Source code: com/chaoswg/xtc4y/classdesc/ConstantPool.java

   //$Header: /cvsroot/xtc4y/xtc4y/src/com/chaoswg/xtc4y/classdesc/ConstantPool.java,v 1.2 2003/08/25 10:50:14 toggm Exp $
   /******************************************************************************
    * XTC4y - eXtreme Testing Collection 4 you                                   *
    * -------------------------------------------------------------------------- *
    * URL: http://www.chaoswg.com/xtc4y                                          *
    * Author: Mike Toggweiler (2.dog@gmx.ch)                                     *
    *                                                                            *
    * Last Updated: $Date: 2003/08/25 10:50:14 $, by $Author: toggm $            *
    * Version: $Revision: 1.2 $                                                  *
   * -------------------------------------------------------------------------- *
   * COPYRIGHT:   (c) 2003 by Mike Toggweiler                                   *
   *                                                                            *
   * This program 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.                                        *
   *****************************************************************************/
  package com.chaoswg.xtc4y.classdesc;
  
  import java.util.Vector;
  import java.util.Iterator;
  
  import java.io.DataInputStream;
  import java.io.DataOutputStream;
  import java.io.IOException;
  
  /**
   * This class describes the constant pool in a class file. It is mainly 
   * used internally
   * The constant pool begins at index 1, therefore tries for storing data 
   * at this position wan't succeed, a ArrayIndexOutofBoundException will be 
   * thrown.
   * It begins at index 1 so a reference to a cp entry at position 0 means no 
   * reference.
   * @author Mike Toggweiler
   **/
  public class ConstantPool {
      private Vector poolEntries;
      private ClassCPEntry thisClass;
  
      /**
       * Create a new empty constant pool
       **/
      public ConstantPool() {
    poolEntries = new Vector();
    //add a default element at the position 0
      }
  
      /**
       * Creates and Initializes a constant pool from a DataInputStream
       * @param dis the DataInputStream to read from
       **/
      protected ConstantPool(DataInputStream dis) throws IOException {
    poolEntries = new Vector();
    //constant_pool_count
    int cpCount = dis.readUnsignedShort();  
    
    //cpinfos[constant_pool_count-1]
    for (int i=0; i<cpCount-1;) {
        ConstantPoolEntry cp = null;
        byte tag = (byte)dis.readUnsignedByte();
        switch (tag) {
        case UTF8CPEntry.TAG:
      cp = new UTF8CPEntry(dis);
      break;
        case IntegerCPEntry.TAG:
      cp = new IntegerCPEntry(dis);
      break;
        case FloatCPEntry.TAG:
      cp = new FloatCPEntry(dis);
      break;
        case LongCPEntry.TAG:
      cp = new LongCPEntry(dis);
      break;
        case DoubleCPEntry.TAG:
      cp = new DoubleCPEntry(dis);
      break;    
        case StringCPEntry.TAG:
      cp = new StringCPEntry(dis);
      break;    
        case ClassCPEntry.TAG:
      cp = new ClassCPEntry(dis);
      break;
        case FieldrefCPEntry.TAG:
      cp = new FieldrefCPEntry(dis);
      break;
        case MethodrefCPEntry.TAG:
      cp = new MethodrefCPEntry(dis);
      break;
        case InterfaceMethodrefCPEntry.TAG:
      cp = new InterfaceMethodrefCPEntry(dis);
      break;
        case NameAndTypeCPEntry.TAG:
      cp = new NameAndTypeCPEntry(dis);
      break;
        default:
      throw new ClassFormatError("Constant pool tag unknown:"+tag);
        }
        int step = cp.getUsedCPSpace();            
 
       poolEntries.add(cp);
       
       for (int i2=1; i2<step; ++i2) {
     //add dummy objects
     poolEntries.add(new Object());
       }      
       i += step;      
   }
   int j=0;
   //resolve references in cp entries
   for (int i=0; i<poolEntries.size(); ++i) {
       Object next = poolEntries.elementAt(i);
       if (next instanceof ConstantPoolEntry) {    
     ++j;
     ((ConstantPoolEntry)next).resolve(this);
       }
   }
     }
 
     /**
      * Write the constant pool information into a DataOutputStream
      * @param dos the DataOutputStream to write on     
      **/
     protected void write(DataOutputStream dos) throws IOException {
   Object obj;
   for (int i=0; i<poolEntries.size(); ++i) {
       obj = poolEntries.elementAt(i);
       if (obj instanceof ConstantPoolEntry) {
     //used to remove dummy entries
     ((ConstantPoolEntry)obj).write(dos, this);
       }
   }
     }
 
     /**
      * add a constant pool entry, if it already exists, just return an index
      * on it
      * @param entry cp entry to add
      * @return the index of the current cp entry
      **/
     public short addCPEntry(ConstantPoolEntry entry) {  
   if (poolEntries.contains(entry)) {
       return (short)(poolEntries.indexOf(entry)+1);
   }  
   poolEntries.add(entry);
   int index = poolEntries.size();
 
   int step = entry.getUsedCPSpace();            
       
   for (int i=1; i<step; ++i) {
       //add dummy objects
       poolEntries.add(new Object());
   }        
   return (short)index;
     }
 
     /**
      * @return an iterator of all cpentires
      **/
     public Iterator getCPEntries() {
   Iterator it = poolEntries.iterator();
   //move an element forward
   it.next();
   return it;
     }
 
     /**
      * @return a CPEntry at a given position
      **/
     public ConstantPoolEntry getCPEntryAt(int index) {
   if (index <= 0 || index > poolEntries.size()) {
       throw new ArrayIndexOutOfBoundsException(poolEntries.size()+":"+
                  index);
   }
   return (ConstantPoolEntry)poolEntries.elementAt(index-1);
     }
 
     /**
      * @return the size of the constant pool
      **/
     public int getSize() {
   return poolEntries.size();
     }
 
     /**
      * Get this class
      **/
     protected ClassCPEntry getThisClass() {
   return thisClass;
     }
 
     /**
      * set this class
      **/
     protected void setThisClass(ClassCPEntry cl) {
   thisClass = cl;
     }
 
     /**
      * Get a readable version of hte current constant pool
      **/
     public String toString() {
   String ret = "ConstantPool:\nThisClass:"+thisClass+"\n";
   for (int i=0; i<poolEntries.size(); ++i) {
       Object obj = poolEntries.elementAt(i);
       if (obj instanceof ConstantPoolEntry) {
     ret += (i+1) + " " + obj + "\n";
       }
   }
   return ret;
     }
 }