1 /*
   2  * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package sun.invoke.anon;
  27 
  28 import java.io.IOException;
  29 import java.io.OutputStream;
  30 import java.nio.BufferUnderflowException;
  31 import java.nio.ByteBuffer;
  32 
  33 import static sun.invoke.anon.ConstantPoolVisitor.*;
  34 
  35 /** A constant pool parser.
  36  */
  37 public class ConstantPoolParser {
  38     final byte[] classFile;
  39     final byte[] tags;
  40     final char[] firstHeader;  // maghi, maglo, minor, major, cplen
  41 
  42     // these are filled in on first parse:
  43     int endOffset;
  44     char[] secondHeader;       // flags, this_class, super_class, intlen
  45 
  46     // used to decode UTF8 array
  47     private char[] charArray = new char[80];
  48 
  49     /** Creates a constant pool parser.
  50      * @param classFile an array of bytes containing a class.
  51      * @throws InvalidConstantPoolFormatException if the header of the class has errors.
  52      */
  53     public ConstantPoolParser(byte[] classFile) throws InvalidConstantPoolFormatException {
  54         this.classFile = classFile;
  55         this.firstHeader = parseHeader(classFile);
  56         this.tags = new byte[firstHeader[4]];
  57     }
  58 
  59     /** Create a constant pool parser by loading the bytecodes of the
  60      *  class taken as argument.
  61      *
  62      * @param templateClass the class to parse.
  63      *
  64      * @throws IOException raised if an I/O occurs when loading
  65      *  the bytecode of the template class.
  66      * @throws InvalidConstantPoolFormatException if the header of the class has errors.
  67      *
  68      * @see #ConstantPoolParser(byte[])
  69      * @see AnonymousClassLoader#readClassFile(Class)
  70      */
  71     public ConstantPoolParser(Class<?> templateClass) throws IOException, InvalidConstantPoolFormatException {
  72         this(AnonymousClassLoader.readClassFile(templateClass));
  73     }
  74 
  75     /** Creates an empty patch to patch the class file
  76      *  used by the current parser.
  77      * @return a new class patch.
  78      */
  79     public ConstantPoolPatch createPatch() {
  80         return new ConstantPoolPatch(this);
  81     }
  82 
  83     /** Report the tag of the indicated CP entry.
  84      * @param index
  85      * @return one of {@link ConstantPoolVisitor#CONSTANT_Utf8}, etc.
  86      */
  87     public byte getTag(int index) {
  88         getEndOffset();  // trigger an exception if we haven't parsed yet
  89         return tags[index];
  90     }
  91 
  92     /** Report the length of the constant pool. */
  93     public int getLength() {
  94         return firstHeader[4];
  95     }
  96 
  97     /** Report the offset, within the class file, of the start of the constant pool. */
  98     public int getStartOffset() {
  99         return firstHeader.length * 2;
 100     }
 101 
 102     /** Report the offset, within the class file, of the end of the constant pool. */
 103     public int getEndOffset() {
 104         if (endOffset == 0)
 105             throw new IllegalStateException("class file has not yet been parsed");
 106         return endOffset;
 107     }
 108 
 109     /** Report the CP index of this class's own name. */
 110     public int getThisClassIndex() {
 111         getEndOffset();   // provoke exception if not yet parsed
 112         return secondHeader[1];
 113     }
 114 
 115     /** Report the total size of the class file. */
 116     public int getTailLength() {
 117         return classFile.length - getEndOffset();
 118     }
 119 
 120     /** Write the head (header plus constant pool)
 121      *  of the class file to the indicated stream.
 122      */
 123     public void writeHead(OutputStream out) throws IOException {
 124         out.write(classFile, 0, getEndOffset());
 125     }
 126 
 127     /** Write the head (header plus constant pool)
 128      *  of the class file to the indicated stream,
 129      *  incorporating the non-null entries of the given array
 130      *  as patches.
 131      */
 132     void writePatchedHead(OutputStream out, Object[] patchArray) {
 133         // this will be useful to partially emulate the class loader on old JVMs
 134         throw new UnsupportedOperationException("Not yet implemented");
 135     }
 136 
 137     /** Write the tail (everything after the constant pool)
 138      *  of the class file to the indicated stream.
 139      */
 140     public void writeTail(OutputStream out) throws IOException {
 141         out.write(classFile, getEndOffset(), getTailLength());
 142     }
 143 
 144     private static char[] parseHeader(byte[] classFile) throws InvalidConstantPoolFormatException {
 145         char[] result = new char[5];
 146         ByteBuffer buffer = ByteBuffer.wrap(classFile);
 147         for (int i = 0; i < result.length; i++)
 148             result[i] = (char) getUnsignedShort(buffer);
 149         int magic = result[0] << 16 | result[1] << 0;
 150         if (magic != 0xCAFEBABE)
 151             throw new InvalidConstantPoolFormatException("invalid magic number "+magic);
 152         // skip major, minor version
 153         int len = result[4];
 154         if (len < 1)
 155             throw new InvalidConstantPoolFormatException("constant pool length < 1");
 156         return result;
 157     }
 158 
 159     /** Parse the constant pool of the class
 160      *  calling a method visit* each time a constant pool entry is parsed.
 161      *
 162      *  The order of the calls to visit* is not guaranteed to be the same
 163      *  than the order of the constant pool entry in the bytecode array.
 164      *
 165      * @param visitor
 166      * @throws InvalidConstantPoolFormatException
 167      */
 168     public void parse(ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {
 169         ByteBuffer buffer = ByteBuffer.wrap(classFile);
 170         buffer.position(getStartOffset()); //skip header
 171 
 172         Object[] values = new Object[getLength()];
 173         try {
 174             parseConstantPool(buffer, values, visitor);
 175         } catch(BufferUnderflowException e) {
 176             throw new InvalidConstantPoolFormatException(e);
 177         }
 178         if (endOffset == 0) {
 179             endOffset = buffer.position();
 180             secondHeader = new char[4];
 181             for (int i = 0; i < secondHeader.length; i++) {
 182                 secondHeader[i] = (char) getUnsignedShort(buffer);
 183             }
 184         }
 185         resolveConstantPool(values, visitor);
 186     }
 187 
 188     private char[] getCharArray(int utfLength) {
 189         if (utfLength <= charArray.length)
 190             return charArray;
 191         return charArray = new char[utfLength];
 192     }
 193 
 194     private void parseConstantPool(ByteBuffer buffer, Object[] values, ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {
 195         for (int i = 1; i < tags.length; ) {
 196             byte tag = (byte) getUnsignedByte(buffer);
 197             assert(tags[i] == 0 || tags[i] == tag);
 198             tags[i] = tag;
 199             switch (tag) {
 200                 case CONSTANT_Utf8:
 201                     int utfLen = getUnsignedShort(buffer);
 202                     String value = getUTF8(buffer, utfLen, getCharArray(utfLen));
 203                     visitor.visitUTF8(i, CONSTANT_Utf8, value);
 204                     tags[i] = tag;
 205                     values[i++] = value;
 206                     break;
 207                 case CONSTANT_Integer:
 208                     visitor.visitConstantValue(i, tag, buffer.getInt());
 209                     i++;
 210                     break;
 211                 case CONSTANT_Float:
 212                     visitor.visitConstantValue(i, tag, buffer.getFloat());
 213                     i++;
 214                     break;
 215                 case CONSTANT_Long:
 216                     visitor.visitConstantValue(i, tag, buffer.getLong());
 217                     i+=2;
 218                     break;
 219                 case CONSTANT_Double:
 220                     visitor.visitConstantValue(i, tag, buffer.getDouble());
 221                     i+=2;
 222                     break;
 223 
 224                 case CONSTANT_Class:    // fall through:
 225                 case CONSTANT_String:
 226                     tags[i] = tag;
 227                     values[i++] = new int[] { getUnsignedShort(buffer) };
 228                     break;
 229 
 230                 case CONSTANT_Fieldref:           // fall through:
 231                 case CONSTANT_Methodref:          // fall through:
 232                 case CONSTANT_InterfaceMethodref: // fall through:
 233                 case CONSTANT_NameAndType:
 234                     tags[i] = tag;
 235                     values[i++] = new int[] { getUnsignedShort(buffer), getUnsignedShort(buffer) };
 236                     break;
 237                 default:
 238                     throw new AssertionError("invalid constant "+tag);
 239             }
 240         }
 241     }
 242 
 243     private void resolveConstantPool(Object[] values, ConstantPoolVisitor visitor) {
 244         // clean out the int[] values, which are temporary
 245         for (int beg = 1, end = values.length-1, beg2, end2;
 246              beg <= end;
 247              beg = beg2, end = end2) {
 248              beg2 = end; end2 = beg-1;
 249              //System.out.println("CP resolve pass: "+beg+".."+end);
 250              for (int i = beg; i <= end; i++) {
 251                   Object value = values[i];
 252                   if (!(value instanceof int[]))
 253                       continue;
 254                   int[] array = (int[]) value;
 255                   byte tag = tags[i];
 256                   switch (tag) {
 257                       case CONSTANT_String:
 258                           String stringBody = (String) values[array[0]];
 259                           visitor.visitConstantString(i, tag, stringBody, array[0]);
 260                           values[i] = null;
 261                           break;
 262                       case CONSTANT_Class: {
 263                           String className = (String) values[array[0]];
 264                           // use the external form favored by Class.forName:
 265                           className = className.replace('/', '.');
 266                           visitor.visitConstantString(i, tag, className, array[0]);
 267                           values[i] = className;
 268                           break;
 269                       }
 270                       case CONSTANT_NameAndType: {
 271                           String memberName = (String) values[array[0]];
 272                           String signature  = (String) values[array[1]];
 273                           visitor.visitDescriptor(i, tag, memberName, signature,
 274                                                   array[0], array[1]);
 275                           values[i] = new String[] {memberName, signature};
 276                           break;
 277                       }
 278                       case CONSTANT_Fieldref:           // fall through:
 279                       case CONSTANT_Methodref:          // fall through:
 280                       case CONSTANT_InterfaceMethodref: {
 281                               Object className   = values[array[0]];
 282                               Object nameAndType = values[array[1]];
 283                               if (!(className instanceof String) ||
 284                                   !(nameAndType instanceof String[])) {
 285                                    // one more pass is needed
 286                                    if (beg2 > i)  beg2 = i;
 287                                    if (end2 < i)  end2 = i;
 288                                    continue;
 289                               }
 290                               String[] nameAndTypeArray = (String[]) nameAndType;
 291                               visitor.visitMemberRef(i, tag,
 292                                   (String)className,
 293                                   nameAndTypeArray[0],
 294                                   nameAndTypeArray[1],
 295                                   array[0], array[1]);
 296                               values[i] = null;
 297                           }
 298                           break;
 299                       default:
 300                           continue;
 301                 }
 302             }
 303         }
 304     }
 305 
 306     private static int getUnsignedByte(ByteBuffer buffer) {
 307         return buffer.get() & 0xFF;
 308     }
 309 
 310     private static int getUnsignedShort(ByteBuffer buffer) {
 311         int b1 = getUnsignedByte(buffer);
 312         int b2 = getUnsignedByte(buffer);
 313         return (b1 << 8) + (b2 << 0);
 314     }
 315 
 316     private static String getUTF8(ByteBuffer buffer, int utfLen, char[] charArray) throws InvalidConstantPoolFormatException {
 317       int utfLimit = buffer.position() + utfLen;
 318       int index = 0;
 319       while (buffer.position() < utfLimit) {
 320           int c = buffer.get() & 0xff;
 321           if (c > 127) {
 322               buffer.position(buffer.position() - 1);
 323               return getUTF8Extended(buffer, utfLimit, charArray, index);
 324           }
 325           charArray[index++] = (char)c;
 326       }
 327       return new String(charArray, 0, index);
 328     }
 329 
 330     private static String getUTF8Extended(ByteBuffer buffer, int utfLimit, char[] charArray, int index) throws InvalidConstantPoolFormatException {
 331         int c, c2, c3;
 332         while (buffer.position() < utfLimit) {
 333             c = buffer.get() & 0xff;
 334             switch (c >> 4) {
 335                 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
 336                     /* 0xxxxxxx*/
 337                     charArray[index++] = (char)c;
 338                     break;
 339                 case 12: case 13:
 340                     /* 110x xxxx   10xx xxxx*/
 341                     c2 = buffer.get();
 342                     if ((c2 & 0xC0) != 0x80)
 343                         throw new InvalidConstantPoolFormatException(
 344                             "malformed input around byte " + buffer.position());
 345                      charArray[index++] = (char)(((c  & 0x1F) << 6) |
 346                                                   (c2 & 0x3F));
 347                     break;
 348                 case 14:
 349                     /* 1110 xxxx  10xx xxxx  10xx xxxx */
 350                     c2 = buffer.get();
 351                     c3 = buffer.get();
 352                     if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80))
 353                        throw new InvalidConstantPoolFormatException(
 354                           "malformed input around byte " + (buffer.position()));
 355                     charArray[index++] = (char)(((c  & 0x0F) << 12) |
 356                                                 ((c2 & 0x3F) << 6)  |
 357                                                 ((c3 & 0x3F) << 0));
 358                     break;
 359                 default:
 360                     /* 10xx xxxx,  1111 xxxx */
 361                     throw new InvalidConstantPoolFormatException(
 362                         "malformed input around byte " + buffer.position());
 363             }
 364         }
 365         // The number of chars produced may be less than utflen
 366         return new String(charArray, 0, index);
 367     }
 368 }