classholder.java

derby database source code.good for you.

/*

   Derby - Class org.apache.derby.iapi.services.classfile.ClassHolder

   Copyright 2000, 2004 The Apache Software Foundation or its licensors, as applicable.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

 */

package org.apache.derby.iapi.services.classfile;

import org.apache.derby.iapi.services.sanity.SanityManager;


import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;

import java.io.IOException;
import java.util.Vector;

import org.apache.derby.iapi.util.ByteArray;
import org.apache.derby.iapi.services.classfile.VMDescriptor;
import org.apache.derby.iapi.services.classfile.VMDescriptor;

import java.util.Hashtable;
import java.util.Vector;
import java.util.Enumeration;


/** Based upon "THE class FILE FORMAT" chapter of "The Java Virtual Machine Specification"
    corresponding to version 1.0.2 of the Java Virtual Machine and 1.0.2 of the
	Java Language Specification.

    ISBN  0-201-63452-X, September 1996.
	*/

public class ClassHolder {


	/*
	** Constants.
	*/

	/*
	** Fields
	*/

	protected int access_flags;
	protected int this_class;
	protected int super_class;

	// protected InterfacesArray interfaces; // can be null
	protected int[] interfaces; //can be null

	protected MemberTable field_info; // can be null
	protected MemberTable method_info;	// can be null
	protected Attributes attribute_info; // can be null

	/*
	** Fields for Constant Pool Table
	*/
	protected Hashtable cptHashTable;
	protected Vector cptEntries;
	private int cptEstimatedSize;

	/**
		Used to search for index entries to avoid object allocation
		in the case a referecne already exists.
	*/
	private final CONSTANT_Index_info	searchIndex = new CONSTANT_Index_info(0, 0, 0);

	/*
	**	Constructors.
	*/

	protected ClassHolder(int estimatedConstantPoolCount) {
		// Constant Pool Information
		// 100 is the estimate of the number of entries that will be generated
		cptEntries = new Vector(estimatedConstantPoolCount);
		cptHashTable = new Hashtable(estimatedConstantPoolCount, (float)0.75);

		// reserve the 0'th constant pool entry
		cptEntries.setSize(1);
	}


	/**
		This will not define a constructor -- it is up
		to the caller to add at least one.
	*/

	public ClassHolder(String fullyQualifiedName, String superClassName,
		int modifiers) {

		this(100);

		access_flags = modifiers | /* Modifier.SUPER */ 0x0020;

		this_class = addClassReference(fullyQualifiedName);
		super_class = addClassReference(superClassName);
		method_info = new MemberTable(0);
	}

	private void put(ClassFormatOutput out) throws IOException {

		/* Write out the header */
		out.putU4(VMDescriptor.JAVA_CLASS_FORMAT_MAGIC);
		out.putU2(VMDescriptor.JAVA_CLASS_FORMAT_MINOR_VERSION);
		out.putU2(VMDescriptor.JAVA_CLASS_FORMAT_MAJOR_VERSION);

		// special case checking that the number of constant
		// pool entries does not exceed the limit of 65535
		// (as it is stored as a U2).
		// Special case to allow somewhat easier debugging
		// of the resulting failure.
		out.putU2("constant_pool", cptEntries.size());
		cptPut(out);

		out.putU2(access_flags);
		out.putU2(this_class);
		out.putU2(super_class);

		if (interfaces != null) {
			int ilen = interfaces.length;
			out.putU2(ilen);
			for (int i = 0; i < ilen; i++) {
				out.putU2(interfaces[i]);
			}
		} else {
			out.putU2(0);
		}

		if (field_info != null) {
			out.putU2(field_info.size());
			field_info.put(out);
		} else {
			out.putU2(0);
		}

		if (method_info != null) {
			out.putU2(method_info.size());
			method_info.put(out);
		} else {
			out.putU2(0);
		}

		if (attribute_info != null) {
			out.putU2(attribute_info.size());
			attribute_info.put(out);
		} else {
			out.putU2(0);
		}

	}


	/*
	**	Public methods from ClassHolder.
	*/

	/**
	 * Convert the object representation of the class into
	 * its class file format.
	 * @exception IOException error writing the class
	 */
	public ByteArray getFileFormat() throws IOException {

		int classFileSize = 4 + (10 * 2);
		classFileSize += cptEstimatedSize;

		if (interfaces != null)
			classFileSize += (interfaces.length * 2);

		if (field_info != null)
			classFileSize += field_info.classFileSize();

		if (method_info != null)
			classFileSize += method_info.classFileSize();

		if (attribute_info != null)
			classFileSize += attribute_info.classFileSize();

	
		ClassFormatOutput cfo = new ClassFormatOutput(classFileSize + 200);

		put(cfo);

		return new ByteArray(cfo.getData(), 0, cfo.size());

	}

	/*
	** Public methods from ClassMember
	*/

	/** @see ClassMember
	*/
	public int getModifier() { return access_flags; }

	/** @see ClassMember
	*/
	public String getName() {
		return className(this_class).replace('/', '.');
	}
	/*
	**	Public methods from ClassHolder
	*/

	/** @see ClassHolder#addMember */
 	public ClassMember addMember(String simpleName, String descriptor, int modifier)
	{
		if (SanityManager.DEBUG)
		{
			if (descriptor.startsWith("(")) {
				if (method_info != null) {
					if (method_info.find(simpleName, descriptor) != null) {
						SanityManager.THROWASSERT("Method already exists " + simpleName + " " + descriptor);
					}
				}

			} else {
				if (field_info != null) {
					if (field_info.find(simpleName, descriptor) != null) {
						SanityManager.THROWASSERT("Field already exists " + simpleName + " " + descriptor);
					}
				}
			}
		}

		CONSTANT_Utf8_info utf = addUtf8Entry(simpleName);

		int nameIndex = utf.getIndex();
		int descriptorIndex = addUtf8Entry(descriptor).getIndex();

		ClassMember item = new ClassMember(this, modifier, nameIndex, descriptorIndex);
		MemberTable mt;
		if (descriptor.startsWith("(")) {
			mt = method_info;
			if (mt == null)
				mt = method_info = new MemberTable(0);

		}
		else {
			mt = field_info;
			if (mt == null)
				mt = field_info = new MemberTable(0);
		}

		mt.addEntry(item);
		return item;
	}

	/** @see ClassHolder#addFieldReference */
	public int addFieldReference(String className, String simpleName, String descriptor) {
		return addReference(VMDescriptor.CONSTANT_Fieldref, className, simpleName, descriptor);
	}

	public int addFieldReference(ClassMember field) {
		return addReference(VMDescriptor.CONSTANT_Fieldref, (ClassMember) field);
	}

	/** @see ClassHolder#addMethodReference */
	public int addMethodReference(String className, String simpleName, String descriptor, boolean isInterface) {

		int tag = isInterface ?	VMDescriptor.CONSTANT_InterfaceMethodref :
								VMDescriptor.CONSTANT_Methodref;

		return addReference(tag, className, simpleName, descriptor); 
	}

	private int addReference(int tag, String className, String simpleName, String descriptor) {

		int classIndex = addClassReference(className);
		int nameTypeIndex = addNameAndType(simpleName, descriptor);

		return addIndexReference(tag, classIndex, nameTypeIndex);
	}

	private int addReference(int tag, ClassMember member) {

		int nameTypeIndex = addIndexReference(VMDescriptor.CONSTANT_NameAndType,
							member.name_index, member.descriptor_index);

		return addIndexReference(tag, this_class, nameTypeIndex);
	}

	/** @see ClassHolder#addConstant */
	public int addConstant(String value) {

		return addString(value);
	}

	/** @see ClassHolder#addUtf8 */
	public int addUtf8(String value) {

		return addUtf8Entry(value).getIndex();
	}


	/** @see ClassHolder#addConstant */
	public int addConstant(int value) {
		return addDirectEntry(new CONSTANT_Integer_info(value));
	}

	/** @see ClassHolder#addConstant */
	public int addConstant(float value) {
		return addDirectEntry(new CONSTANT_Float_info(value));
	}

	/** @see ClassHolder#addConstant */
	public int addConstant(long value) {
		return addDirectEntry(new CONSTANT_Long_info(value));
	}

	/** @see ClassHolder#addConstant */
	public int addConstant(double value) {
		return addDirectEntry(new CONSTANT_Double_info(value));
	}


	/** @see ClassMember
	*/
	public int getConstantPoolIndex() { return this_class; }

	public void addAttribute(String attributeName, ClassFormatOutput info) {

		if (attribute_info == null)
			attribute_info = new Attributes(1);


		CONSTANT_Utf8_info autf = addUtf8Entry(attributeName);

		int index = autf.getIndex();

		attribute_info.addEntry(new AttributeEntry(index, info));
	}


	public String getSuperClassName() {
		if (super_class == 0)
			return null;
		else
			return className(super_class).replace('/', '.');
	}


/*
    public ClassMember getMemberReference(String fullyQualifiedClassName, String simpleName, String descriptor) {

		int classIndex;

		if (fullyQualifiedClassName == null)
			 classIndex = this_class;
		else
			classIndex = constantPool.findClass(fullyQualifiedClassName);

		if (classIndex < 0)
			return null;

		int nameAndTypeIndex = constantPool.findNameAndType(simpleName, descriptor);
		if (nameAndTypeIndex < 0)
			return null;

        return constantPool.findReference(classIndex, nameAndTypeIndex);
	}
*/
	/*
	** Public methods from ClassRead
	*/



	/*
	** Implementation specific methods.
	*/

	/*
	** Methods related to Constant Pool Table
	*/
	/**
		Generic add entry to constant pool. Includes the logic
		for an entry to occupy more than one slot (e.g. long).

		@return The number of slots occupied by the entry.
.
	*/
	protected int addEntry(Object key, ConstantPoolEntry item) {

		item.setIndex(cptEntries.size());
		if (key != null)
			cptHashTable.put(key, item);
		cptEntries.addElement(item);

		cptEstimatedSize += item.classFileSize();

		if (item.doubleSlot()) {
			cptEntries.addElement(null);
			return 2;
		} else {
			return 1;
		}
	}
	
	/**
		Add an entry, but only if it doesn't exist.

		@return the constant pool index of the added
		or existing item.
	*/
	private int addDirectEntry(ConstantPoolEntry item) {
		ConstantPoolEntry existingItem = findMatchingEntry(item);
		if (existingItem != null) {
			item = existingItem;
			//foundCount++;
		}
		else {
			addEntry(item.getKey(), item);
		}
		return item.getIndex();
	}

	/**
		Add an index reference.
	*/
	private int addIndexReference(int tag, int i1, int i2) {

		// search for the item using the pre-allocated object 
		searchIndex.set(tag, i1, i2);

		ConstantPoolEntry item = findMatchingEntry(searchIndex);

		if (item == null) {
			item = new CONSTANT_Index_info(tag, i1, i2);
			addEntry(item.getKey(), item);
		}

		return item.getIndex();
	}

	/**
		Add a class entry to the pool.
	*/