/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/bytecode/ByteCodeParser.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source 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, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.bytecode;

import com.caucho.util.CharBuffer;
import com.caucho.util.L10N;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

/**
 * Interface to the bytecode parser.
 */
public class ByteCodeParser {
  private static final L10N L = new L10N(ByteCode.class);

  static final int CP_CLASS = 7;
  static final int CP_FIELD_REF = 9;
  static final int CP_METHOD_REF = 10;
  static final int CP_INTERFACE_METHOD_REF = 11;
  static final int CP_STRING = 8;
  static final int CP_INTEGER = 3;
  static final int CP_FLOAT = 4;
  static final int CP_LONG = 5;
  static final int CP_DOUBLE = 6;
  static final int CP_NAME_AND_TYPE = 12;
  static final int CP_UTF8 = 1;

  private JavaClassLoader _loader;
  private InputStream _is;
  private JavaClass _class;
  private ConstantPool _cp;

  /**
   * Sets the JClassLoader
   */
  public void setClassLoader(JavaClassLoader loader)
  {
    _loader = loader;
  }

  /**
   * Sets the class.
   */
  public void setJavaClass(JavaClass javaClass)
  {
    _class = javaClass;
  }
  
  /**
   * Parses the .class file.
   */
  public JavaClass parse(InputStream is)
    throws IOException
  {
    _is = is;

    if (_loader == null)
      _loader = new JavaClassLoader();
    
    if (_class == null)
      _class = new JavaClass(_loader);

    _cp = _class.getConstantPool();
    
    parseClass();

    return _class;
  }

  /**
   * Returns the constant pool.
   */
  public ConstantPool getConstantPool()
  {
    return _cp;
  }

  /**
   * Returns a UTF8 String from the constant pool.
   */
  public String getUTF8(int index)
  {
    return getConstantPool().getUtf8AsString(index);
  }

  /**
   * Parses the ClassFile construct
   */
  private void parseClass()
    throws IOException
  {
    int magic = readInt();

    if (magic != JavaClass.MAGIC)
      throw error(L.l("bad magic number in class file"));

    int minor = readShort();
    int major = readShort();

    _class.setMajor(major);
    _class.setMinor(minor);

    parseConstantPool();

    int accessFlags = readShort();
    _class.setAccessFlags(accessFlags);

    int thisClassIndex = readShort();
    _class.setThisClass(_cp.getClass(thisClassIndex).getName());
    
    int superClassIndex = readShort();
    if (superClassIndex > 0)
      _class.setSuperClass(_cp.getClass(superClassIndex).getName());

    int interfaceCount = readShort();
    for (int i = 0; i < interfaceCount; i++) {
      int classIndex = readShort();

      _class.addInterface(_cp.getClass(classIndex).getName());
    }

    int fieldCount = readShort();
    for (int i = 0; i < fieldCount; i++) {
      parseField();
    }

    int methodCount = readShort();
    for (int i = 0; i < methodCount; i++)
      parseMethod();

    int attrCount = readShort();
    for (int i = 0; i < attrCount; i++) {
      Attribute attr = parseAttribute();

      _class.addAttribute(attr);
    }
  }

  /**
   * Parses the constant pool.
   */
  public void parseConstantPool()
    throws IOException
  {
    int count = readShort();

    for (int i = 1; i < count; i++) {
      ConstantPoolEntry entry = parseConstantPoolEntry(i);

      _cp.addConstant(entry);
      
      if (entry instanceof DoubleConstant ||
          entry instanceof LongConstant) {
        i++;
        _cp.addConstant(null);
      }
    }
  }

  /**
   * Parses a constant pool entry.
   */
  private ConstantPoolEntry parseConstantPoolEntry(int index)
    throws IOException
  {
    int tag = read();

    switch (tag) {
    case CP_CLASS:
      return parseClassConstant(index);
      
    case CP_FIELD_REF:
      return parseFieldRefConstant(index);
      
    case CP_METHOD_REF:
      return parseMethodRefConstant(index);
      
    case CP_INTERFACE_METHOD_REF:
      return parseInterfaceMethodRefConstant(index);
      
    case CP_STRING:
      return parseStringConstant(index);
      
    case CP_INTEGER:
      return parseIntegerConstant(index);
      
    case CP_FLOAT:
      return parseFloatConstant(index);
      
    case CP_LONG:
      return parseLongConstant(index);
      
    case CP_DOUBLE:
      return parseDoubleConstant(index);
      
    case CP_NAME_AND_TYPE:
      return parseNameAndTypeConstant(index);
      
    case CP_UTF8:
      return parseUtf8Constant(index);

    default:
      throw error(L.l("'{0}' is an unknown constant pool type.",
                      tag));
    }
  }

  /**
   * Parses a class constant pool entry.
   */
  private ClassConstant parseClassConstant(int index)
    throws IOException
  {
    int nameIndex = readShort();

    return new ClassConstant(_class.getConstantPool(), index, nameIndex);
  }

  /**
   * Parses a field ref constant pool entry.
   */
  private FieldRefConstant parseFieldRefConstant(int index)
    throws IOException
  {
    int classIndex = readShort();
    int nameAndTypeIndex = readShort();

    return new FieldRefConstant(_class.getConstantPool(), index,
                                classIndex, nameAndTypeIndex);
  }

  /**
   * Parses a method ref constant pool entry.
   */
  private MethodRefConstant parseMethodRefConstant(int index)
    throws IOException
  {
    int classIndex = readShort();
    int nameAndTypeIndex = readShort();

    return new MethodRefConstant(_class.getConstantPool(), index,
                                 classIndex, nameAndTypeIndex);
  }

  /**
   * Parses an interface method ref constant pool entry.
   */
  private InterfaceMethodRefConstant parseInterfaceMethodRefConstant(int index)
    throws IOException
  {
    int classIndex = readShort();
    int nameAndTypeIndex = readShort();

    return new InterfaceMethodRefConstant(_class.getConstantPool(), index,
                                          classIndex, nameAndTypeIndex);
  }

  /**
   * Parses a string constant pool entry.
   */
  private StringConstant parseStringConstant(int index)
    throws IOException
  {
    int stringIndex = readShort();

    return new StringConstant(_class.getConstantPool(), index, stringIndex);
  }

  /**
   * Parses an integer constant pool entry.
   */
  private IntegerConstant parseIntegerConstant(int index)
    throws IOException
  {
    int value = readInt();

    return new IntegerConstant(_class.getConstantPool(), index, value);
  }

  /**
   * Parses a float constant pool entry.
   */
  private FloatConstant parseFloatConstant(int index)
    throws IOException
  {
    int bits = readInt();

    float value = Float.intBitsToFloat(bits);

    return new FloatConstant(_class.getConstantPool(), index, value);
  }

  /**
   * Parses a long constant pool entry.
   */
  private LongConstant parseLongConstant(int index)
    throws IOException
  {
    long value = readLong();

    return new LongConstant(_class.getConstantPool(), index, value);
  }

  /**
   * Parses a double constant pool entry.
   */
  private DoubleConstant parseDoubleConstant(int index)
    throws IOException
  {
    long bits = readLong();

    double value = Double.longBitsToDouble(bits);

    return new DoubleConstant(_class.getConstantPool(), index, value);
  }

  /**
   * Parses a name and type pool entry.
   */
  private NameAndTypeConstant parseNameAndTypeConstant(int index)
    throws IOException
  {
    int nameIndex = readShort();
    int descriptorIndex = readShort();

    return new NameAndTypeConstant(_class.getConstantPool(), index,
                                   nameIndex, descriptorIndex);
  }

  /**
   * Parses a utf-8 constant pool entry.
   */
  private Utf8Constant parseUtf8Constant(int index)
    throws IOException
  {
    int length = readShort();
    
    CharBuffer cb = CharBuffer.allocate();

    for (int i = 0; i < length; i++) {
      int ch = read();

      if (ch < 0x80) {
        cb.append((char) ch);
      }
      else if ((ch & 0xe0) == 0xc0) {
        int ch2 = read();
        i++;

        cb.append((char) (((ch & 0x1f) << 6)+
                          (ch2 & 0x3f)));
      }
      else {
        int ch2 = read();
        int ch3 = read();
        i += 2;
      
        cb.append((char) (((ch & 0xf) << 12)+
                          ((ch2 & 0x3f) << 6) +
                          ((ch3 & 0x3f))));
      }
    }

    return new Utf8Constant(_class.getConstantPool(), index, cb.close());
  }

  /**
   * Parses a field entry.
   */
  private void parseField()
    throws IOException
  {
    int accessFlags = readShort();
    int nameIndex = readShort();
    int descriptorIndex = readShort();

    JavaField field = new JavaField();
    field.setJavaClass(_class);
    field.setName(_cp.getUtf8(nameIndex).getValue());
    field.setDescriptor(_cp.getUtf8(descriptorIndex).getValue());
    field.setAccessFlags(accessFlags);

    int attributesCount = readShort();

    for (int i = 0; i < attributesCount; i++) {
      Attribute attr = parseAttribute();

      field.addAttribute(attr);
    }

    _class.addField(field);
  }

  /**
   * Parses a method entry.
   */
  private void parseMethod()
    throws IOException
  {
    int accessFlags = readShort();
    int nameIndex = readShort();
    int descriptorIndex = readShort();

    JavaMethod method = new JavaMethod(_loader);
    method.setJavaClass(_class);
    method.setName(_cp.getUtf8(nameIndex).getValue());
    method.setDescriptor(_cp.getUtf8(descriptorIndex).getValue());
    method.setAccessFlags(accessFlags);

    int attributesCount = readShort();

    for (int i = 0; i < attributesCount; i++) {
      Attribute attr = parseAttribute();

      method.addAttribute(attr);
      
      if (attr instanceof ExceptionsAttribute) {
        ExceptionsAttribute exn = (ExceptionsAttribute) attr;

        ArrayList<String> exnNames = exn.getExceptionList();

        if (exnNames.size() > 0) {
          JClass []exnClasses = new JClass[exnNames.size()];

          for (int j = 0; j < exnNames.size(); j++) {
            String exnName = exnNames.get(j).replace('/', '.');

            exnClasses[j] = _loader.forName(exnName);
          }

          method.setExceptionTypes(exnClasses);
        }
      }
    }

    _class.addMethod(method);
  }

  /**
   * Parses an attribute.
   */
  Attribute parseAttribute()
    throws IOException
  {
    int nameIndex = readShort();

    String name = _cp.getUtf8(nameIndex).getValue();

    if (name.equals("Code")) {
      CodeAttribute code = new CodeAttribute(name);
      code.read(this);
      return code;
    }
    else if (name.equals("Exceptions")) {
      ExceptionsAttribute code = new ExceptionsAttribute(name);
      code.read(this);
      return code;
    }
    else if (name.equals("Signature")) {
      SignatureAttribute code = new SignatureAttribute();
      code.read(this);
      return code;
    }
    
    OpaqueAttribute attr = new OpaqueAttribute(name);
    
    int length = readInt();

    byte []bytes = new byte[length];
    
    read(bytes, 0, bytes.length);

    attr.setValue(bytes);

    return attr;
  }

  /**
   * Parses a 64-bit int.
   */
  long readLong()
    throws IOException
  {
    return (((long) _is.read() << 56) |
            ((long) _is.read() << 48) |
            ((long) _is.read() << 40) |
            ((long) _is.read() << 32) |
            ((long) _is.read() << 24) |
            ((long) _is.read() << 16) |
            ((long) _is.read() << 8) |
            ((long) _is.read()));
  }

  /**
   * Parses a 32-bit int.
   */
  int readInt()
    throws IOException
  {
    return ((_is.read() << 24) |
            (_is.read() << 16) |
            (_is.read() << 8) |
            (_is.read()));
  }

  /**
   * Parses a 16-bit int.
   */
  int readShort()
    throws IOException
  {
    int c1 = _is.read();
    int c2 = _is.read();

    return ((c1 << 8) | c2);
  }

  /**
   * Parses a byte
   */
  int read()
    throws IOException
  {
    return _is.read();
  }

  /**
   * Reads a chunk
   */
  int read(byte []buffer, int offset, int length)
    throws IOException
  {
    int readLength = 0;
    
    while (length > 0) {
      int sublen = _is.read(buffer, offset, length);

      if (sublen < 0)
        return readLength == 0 ? -1 : readLength;

      offset += sublen;
      length -= sublen;
      readLength += sublen;
    }

    return readLength;
  }

  /**
   * Returns an error message.
   */
  private IOException error(String message)
  {
    return new IOException(message);
  }
}
