/*

  * 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.nio.BufferUnderflowException;

 import java.nio.ByteBuffer;

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

 /** A constant pool parser.

  */

 public class ConstantPoolParser {

     final byte[] classFile;

     final byte[] tags;

     final char[] firstHeader;  // maghi, maglo, minor, major, cplen

     // these are filled in on first parse:

     int endOffset;

     char[] secondHeader;       // flags, this_class, super_class, intlen

     // used to decode UTF8 array

     private char[] charArray = new char[80];

     /** Creates a constant pool parser.

      * @param classFile an array of bytes containing a class.

      * @throws InvalidConstantPoolFormatException if the header of the class has errors.

      */

     public ConstantPoolParser(byte[] classFile) throws InvalidConstantPoolFormatException {

         this.classFile = classFile;

         this.firstHeader = parseHeader(classFile);

         this.tags = new byte[firstHeader[4]];

     }

     /** Create a constant pool parser by loading the bytecodes of the

      *  class taken as argument.

      *

      * @param templateClass the class to parse.

      *

      * @throws IOException raised if an I/O occurs when loading

      *  the bytecode of the template class.

      * @throws InvalidConstantPoolFormatException if the header of the class has errors.

      *

      * @see #ConstantPoolParser(byte[])

      * @see AnonymousClassLoader#readClassFile(Class)

      */

     public ConstantPoolParser(Class<?> templateClass) throws IOException, InvalidConstantPoolFormatException {

         this(AnonymousClassLoader.readClassFile(templateClass));

     }

     /** Creates an empty patch to patch the class file

      *  used by the current parser.

      * @return a new class patch.

      */

     public ConstantPoolPatch createPatch() {

         return new ConstantPoolPatch(this);

     }

     /** Report the tag of the indicated CP entry.

      * @param index

      * @return one of {@link ConstantPoolVisitor#CONSTANT_Utf8}, etc.

      */

     public byte getTag(int index) {

         getEndOffset();  // trigger an exception if we haven't parsed yet

         return tags[index];

     }

     /** Report the length of the constant pool. */

     public int getLength() {

         return firstHeader[4];

     }

     /** Report the offset, within the class file, of the start of the constant pool. */

     public int getStartOffset() {

         return firstHeader.length * 2;

     }

     /** Report the offset, within the class file, of the end of the constant pool. */

     public int getEndOffset() {

         if (endOffset == 0)

             throw new IllegalStateException("class file has not yet been parsed");

         return endOffset;

     }

     /** Report the CP index of this class's own name. */

     public int getThisClassIndex() {

         getEndOffset();   // provoke exception if not yet parsed

         return secondHeader[1];

     }

     /** Report the total size of the class file. */

     public int getTailLength() {

         return classFile.length - getEndOffset();

     }

     /** Write the head (header plus constant pool)

      *  of the class file to the indicated stream.

      */

     public void writeHead(OutputStream out) throws IOException {

         out.write(classFile, 0, getEndOffset());

     }

     /** Write the head (header plus constant pool)

      *  of the class file to the indicated stream,

      *  incorporating the non-null entries of the given array

      *  as patches.

      */

     void writePatchedHead(OutputStream out, Object[] patchArray) {

         // this will be useful to partially emulate the class loader on old JVMs

         throw new UnsupportedOperationException("Not yet implemented");

     }

     /** Write the tail (everything after the constant pool)

      *  of the class file to the indicated stream.

      */

     public void writeTail(OutputStream out) throws IOException {

         out.write(classFile, getEndOffset(), getTailLength());

     }

     private static char[] parseHeader(byte[] classFile) throws InvalidConstantPoolFormatException {

         char[] result = new char[5];

         ByteBuffer buffer = ByteBuffer.wrap(classFile);

         for (int i = 0; i < result.length; i++)

             result[i] = (char) getUnsignedShort(buffer);

         int magic = result[0] << 16 | result[1] << 0;

         if (magic != 0xCAFEBABE)

             throw new InvalidConstantPoolFormatException("invalid magic number "+magic);

         // skip major, minor version

         int len = result[4];

         if (len < 1)

             throw new InvalidConstantPoolFormatException("constant pool length < 1");

         return result;

     }

     /** Parse the constant pool of the class

      *  calling a method visit* each time a constant pool entry is parsed.

      *

      *  The order of the calls to visit* is not guaranteed to be the same

      *  than the order of the constant pool entry in the bytecode array.

      *

      * @param visitor

      * @throws InvalidConstantPoolFormatException

      */

     public void parse(ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {

         ByteBuffer buffer = ByteBuffer.wrap(classFile);

         buffer.position(getStartOffset()); //skip header

         Object[] values = new Object[getLength()];

         try {

             parseConstantPool(buffer, values, visitor);

         } catch(BufferUnderflowException e) {

             throw new InvalidConstantPoolFormatException(e);

         }

         if (endOffset == 0) {

             endOffset = buffer.position();

             secondHeader = new char[4];

             for (int i = 0; i < secondHeader.length; i++) {

                 secondHeader[i] = (char) getUnsignedShort(buffer);

             }

         }

         resolveConstantPool(values, visitor);

     }

     private char[] getCharArray(int utfLength) {

         if (utfLength <= charArray.length)

             return charArray;

         return charArray = new char[utfLength];

     }

     private void parseConstantPool(ByteBuffer buffer, Object[] values, ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {

         for (int i = 1; i < tags.length; ) {

             byte tag = (byte) getUnsignedByte(buffer);

             assert(tags[i] == 0 || tags[i] == tag);

             tags[i] = tag;

             switch (tag) {

                 case CONSTANT_Utf8:

                     int utfLen = getUnsignedShort(buffer);

                     String value = getUTF8(buffer, utfLen, getCharArray(utfLen));

                     visitor.visitUTF8(i, CONSTANT_Utf8, value);

                     tags[i] = tag;

                     values[i++] = value;

                     break;

                 case CONSTANT_Integer:

                     visitor.visitConstantValue(i, tag, buffer.getInt());

                     i++;

                     break;

                 case CONSTANT_Float:

                     visitor.visitConstantValue(i, tag, buffer.getFloat());

                     i++;

                     break;

                 case CONSTANT_Long:

                     visitor.visitConstantValue(i, tag, buffer.getLong());

                     i+=2;

                     break;

                 case CONSTANT_Double:

                     visitor.visitConstantValue(i, tag, buffer.getDouble());

                     i+=2;

                     break;

                 case CONSTANT_Class:    // fall through:

                 case CONSTANT_String:

                     tags[i] = tag;

                     values[i++] = new int[] { getUnsignedShort(buffer) };

                     break;

                 case CONSTANT_Fieldref:           // fall through:

                 case CONSTANT_Methodref:          // fall through:

                 case CONSTANT_InterfaceMethodref: // fall through:

                 case CONSTANT_NameAndType:

                     tags[i] = tag;

                     values[i++] = new int[] { getUnsignedShort(buffer), getUnsignedShort(buffer) };

                     break;

                 default:

                     throw new AssertionError("invalid constant "+tag);

             }

         }

     }

     private void resolveConstantPool(Object[] values, ConstantPoolVisitor visitor) {

         // clean out the int[] values, which are temporary

         for (int beg = 1, end = values.length-1, beg2, end2;

              beg <= end;

              beg = beg2, end = end2) {

              beg2 = end; end2 = beg-1;

              //System.out.println("CP resolve pass: "+beg+".."+end);

              for (int i = beg; i <= end; i++) {

                   Object value = values[i];

                   if (!(value instanceof int[]))

                       continue;

                   int[] array = (int[]) value;

                   byte tag = tags[i];

                   switch (tag) {

                       case CONSTANT_String:

                           String stringBody = (String) values[array[0]];

                           visitor.visitConstantString(i, tag, stringBody, array[0]);

                           values[i] = null;

                           break;

                       case CONSTANT_Class: {

                           String className = (String) values[array[0]];

                           // use the external form favored by Class.forName:

                           className = className.replace('/', '.');

                           visitor.visitConstantString(i, tag, className, array[0]);

                           values[i] = className;

                           break;

                       }

                       case CONSTANT_NameAndType: {

                           String memberName = (String) values[array[0]];

                           String signature  = (String) values[array[1]];

                           visitor.visitDescriptor(i, tag, memberName, signature,

                                                   array[0], array[1]);

                           values[i] = new String[] {memberName, signature};

                           break;

                       }

                       case CONSTANT_Fieldref:           // fall through:

                       case CONSTANT_Methodref:          // fall through:

                       case CONSTANT_InterfaceMethodref: {

                               Object className   = values[array[0]];

                               Object nameAndType = values[array[1]];

                               if (!(className instanceof String) ||

                                   !(nameAndType instanceof String[])) {

                                    // one more pass is needed

                                    if (beg2 > i)  beg2 = i;

                                    if (end2 < i)  end2 = i;

                                    continue;

                               }

                               String[] nameAndTypeArray = (String[]) nameAndType;

                               visitor.visitMemberRef(i, tag,

                                   (String)className,

                                   nameAndTypeArray[0],

                                   nameAndTypeArray[1],

                                   array[0], array[1]);

                               values[i] = null;

                           }

                           break;

                       default:

                           continue;

                 }

             }

         }

     }

     private static int getUnsignedByte(ByteBuffer buffer) {

         return buffer.get() & 0xFF;

     }

     private static int getUnsignedShort(ByteBuffer buffer) {

         int b1 = getUnsignedByte(buffer);

         int b2 = getUnsignedByte(buffer);

         return (b1 << 8) + (b2 << 0);

     }

     private static String getUTF8(ByteBuffer buffer, int utfLen, char[] charArray) throws InvalidConstantPoolFormatException {

       int utfLimit = buffer.position() + utfLen;

       int index = 0;

       while (buffer.position() < utfLimit) {

           int c = buffer.get() & 0xff;

           if (c > 127) {

               buffer.position(buffer.position() - 1);

               return getUTF8Extended(buffer, utfLimit, charArray, index);

           }

           charArray[index++] = (char)c;

       }

       return new String(charArray, 0, index);

     }

     private static String getUTF8Extended(ByteBuffer buffer, int utfLimit, char[] charArray, int index) throws InvalidConstantPoolFormatException {

         int c, c2, c3;

         while (buffer.position() < utfLimit) {

             c = buffer.get() & 0xff;

             switch (c >> 4) {

                 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:

                     /* 0xxxxxxx*/

                     charArray[index++] = (char)c;

                     break;

                 case 12: case 13:

                     /* 110x xxxx   10xx xxxx*/

                     c2 = buffer.get();

                     if ((c2 & 0xC0) != 0x80)

                         throw new InvalidConstantPoolFormatException(

                             "malformed input around byte " + buffer.position());

                      charArray[index++] = (char)(((c  & 0x1F) << 6) |

                                                   (c2 & 0x3F));

                     break;

                 case 14:

                     /* 1110 xxxx  10xx xxxx  10xx xxxx */

                     c2 = buffer.get();

                     c3 = buffer.get();

                     if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80))

                        throw new InvalidConstantPoolFormatException(

                           "malformed input around byte " + (buffer.position()));

                     charArray[index++] = (char)(((c  & 0x0F) << 12) |

                                                 ((c2 & 0x3F) << 6)  |

                                                 ((c3 & 0x3F) << 0));

                     break;

                 default:

                     /* 10xx xxxx,  1111 xxxx */

                     throw new InvalidConstantPoolFormatException(

                         "malformed input around byte " + buffer.position());

             }

         }

         // The number of chars produced may be less than utflen

         return new String(charArray, 0, index);

     }

 }