/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/bytecode/ConstantPool.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 java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * Represents a constant pool entry.
 */
public class ConstantPool {
  public static final int CP_CLASS = 7;
  public static final int CP_FIELD_REF = 9;
  public static final int CP_METHOD_REF = 10;
  public static final int CP_INTERFACE_METHOD_REF = 11;
  public static final int CP_STRING = 8;
  public static final int CP_INTEGER = 3;
  public static final int CP_FLOAT = 4;
  public static final int CP_LONG = 5;
  public static final int CP_DOUBLE = 6;
  public static final int CP_NAME_AND_TYPE = 12;
  public static final int CP_UTF8 = 1;

  private ArrayList<ConstantPoolEntry> _entries;
  private HashMap<String,Utf8Constant> _utf8Map
    = new HashMap<String,Utf8Constant>();

  ConstantPool()
  {
    _entries = new ArrayList<ConstantPoolEntry>();
    _entries.add(null);
  }

  /**
   * Returns an entry
   */
  public ConstantPoolEntry getEntry(int index)
  {
    return _entries.get(index);
  }

  /**
   * Returns all the entries.
   */
  public ArrayList<ConstantPoolEntry> getEntries()
  {
    return _entries;
  }

  /**
   * Returns a class constant
   */
  public ClassConstant getClass(int index)
  {
    return (ClassConstant) _entries.get(index);
  }

  /**
   * Returns a field ref entry
   */
  public FieldRefConstant getFieldRef(int index)
  {
    return (FieldRefConstant) _entries.get(index);
  }

  /**
   * Returns a method ref entry
   */
  public MethodRefConstant getMethodRef(int index)
  {
    return (MethodRefConstant) _entries.get(index);
  }

  /**
   * Returns an interface method ref entry
   */
  public InterfaceMethodRefConstant getInterfaceMethodRef(int index)
  {
    return (InterfaceMethodRefConstant) _entries.get(index);
  }

  /**
   * Returns a string constant
   */
  public StringConstant getString(int index)
  {
    return (StringConstant) _entries.get(index);
  }

  /**
   * Returns an integer constant
   */
  public IntegerConstant getInteger(int index)
  {
    return (IntegerConstant) _entries.get(index);
  }

  /**
   * Returns a long constant
   */
  public LongConstant getLong(int index)
  {
    return (LongConstant) _entries.get(index);
  }

  /**
   * Returns a float constant
   */
  public FloatConstant getFloat(int index)
  {
    return (FloatConstant) _entries.get(index);
  }

  /**
   * Returns a double constant
   */
  public DoubleConstant getDouble(int index)
  {
    return (DoubleConstant) _entries.get(index);
  }

  /**
   * Returns a name-and-type constant
   */
  public NameAndTypeConstant getNameAndType(int index)
  {
    return (NameAndTypeConstant) _entries.get(index);
  }

  /**
   * Returns a utf-8 constant
   */
  public Utf8Constant getUtf8(int index)
  {
    return (Utf8Constant) _entries.get(index);
  }

  /**
   * Returns a utf-8 constant as a string
   */
  public String getUtf8AsString(int index)
  {
    Utf8Constant utf8 = (Utf8Constant) _entries.get(index);

    if (utf8 == null)
      return null;
    else
      return utf8.getValue();
  }

  /**
   * Adds a new constant.
   */
  public void addConstant(ConstantPoolEntry entry)
  {
    if (entry instanceof Utf8Constant) {
      Utf8Constant utf8 = (Utf8Constant) entry;
      
      _utf8Map.put(utf8.getValue(), utf8);
    }
    
    _entries.add(entry);
  }

  /**
   * Gets a UTF-8 constant.
   */
  public Utf8Constant getUTF8(String value)
  {
    return _utf8Map.get(value);
  }

  /**
   * Adds a UTF-8 constant.
   */
  public Utf8Constant addUTF8(String value)
  {
    Utf8Constant entry = getUTF8(value);

    if (entry != null)
      return entry;

    entry = new Utf8Constant(this, _entries.size(), value);
    
    addConstant(entry);

    return entry;
  }

  /**
   * Gets a string constant.
   */
  public StringConstant getString(String name)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof StringConstant))
        continue;

      StringConstant stringEntry = (StringConstant) entry;

      if (stringEntry.getString().equals(name))
        return stringEntry;
    }

    return null;
  }

  /**
   * Adds a string constant.
   */
  public StringConstant addString(String name)
  {
    StringConstant entry = getString(name);

    if (entry != null)
      return entry;

    Utf8Constant utf8 = addUTF8(name);

    entry = new StringConstant(this, _entries.size(), utf8.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Gets a integer constant.
   */
  public IntegerConstant getIntegerByValue(int value)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof IntegerConstant))
        continue;

      IntegerConstant integerEntry = (IntegerConstant) entry;

      if (integerEntry.getValue() == value)
        return integerEntry;
    }

    return null;
  }

  /**
   * Adds a integer constant.
   */
  public IntegerConstant addInteger(int value)
  {
    IntegerConstant entry = getIntegerByValue(value);

    if (entry != null)
      return entry;

    entry = new IntegerConstant(this, _entries.size(), value);
    
    addConstant(entry);

    return entry;
  }

  /**
   * Gets a long constant.
   */
  public LongConstant getLongByValue(long value)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof LongConstant))
        continue;

      LongConstant longEntry = (LongConstant) entry;

      if (longEntry.getValue() == value)
        return longEntry;
    }

    return null;
  }

  /**
   * Adds a long constant.
   */
  public LongConstant addLong(long value)
  {
    LongConstant entry = getLongByValue(value);

    if (entry != null)
      return entry;

    entry = new LongConstant(this, _entries.size(), value);
    
    addConstant(entry);
    addConstant(null);

    return entry;
  }

  /**
   * Gets a float constant.
   */
  public FloatConstant getFloatByValue(float value)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof FloatConstant))
        continue;

      FloatConstant floatEntry = (FloatConstant) entry;

      if (floatEntry.getValue() == value)
        return floatEntry;
    }

    return null;
  }

  /**
   * Adds a float constant.
   */
  public FloatConstant addFloat(float value)
  {
    FloatConstant entry = getFloatByValue(value);

    if (entry != null)
      return entry;

    entry = new FloatConstant(this, _entries.size(), value);
    
    addConstant(entry);

    return entry;
  }

  /**
   * Gets a double constant.
   */
  public DoubleConstant getDoubleByValue(double value)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof DoubleConstant))
        continue;

      DoubleConstant doubleEntry = (DoubleConstant) entry;

      if (doubleEntry.getValue() == value)
        return doubleEntry;
    }

    return null;
  }

  /**
   * Adds a double constant.
   */
  public DoubleConstant addDouble(double value)
  {
    DoubleConstant entry = getDoubleByValue(value);

    if (entry != null)
      return entry;

    entry = new DoubleConstant(this, _entries.size(), value);
    
    addConstant(entry);
    addConstant(null);

    return entry;
  }

  /**
   * Gets a class constant.
   */
  public ClassConstant getClass(String name)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof ClassConstant))
        continue;

      ClassConstant classEntry = (ClassConstant) entry;

      if (classEntry.getName().equals(name))
        return classEntry;
    }

    return null;
  }

  /**
   * Adds a class constant.
   */
  public ClassConstant addClass(String name)
  {
    ClassConstant entry = getClass(name);

    if (entry != null)
      return entry;

    Utf8Constant utf8 = addUTF8(name);

    entry = new ClassConstant(this, _entries.size(), utf8.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Gets a name-and-type constant.
   */
  public NameAndTypeConstant getNameAndType(String name, String type)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof NameAndTypeConstant))
        continue;

      NameAndTypeConstant methodEntry = (NameAndTypeConstant) entry;

      if (methodEntry.getName().equals(name) &&
          methodEntry.getType().equals(type))
        return methodEntry;
    }

    return null;
  }

  /**
   * Adds a name-and-type constant.
   */
  public NameAndTypeConstant addNameAndType(String name, String type)
  {
    NameAndTypeConstant entry = getNameAndType(name, type);

    if (entry != null)
      return entry;

    Utf8Constant nameEntry = addUTF8(name);
    Utf8Constant typeEntry = addUTF8(type);

    entry = new NameAndTypeConstant(this, _entries.size(),
                                    nameEntry.getIndex(),
                                    typeEntry.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Gets a field ref constant.
   */
  public FieldRefConstant getFieldRef(String className,
                                      String name,
                                      String type)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof FieldRefConstant))
        continue;

      FieldRefConstant fieldEntry = (FieldRefConstant) entry;

      if (fieldEntry.getClassName().equals(className) &&
          fieldEntry.getName().equals(name) &&
          fieldEntry.getType().equals(type))
        return fieldEntry;
    }

    return null;
  }

  /**
   * Gets a field ref constant.
   */
  public FieldRefConstant getFieldRef(String name)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof FieldRefConstant))
        continue;

      FieldRefConstant fieldEntry = (FieldRefConstant) entry;

      if (fieldEntry.getName().equals(name))
        return fieldEntry;
    }

    return null;
  }

  /**
   * Adds a field ref constant.
   */
  public FieldRefConstant addFieldRef(String className,
                                      String name,
                                      String type)
  {
    FieldRefConstant entry = getFieldRef(className, name, type);

    if (entry != null)
      return entry;

    ClassConstant classEntry = addClass(className);
    NameAndTypeConstant typeEntry = addNameAndType(name, type);

    entry = new FieldRefConstant(this, _entries.size(),
                                 classEntry.getIndex(),
                                 typeEntry.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Gets a method ref constant.
   */
  public MethodRefConstant getMethodRef(String className,
                                        String name,
                                        String type)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof MethodRefConstant))
        continue;

      MethodRefConstant methodEntry = (MethodRefConstant) entry;

      if (methodEntry.getClassName().equals(className) &&
          methodEntry.getName().equals(name) &&
          methodEntry.getType().equals(type))
        return methodEntry;
    }

    return null;
  }

  /**
   * Adds a method ref constant.
   */
  public MethodRefConstant addMethodRef(String className,
                                        String name,
                                        String type)
  {
    MethodRefConstant entry = getMethodRef(className, name, type);

    if (entry != null)
      return entry;

    ClassConstant classEntry = addClass(className);
    NameAndTypeConstant typeEntry = addNameAndType(name, type);

    entry = new MethodRefConstant(this, _entries.size(),
                                  classEntry.getIndex(),
                                  typeEntry.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Gets an interface constant.
   */
  public InterfaceMethodRefConstant getInterfaceRef(String className,
                                                    String name,
                                                    String type)
  {
    for (int i = 0; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (! (entry instanceof InterfaceMethodRefConstant))
        continue;

      InterfaceMethodRefConstant methodEntry;
      methodEntry = (InterfaceMethodRefConstant) entry;

      if (methodEntry.getClassName().equals(className) &&
          methodEntry.getName().equals(name) &&
          methodEntry.getType().equals(type))
        return methodEntry;
    }

    return null;
  }

  /**
   * Adds an interface ref constant.
   */
  public InterfaceMethodRefConstant addInterfaceRef(String className,
                                                    String name,
                                                    String type)
  {
    InterfaceMethodRefConstant entry = getInterfaceRef(className, name, type);

    if (entry != null)
      return entry;

    ClassConstant classEntry = addClass(className);
    NameAndTypeConstant typeEntry = addNameAndType(name, type);

    entry = new InterfaceMethodRefConstant(this, _entries.size(),
                                           classEntry.getIndex(),
                                           typeEntry.getIndex());

    addConstant(entry);

    return entry;
  }

  /**
   * Writes the contents of the pool.
   */
  void write(ByteCodeWriter out)
    throws IOException
  {
    out.writeShort(_entries.size());

    for (int i = 1; i < _entries.size(); i++) {
      ConstantPoolEntry entry = _entries.get(i);

      if (entry != null)
        entry.write(out);
    }
  }
}
