ojluni/src/main/java/sun/invoke/anon/ConstantPoolPatch.java - platform/libcore.git - Git at Google

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

 package sun.invoke.anon;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Map;

 import static sun.invoke.anon.ConstantPoolVisitor.*;

 /** A class and its patched constant pool.
  *
  *  This class allow to modify (patch) a constant pool
  *  by changing the value of its entry.
  *  Entry are referenced using index that can be get
  *  by parsing the constant pool using
  *  {@link ConstantPoolParser#parse(ConstantPoolVisitor)}.
  *
  * @see ConstantPoolVisitor
  * @see ConstantPoolParser#createPatch()
  */
 public class ConstantPoolPatch {
     final ConstantPoolParser outer;
     final Object[] patchArray;

     ConstantPoolPatch(ConstantPoolParser outer) {
         this.outer      = outer;
         this.patchArray = new Object[outer.getLength()];
     }

     /** Create a {@link ConstantPoolParser} and
      *  a {@link ConstantPoolPatch} in one step.
      *  Equivalent to {@code new ConstantPoolParser(classFile).createPatch()}.
      *
      * @param classFile an array of bytes containing a class.
      * @see #ConstantPoolParser(Class)
      */
     public ConstantPoolPatch(byte[] classFile) throws InvalidConstantPoolFormatException {
         this(new ConstantPoolParser(classFile));
     }

     /** Create a {@link ConstantPoolParser} and
      *  a {@link ConstantPoolPatch} in one step.
      *  Equivalent to {@code new ConstantPoolParser(templateClass).createPatch()}.
      *
      * @param templateClass the class to parse.
      * @see #ConstantPoolParser(Class)
      */
     public ConstantPoolPatch(Class<?> templateClass) throws IOException, InvalidConstantPoolFormatException {
         this(new ConstantPoolParser(templateClass));
     }


     /** Creates a patch from an existing patch.
      *  All changes are copied from that patch.
      * @param patch a patch
      *
      * @see ConstantPoolParser#createPatch()
      */
     public ConstantPoolPatch(ConstantPoolPatch patch) {
         outer      = patch.outer;
         patchArray = patch.patchArray.clone();
     }

     /** Which parser built this patch? */
     public ConstantPoolParser getParser() {
         return outer;
     }

     /** Report the tag at the given index in the constant pool. */
     public byte getTag(int index) {
         return outer.getTag(index);
     }

     /** Report the current patch at the given index of the constant pool.
      *  Null means no patch will be made.
      *  To observe the unpatched entry at the given index, use
      *  {@link #getParser()}{@code .}@link ConstantPoolParser#parse(ConstantPoolVisitor)}
      */
     public Object getPatch(int index) {
         Object value = patchArray[index];
         if (value == null)  return null;
         switch (getTag(index)) {
         case CONSTANT_Fieldref:
         case CONSTANT_Methodref:
         case CONSTANT_InterfaceMethodref:
             if (value instanceof String)
                 value = stripSemis(2, (String) value);
             break;
         case CONSTANT_NameAndType:
             if (value instanceof String)
                 value = stripSemis(1, (String) value);
             break;
         }
         return value;
     }

     /** Clear all patches. */
     public void clear() {
         Arrays.fill(patchArray, null);
     }

     /** Clear one patch. */
     public void clear(int index) {
         patchArray[index] = null;
     }

     /** Produce the patches as an array. */
     public Object[] getPatches() {
         return patchArray.clone();
     }

     /** Produce the original constant pool as an array. */
     public Object[] getOriginalCP() throws InvalidConstantPoolFormatException {
         return getOriginalCP(0, patchArray.length, -1);
     }

     /** Walk the constant pool, applying patches using the given map.
      *
      * @param utf8Map Utf8 strings to modify, if encountered
      * @param classMap Classes (or their names) to modify, if encountered
      * @param valueMap Constant values to modify, if encountered
      * @param deleteUsedEntries if true, delete map entries that are used
      */
     public void putPatches(final Map<String,String> utf8Map,
                            final Map<String,Object> classMap,
                            final Map<Object,Object> valueMap,
                            boolean deleteUsedEntries) throws InvalidConstantPoolFormatException {
         final HashSet<String> usedUtf8Keys;
         final HashSet<String> usedClassKeys;
         final HashSet<Object> usedValueKeys;
         if (deleteUsedEntries) {
             usedUtf8Keys  = (utf8Map  == null) ? null : new HashSet<String>();
             usedClassKeys = (classMap == null) ? null : new HashSet<String>();
             usedValueKeys = (valueMap == null) ? null : new HashSet<Object>();
         } else {
             usedUtf8Keys = null;
             usedClassKeys = null;
             usedValueKeys = null;
         }

         outer.parse(new ConstantPoolVisitor() {

             @Override
             public void visitUTF8(int index, byte tag, String utf8) {
                 putUTF8(index, utf8Map.get(utf8));
                 if (usedUtf8Keys != null)  usedUtf8Keys.add(utf8);
             }

             @Override
             public void visitConstantValue(int index, byte tag, Object value) {
                 putConstantValue(index, tag, valueMap.get(value));
                 if (usedValueKeys != null)  usedValueKeys.add(value);
             }

             @Override
             public void visitConstantString(int index, byte tag, String name, int nameIndex) {
                 if (tag == CONSTANT_Class) {
                     putConstantValue(index, tag, classMap.get(name));
                     if (usedClassKeys != null)  usedClassKeys.add(name);
                 } else {
                     assert(tag == CONSTANT_String);
                     visitConstantValue(index, tag, name);
                 }
             }
         });
         if (usedUtf8Keys != null)   utf8Map.keySet().removeAll(usedUtf8Keys);
         if (usedClassKeys != null)  classMap.keySet().removeAll(usedClassKeys);
         if (usedValueKeys != null)  valueMap.keySet().removeAll(usedValueKeys);
     }

     Object[] getOriginalCP(final int startIndex,
                            final int endIndex,
                            final int tagMask) throws InvalidConstantPoolFormatException {
         final Object[] cpArray = new Object[endIndex - startIndex];
         outer.parse(new ConstantPoolVisitor() {

             void show(int index, byte tag, Object value) {
                 if (index < startIndex || index >= endIndex)  return;
                 if (((1 << tag) & tagMask) == 0)  return;
                 cpArray[index - startIndex] = value;
             }

             @Override
             public void visitUTF8(int index, byte tag, String utf8) {
                 show(index, tag, utf8);
             }

             @Override
             public void visitConstantValue(int index, byte tag, Object value) {
                 assert(tag != CONSTANT_String);
                 show(index, tag, value);
             }

             @Override
             public void visitConstantString(int index, byte tag,
                                             String value, int j) {
                 show(index, tag, value);
             }

             @Override
             public void visitMemberRef(int index, byte tag,
                     String className, String memberName,
                     String signature,
                     int j, int k) {
                 show(index, tag, new String[]{ className, memberName, signature });
             }

             @Override
             public void visitDescriptor(int index, byte tag,
                     String memberName, String signature,
                     int j, int k) {
                 show(index, tag, new String[]{ memberName, signature });
             }
         });
         return cpArray;
     }

     /** Write the head (header plus constant pool)
      *  of the patched class file to the indicated stream.
      */
     void writeHead(OutputStream out) throws IOException {
         outer.writePatchedHead(out, patchArray);
     }

     /** Write the tail (everything after the constant pool)
      *  of the patched class file to the indicated stream.
      */
     void writeTail(OutputStream out) throws IOException {
         outer.writeTail(out);
     }

     private void checkConstantTag(byte tag, Object value) {
         if (value == null)
             throw new IllegalArgumentException(
                     "invalid null constant value");
         if (classForTag(tag) != value.getClass())
             throw new IllegalArgumentException(
                     "invalid constant value"
                     + (tag == CONSTANT_None ? ""
                         : " for tag "+tagName(tag))
                     + " of class "+value.getClass());
     }

     private void checkTag(int index, byte putTag) {
         byte tag = outer.tags[index];
         if (tag != putTag)
             throw new IllegalArgumentException(
                 "invalid put operation"
                 + " for " + tagName(putTag)
                 + " at index " + index + " found " + tagName(tag));
     }

     private void checkTagMask(int index, int tagBitMask) {
         byte tag = outer.tags[index];
         int tagBit = ((tag & 0x1F) == tag) ? (1 << tag) : 0;
         if ((tagBit & tagBitMask) == 0)
             throw new IllegalArgumentException(
                 "invalid put operation"
                 + " at index " + index + " found " + tagName(tag));
     }

     private static void checkMemberName(String memberName) {
         if (memberName.indexOf(';') >= 0)
             throw new IllegalArgumentException("memberName " + memberName + " contains a ';'");
     }

     /** Set the entry of the constant pool indexed by index to
      *  a new string.
      *
      * @param index an index to a constant pool entry containing a
      *        {@link ConstantPoolVisitor#CONSTANT_Utf8} value.
      * @param utf8 a string
      *
      * @see ConstantPoolVisitor#visitUTF8(int, byte, String)
      */
     public void putUTF8(int index, String utf8) {
         if (utf8 == null) { clear(index); return; }
         checkTag(index, CONSTANT_Utf8);
         patchArray[index] = utf8;
     }

     /** Set the entry of the constant pool indexed by index to
      *  a new value, depending on its dynamic type.
      *
      * @param index an index to a constant pool entry containing a
      *        one of the following structures:
      *        {@link ConstantPoolVisitor#CONSTANT_Integer},
      *        {@link ConstantPoolVisitor#CONSTANT_Float},
      *        {@link ConstantPoolVisitor#CONSTANT_Long},
      *        {@link ConstantPoolVisitor#CONSTANT_Double},
      *        {@link ConstantPoolVisitor#CONSTANT_String}, or
      *        {@link ConstantPoolVisitor#CONSTANT_Class}
      * @param value a boxed int, float, long or double; or a string or class object
      * @throws IllegalArgumentException if the type of the constant does not
      *         match the constant pool entry type,
      *         as reported by {@link #getTag(int)}
      *
      * @see #putConstantValue(int, byte, Object)
      * @see ConstantPoolVisitor#visitConstantValue(int, byte, Object)
      * @see ConstantPoolVisitor#visitConstantString(int, byte, String, int)
      */
     public void putConstantValue(int index, Object value) {
         if (value == null) { clear(index); return; }
         byte tag = tagForConstant(value.getClass());
         checkConstantTag(tag, value);
         checkTag(index, tag);
         patchArray[index] = value;
     }

     /** Set the entry of the constant pool indexed by index to
      *  a new value.
      *
      * @param index an index to a constant pool entry matching the given tag
      * @param tag one of the following values:
      *        {@link ConstantPoolVisitor#CONSTANT_Integer},
      *        {@link ConstantPoolVisitor#CONSTANT_Float},
      *        {@link ConstantPoolVisitor#CONSTANT_Long},
      *        {@link ConstantPoolVisitor#CONSTANT_Double},
      *        {@link ConstantPoolVisitor#CONSTANT_String}, or
      *        {@link ConstantPoolVisitor#CONSTANT_Class}
      * @param value a boxed number, string, or class object
      * @throws IllegalArgumentException if the type of the constant does not
      *         match the constant pool entry type, or if a class name contains
      *         '/' or ';'
      *
      * @see #putConstantValue(int, Object)
      * @see ConstantPoolVisitor#visitConstantValue(int, byte, Object)
      * @see ConstantPoolVisitor#visitConstantString(int, byte, String, int)
      */
     public void putConstantValue(int index, byte tag, Object value) {
         if (value == null) { clear(index); return; }
         checkTag(index, tag);
         if (tag == CONSTANT_Class && value instanceof String) {
             checkClassName((String) value);
         } else if (tag == CONSTANT_String) {
             // the JVM accepts any object as a patch for a string
         } else {
             // make sure the incoming value is the right type
             checkConstantTag(tag, value);
         }
         checkTag(index, tag);
         patchArray[index] = value;
     }

     /** Set the entry of the constant pool indexed by index to
      *  a new {@link ConstantPoolVisitor#CONSTANT_NameAndType} value.
      *
      * @param index an index to a constant pool entry containing a
      *        {@link ConstantPoolVisitor#CONSTANT_NameAndType} value.
      * @param memberName a memberName
      * @param signature a signature
      * @throws IllegalArgumentException if memberName contains the character ';'
      *
      * @see ConstantPoolVisitor#visitDescriptor(int, byte, String, String, int, int)
      */
     public void putDescriptor(int index, String memberName, String signature) {
         checkTag(index, CONSTANT_NameAndType);
         checkMemberName(memberName);
         patchArray[index] = addSemis(memberName, signature);
     }

     /** Set the entry of the constant pool indexed by index to
      *  a new {@link ConstantPoolVisitor#CONSTANT_Fieldref},
      *  {@link ConstantPoolVisitor#CONSTANT_Methodref}, or
      *  {@link ConstantPoolVisitor#CONSTANT_InterfaceMethodref} value.
      *
      * @param index an index to a constant pool entry containing a member reference
      * @param className a class name
      * @param memberName a field or method name
      * @param signature a field or method signature
      * @throws IllegalArgumentException if memberName contains the character ';'
      *             or signature is not a correct signature
      *
      * @see ConstantPoolVisitor#visitMemberRef(int, byte, String, String, String, int, int)
      */
     public void putMemberRef(int index, byte tag,
                     String className, String memberName, String signature) {
         checkTagMask(tag, CONSTANT_MemberRef_MASK);
         checkTag(index, tag);
         checkClassName(className);
         checkMemberName(memberName);
         if (signature.startsWith("(") == (tag == CONSTANT_Fieldref))
             throw new IllegalArgumentException("bad signature: "+signature);
         patchArray[index] = addSemis(className, memberName, signature);
     }

     static private final int CONSTANT_MemberRef_MASK =
               CONSTANT_Fieldref
             | CONSTANT_Methodref
             | CONSTANT_InterfaceMethodref;

     private static final Map<Class<?>, Byte> CONSTANT_VALUE_CLASS_TAG
         = new IdentityHashMap<Class<?>, Byte>();
     private static final Class[] CONSTANT_VALUE_CLASS = new Class[16];
     static {
         Object[][] values = {
             {Integer.class, CONSTANT_Integer},
             {Long.class, CONSTANT_Long},
             {Float.class, CONSTANT_Float},
             {Double.class, CONSTANT_Double},
             {String.class, CONSTANT_String},
             {Class.class, CONSTANT_Class}
         };
         for (Object[] value : values) {
             Class<?> cls = (Class<?>)value[0];
             Byte     tag = (Byte) value[1];
             CONSTANT_VALUE_CLASS_TAG.put(cls, tag);
             CONSTANT_VALUE_CLASS[(byte)tag] = cls;
         }
     }

     static Class<?> classForTag(byte tag) {
         if ((tag & 0xFF) >= CONSTANT_VALUE_CLASS.length)
             return null;
         return CONSTANT_VALUE_CLASS[tag];
     }

     static byte tagForConstant(Class<?> cls) {
         Byte tag = CONSTANT_VALUE_CLASS_TAG.get(cls);
         return (tag == null) ? CONSTANT_None : (byte)tag;
     }

     private static void checkClassName(String className) {
         if (className.indexOf('/') >= 0 || className.indexOf(';') >= 0)
             throw new IllegalArgumentException("invalid class name " + className);
     }

     static String addSemis(String name, String... names) {
         StringBuilder buf = new StringBuilder(name.length() * 5);
         buf.append(name);
         for (String name2 : names) {
             buf.append(';').append(name2);
         }
         String res = buf.toString();
         assert(stripSemis(names.length, res)[0].equals(name));
         assert(stripSemis(names.length, res)[1].equals(names[0]));
         assert(names.length == 1 ||
                stripSemis(names.length, res)[2].equals(names[1]));
         return res;
     }

     static String[] stripSemis(int count, String string) {
         String[] res = new String[count+1];
         int pos = 0;
         for (int i = 0; i < count; i++) {
             int pos2 = string.indexOf(';', pos);
             if (pos2 < 0)  pos2 = string.length();  // yuck
             res[i] = string.substring(pos, pos2);
             pos = pos2;
         }
         res[count] = string.substring(pos);
         return res;
     }

     public String toString() {
         StringBuilder buf = new StringBuilder(this.getClass().getName());
         buf.append("{");
         Object[] origCP = null;
         for (int i = 0; i < patchArray.length; i++) {
             if (patchArray[i] == null)  continue;
             if (origCP != null) {
                 buf.append(", ");
             } else {
                 try {
                     origCP = getOriginalCP();
                 } catch (InvalidConstantPoolFormatException ee) {
                     origCP = new Object[0];
                 }
             }
             Object orig = (i < origCP.length) ? origCP[i] : "?";
             buf.append(orig).append("=").append(patchArray[i]);
         }
         buf.append("}");
         return buf.toString();
     }
 }
	/*
	* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.invoke.anon;

	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.Arrays;
	import java.util.HashSet;
	import java.util.IdentityHashMap;
	import java.util.Map;

	import static sun.invoke.anon.ConstantPoolVisitor.*;

	/** A class and its patched constant pool.
	*
	* This class allow to modify (patch) a constant pool
	* by changing the value of its entry.
	* Entry are referenced using index that can be get
	* by parsing the constant pool using
	* {@link ConstantPoolParser#parse(ConstantPoolVisitor)}.
	*
	* @see ConstantPoolVisitor
	* @see ConstantPoolParser#createPatch()
	*/
	public class ConstantPoolPatch {
	final ConstantPoolParser outer;
	final Object[] patchArray;

	ConstantPoolPatch(ConstantPoolParser outer) {
	this.outer = outer;
	this.patchArray = new Object[outer.getLength()];
	}

	/** Create a {@link ConstantPoolParser} and
	* a {@link ConstantPoolPatch} in one step.
	* Equivalent to {@code new ConstantPoolParser(classFile).createPatch()}.
	*
	* @param classFile an array of bytes containing a class.
	* @see #ConstantPoolParser(Class)
	*/
	public ConstantPoolPatch(byte[] classFile) throws InvalidConstantPoolFormatException {
	this(new ConstantPoolParser(classFile));
	}

	/** Create a {@link ConstantPoolParser} and
	* a {@link ConstantPoolPatch} in one step.
	* Equivalent to {@code new ConstantPoolParser(templateClass).createPatch()}.
	*
	* @param templateClass the class to parse.
	* @see #ConstantPoolParser(Class)
	*/
	public ConstantPoolPatch(Class<?> templateClass) throws IOException, InvalidConstantPoolFormatException {
	this(new ConstantPoolParser(templateClass));
	}


	/** Creates a patch from an existing patch.
	* All changes are copied from that patch.
	* @param patch a patch
	*
	* @see ConstantPoolParser#createPatch()
	*/
	public ConstantPoolPatch(ConstantPoolPatch patch) {
	outer = patch.outer;
	patchArray = patch.patchArray.clone();
	}

	/** Which parser built this patch? */
	public ConstantPoolParser getParser() {
	return outer;
	}

	/** Report the tag at the given index in the constant pool. */
	public byte getTag(int index) {
	return outer.getTag(index);
	}

	/** Report the current patch at the given index of the constant pool.
	* Null means no patch will be made.
	* To observe the unpatched entry at the given index, use
	* {@link #getParser()}{@code .}@link ConstantPoolParser#parse(ConstantPoolVisitor)}
	*/
	public Object getPatch(int index) {
	Object value = patchArray[index];
	if (value == null) return null;
	switch (getTag(index)) {
	case CONSTANT_Fieldref:
	case CONSTANT_Methodref:
	case CONSTANT_InterfaceMethodref:
	if (value instanceof String)
	value = stripSemis(2, (String) value);
	break;
	case CONSTANT_NameAndType:
	if (value instanceof String)
	value = stripSemis(1, (String) value);
	break;
	}
	return value;
	}

	/** Clear all patches. */
	public void clear() {
	Arrays.fill(patchArray, null);
	}

	/** Clear one patch. */
	public void clear(int index) {
	patchArray[index] = null;
	}

	/** Produce the patches as an array. */
	public Object[] getPatches() {
	return patchArray.clone();
	}

	/** Produce the original constant pool as an array. */
	public Object[] getOriginalCP() throws InvalidConstantPoolFormatException {
	return getOriginalCP(0, patchArray.length, -1);
	}

	/** Walk the constant pool, applying patches using the given map.
	*
	* @param utf8Map Utf8 strings to modify, if encountered
	* @param classMap Classes (or their names) to modify, if encountered
	* @param valueMap Constant values to modify, if encountered
	* @param deleteUsedEntries if true, delete map entries that are used
	*/
	public void putPatches(final Map<String,String> utf8Map,
	final Map<String,Object> classMap,
	final Map<Object,Object> valueMap,
	boolean deleteUsedEntries) throws InvalidConstantPoolFormatException {
	final HashSet<String> usedUtf8Keys;
	final HashSet<String> usedClassKeys;
	final HashSet<Object> usedValueKeys;
	if (deleteUsedEntries) {
	usedUtf8Keys = (utf8Map == null) ? null : new HashSet<String>();
	usedClassKeys = (classMap == null) ? null : new HashSet<String>();
	usedValueKeys = (valueMap == null) ? null : new HashSet<Object>();
	} else {
	usedUtf8Keys = null;
	usedClassKeys = null;
	usedValueKeys = null;
	}

	outer.parse(new ConstantPoolVisitor() {

	@Override
	public void visitUTF8(int index, byte tag, String utf8) {
	putUTF8(index, utf8Map.get(utf8));
	if (usedUtf8Keys != null) usedUtf8Keys.add(utf8);
	}

	@Override
	public void visitConstantValue(int index, byte tag, Object value) {
	putConstantValue(index, tag, valueMap.get(value));
	if (usedValueKeys != null) usedValueKeys.add(value);
	}

	@Override
	public void visitConstantString(int index, byte tag, String name, int nameIndex) {
	if (tag == CONSTANT_Class) {
	putConstantValue(index, tag, classMap.get(name));
	if (usedClassKeys != null) usedClassKeys.add(name);
	} else {
	assert(tag == CONSTANT_String);
	visitConstantValue(index, tag, name);
	}
	}
	});
	if (usedUtf8Keys != null) utf8Map.keySet().removeAll(usedUtf8Keys);
	if (usedClassKeys != null) classMap.keySet().removeAll(usedClassKeys);
	if (usedValueKeys != null) valueMap.keySet().removeAll(usedValueKeys);
	}

	Object[] getOriginalCP(final int startIndex,
	final int endIndex,
	final int tagMask) throws InvalidConstantPoolFormatException {
	final Object[] cpArray = new Object[endIndex - startIndex];
	outer.parse(new ConstantPoolVisitor() {

	void show(int index, byte tag, Object value) {
	if (index < startIndex \|\| index >= endIndex) return;
	if (((1 << tag) & tagMask) == 0) return;
	cpArray[index - startIndex] = value;
	}

	@Override
	public void visitUTF8(int index, byte tag, String utf8) {
	show(index, tag, utf8);
	}

	@Override
	public void visitConstantValue(int index, byte tag, Object value) {
	assert(tag != CONSTANT_String);
	show(index, tag, value);
	}

	@Override
	public void visitConstantString(int index, byte tag,
	String value, int j) {
	show(index, tag, value);
	}

	@Override
	public void visitMemberRef(int index, byte tag,
	String className, String memberName,
	String signature,
	int j, int k) {
	show(index, tag, new String[]{ className, memberName, signature });
	}

	@Override
	public void visitDescriptor(int index, byte tag,
	String memberName, String signature,
	int j, int k) {
	show(index, tag, new String[]{ memberName, signature });
	}
	});
	return cpArray;
	}

	/** Write the head (header plus constant pool)
	* of the patched class file to the indicated stream.
	*/
	void writeHead(OutputStream out) throws IOException {
	outer.writePatchedHead(out, patchArray);
	}

	/** Write the tail (everything after the constant pool)
	* of the patched class file to the indicated stream.
	*/
	void writeTail(OutputStream out) throws IOException {
	outer.writeTail(out);
	}

	private void checkConstantTag(byte tag, Object value) {
	if (value == null)
	throw new IllegalArgumentException(
	"invalid null constant value");
	if (classForTag(tag) != value.getClass())
	throw new IllegalArgumentException(
	"invalid constant value"
	+ (tag == CONSTANT_None ? ""
	: " for tag "+tagName(tag))
	+ " of class "+value.getClass());
	}

	private void checkTag(int index, byte putTag) {
	byte tag = outer.tags[index];
	if (tag != putTag)
	throw new IllegalArgumentException(
	"invalid put operation"
	+ " for " + tagName(putTag)
	+ " at index " + index + " found " + tagName(tag));
	}

	private void checkTagMask(int index, int tagBitMask) {
	byte tag = outer.tags[index];
	int tagBit = ((tag & 0x1F) == tag) ? (1 << tag) : 0;
	if ((tagBit & tagBitMask) == 0)
	throw new IllegalArgumentException(
	"invalid put operation"
	+ " at index " + index + " found " + tagName(tag));
	}

	private static void checkMemberName(String memberName) {
	if (memberName.indexOf(';') >= 0)
	throw new IllegalArgumentException("memberName " + memberName + " contains a ';'");
	}

	/** Set the entry of the constant pool indexed by index to
	* a new string.
	*
	* @param index an index to a constant pool entry containing a
	* {@link ConstantPoolVisitor#CONSTANT_Utf8} value.
	* @param utf8 a string
	*
	* @see ConstantPoolVisitor#visitUTF8(int, byte, String)
	*/
	public void putUTF8(int index, String utf8) {
	if (utf8 == null) { clear(index); return; }
	checkTag(index, CONSTANT_Utf8);
	patchArray[index] = utf8;
	}

	/** Set the entry of the constant pool indexed by index to
	* a new value, depending on its dynamic type.
	*
	* @param index an index to a constant pool entry containing a
	* one of the following structures:
	* {@link ConstantPoolVisitor#CONSTANT_Integer},
	* {@link ConstantPoolVisitor#CONSTANT_Float},
	* {@link ConstantPoolVisitor#CONSTANT_Long},
	* {@link ConstantPoolVisitor#CONSTANT_Double},
	* {@link ConstantPoolVisitor#CONSTANT_String}, or
	* {@link ConstantPoolVisitor#CONSTANT_Class}
	* @param value a boxed int, float, long or double; or a string or class object
	* @throws IllegalArgumentException if the type of the constant does not
	* match the constant pool entry type,
	* as reported by {@link #getTag(int)}
	*
	* @see #putConstantValue(int, byte, Object)
	* @see ConstantPoolVisitor#visitConstantValue(int, byte, Object)
	* @see ConstantPoolVisitor#visitConstantString(int, byte, String, int)
	*/
	public void putConstantValue(int index, Object value) {
	if (value == null) { clear(index); return; }
	byte tag = tagForConstant(value.getClass());
	checkConstantTag(tag, value);
	checkTag(index, tag);
	patchArray[index] = value;
	}

	/** Set the entry of the constant pool indexed by index to
	* a new value.
	*
	* @param index an index to a constant pool entry matching the given tag
	* @param tag one of the following values:
	* {@link ConstantPoolVisitor#CONSTANT_Integer},
	* {@link ConstantPoolVisitor#CONSTANT_Float},
	* {@link ConstantPoolVisitor#CONSTANT_Long},
	* {@link ConstantPoolVisitor#CONSTANT_Double},
	* {@link ConstantPoolVisitor#CONSTANT_String}, or
	* {@link ConstantPoolVisitor#CONSTANT_Class}
	* @param value a boxed number, string, or class object
	* @throws IllegalArgumentException if the type of the constant does not
	* match the constant pool entry type, or if a class name contains
	* '/' or ';'
	*
	* @see #putConstantValue(int, Object)
	* @see ConstantPoolVisitor#visitConstantValue(int, byte, Object)
	* @see ConstantPoolVisitor#visitConstantString(int, byte, String, int)
	*/
	public void putConstantValue(int index, byte tag, Object value) {
	if (value == null) { clear(index); return; }
	checkTag(index, tag);
	if (tag == CONSTANT_Class && value instanceof String) {
	checkClassName((String) value);
	} else if (tag == CONSTANT_String) {
	// the JVM accepts any object as a patch for a string
	} else {
	// make sure the incoming value is the right type
	checkConstantTag(tag, value);
	}
	checkTag(index, tag);
	patchArray[index] = value;
	}

	/** Set the entry of the constant pool indexed by index to
	* a new {@link ConstantPoolVisitor#CONSTANT_NameAndType} value.
	*
	* @param index an index to a constant pool entry containing a
	* {@link ConstantPoolVisitor#CONSTANT_NameAndType} value.
	* @param memberName a memberName
	* @param signature a signature
	* @throws IllegalArgumentException if memberName contains the character ';'
	*
	* @see ConstantPoolVisitor#visitDescriptor(int, byte, String, String, int, int)
	*/
	public void putDescriptor(int index, String memberName, String signature) {
	checkTag(index, CONSTANT_NameAndType);
	checkMemberName(memberName);
	patchArray[index] = addSemis(memberName, signature);
	}

	/** Set the entry of the constant pool indexed by index to
	* a new {@link ConstantPoolVisitor#CONSTANT_Fieldref},
	* {@link ConstantPoolVisitor#CONSTANT_Methodref}, or
	* {@link ConstantPoolVisitor#CONSTANT_InterfaceMethodref} value.
	*
	* @param index an index to a constant pool entry containing a member reference
	* @param className a class name
	* @param memberName a field or method name
	* @param signature a field or method signature
	* @throws IllegalArgumentException if memberName contains the character ';'
	* or signature is not a correct signature
	*
	* @see ConstantPoolVisitor#visitMemberRef(int, byte, String, String, String, int, int)
	*/
	public void putMemberRef(int index, byte tag,
	String className, String memberName, String signature) {
	checkTagMask(tag, CONSTANT_MemberRef_MASK);
	checkTag(index, tag);
	checkClassName(className);
	checkMemberName(memberName);
	if (signature.startsWith("(") == (tag == CONSTANT_Fieldref))
	throw new IllegalArgumentException("bad signature: "+signature);
	patchArray[index] = addSemis(className, memberName, signature);
	}

	static private final int CONSTANT_MemberRef_MASK =
	CONSTANT_Fieldref
	\| CONSTANT_Methodref
	\| CONSTANT_InterfaceMethodref;

	private static final Map<Class<?>, Byte> CONSTANT_VALUE_CLASS_TAG
	= new IdentityHashMap<Class<?>, Byte>();
	private static final Class[] CONSTANT_VALUE_CLASS = new Class[16];
	static {
	Object[][] values = {
	{Integer.class, CONSTANT_Integer},
	{Long.class, CONSTANT_Long},
	{Float.class, CONSTANT_Float},
	{Double.class, CONSTANT_Double},
	{String.class, CONSTANT_String},
	{Class.class, CONSTANT_Class}
	};
	for (Object[] value : values) {
	Class<?> cls = (Class<?>)value[0];
	Byte tag = (Byte) value[1];
	CONSTANT_VALUE_CLASS_TAG.put(cls, tag);
	CONSTANT_VALUE_CLASS[(byte)tag] = cls;
	}
	}

	static Class<?> classForTag(byte tag) {
	if ((tag & 0xFF) >= CONSTANT_VALUE_CLASS.length)
	return null;
	return CONSTANT_VALUE_CLASS[tag];
	}

	static byte tagForConstant(Class<?> cls) {
	Byte tag = CONSTANT_VALUE_CLASS_TAG.get(cls);
	return (tag == null) ? CONSTANT_None : (byte)tag;
	}

	private static void checkClassName(String className) {
	if (className.indexOf('/') >= 0 \|\| className.indexOf(';') >= 0)
	throw new IllegalArgumentException("invalid class name " + className);
	}

	static String addSemis(String name, String... names) {
	StringBuilder buf = new StringBuilder(name.length() * 5);
	buf.append(name);
	for (String name2 : names) {
	buf.append(';').append(name2);
	}
	String res = buf.toString();
	assert(stripSemis(names.length, res)[0].equals(name));
	assert(stripSemis(names.length, res)[1].equals(names[0]));
	assert(names.length == 1 \|\|
	stripSemis(names.length, res)[2].equals(names[1]));
	return res;
	}

	static String[] stripSemis(int count, String string) {
	String[] res = new String[count+1];
	int pos = 0;
	for (int i = 0; i < count; i++) {
	int pos2 = string.indexOf(';', pos);
	if (pos2 < 0) pos2 = string.length(); // yuck
	res[i] = string.substring(pos, pos2);
	pos = pos2;
	}
	res[count] = string.substring(pos);
	return res;
	}

	public String toString() {
	StringBuilder buf = new StringBuilder(this.getClass().getName());
	buf.append("{");
	Object[] origCP = null;
	for (int i = 0; i < patchArray.length; i++) {
	if (patchArray[i] == null) continue;
	if (origCP != null) {
	buf.append(", ");
	} else {
	try {
	origCP = getOriginalCP();
	} catch (InvalidConstantPoolFormatException ee) {
	origCP = new Object[0];
	}
	}
	Object orig = (i < origCP.length) ? origCP[i] : "?";
	buf.append(orig).append("=").append(patchArray[i]);
	}
	buf.append("}");
	return buf.toString();
	}
	}