Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2012 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
 
 package org.eclipse.jdt.internal.core.builder;
 
 import  org.eclipse.core.resources.*;
 import  org.eclipse.core.runtime.*;
 
 
 import java.io.*;
 import java.util.*;
 
 public class State {
 // NOTE: this state cannot contain types that are not defined in this project
 
 // keyed by the project relative path of the type (i.e. "src1/p1/p2/A.java"), value is a ReferenceCollection or an AdditionalTypeCollection
 // keyed by qualified type name "p1/p2/A", value is the project relative path which defines this type "src1/p1/p2/A.java"
 
 
 private String[] knownPackageNames// of the form "p1/p2"
 
 public static int MaxStructurallyChangedTypes = 100; // keep track of ? structurally changed types, otherwise consider all to be changed
 
 public static final byte VERSION = 0x001B;
 
 static final byte SOURCE_FOLDER = 1;
 static final byte BINARY_FOLDER = 2;
 static final byte EXTERNAL_JAR = 3;
 static final byte INTERNAL_JAR = 4;
 
 State() {
 	// constructor with no argument
 }
 
 protected State(JavaBuilder javaBuilder) {
 	this. = null;
 	this. = null;
 	this. = javaBuilder.currentProject.getName();
 	this. = javaBuilder.nameEnvironment.sourceLocations;
 	this. = javaBuilder.nameEnvironment.binaryLocations;
 	this. = new SimpleLookupTable(7);
 	this. = new SimpleLookupTable(7);
 
 	this. = 0; // indicates a full build
 	this. = computeStructuralBuildTime(javaBuilder.lastState == null ? 0 : javaBuilder.lastState.lastStructuralBuildTime);
 }
 
 long computeStructuralBuildTime(long previousTime) {
 	long newTime = System.currentTimeMillis();
 	if (newTime <= previousTime)
 		newTime = previousTime + 1;
 	return newTime;
 }
 
 void copyFrom(State lastState) {
 	this. = null;
 	this. = lastState.previousStructuralBuildTime;
 	this. = lastState.structurallyChangedTypes;
 	this. = lastState.buildNumber + 1;
 	this. = lastState.lastStructuralBuildTime;
 	this. = lastState.structuralBuildTimes;
 
 	try {
 		this. = (SimpleLookupTablelastState.references.clone();
 		this. = (SimpleLookupTablelastState.typeLocators.clone();
 	} catch (CloneNotSupportedException e) {
 		this. = new SimpleLookupTable(lastState.references.elementSize);
 		Object[] keyTable = lastState.references.keyTable;
 		Object[] valueTable = lastState.references.valueTable;
 		for (int i = 0, l = keyTable.lengthi < li++)
 			if (keyTable[i] != null)
 				this..put(keyTable[i], valueTable[i]);
 
 		this. = new SimpleLookupTable(lastState.typeLocators.elementSize);
		keyTable = lastState.typeLocators.keyTable;
		valueTable = lastState.typeLocators.valueTable;
		for (int i = 0, l = keyTable.lengthi < li++)
			if (keyTable[i] != null)
				this..put(keyTable[i], valueTable[i]);
	}
public char[][] getDefinedTypeNamesFor(String typeLocator) {
	Object c = this..get(typeLocator);
	if (c instanceof AdditionalTypeCollection)
	return null// means only one type is defined with the same name as the file... saves space
	return this.;
	if (prereqState != null && prereqState.previousStructuralBuildTime > 0) {
		Object o = this..get(prereqState.javaProjectName);
		long previous = o == null ? 0 : ((Longo).longValue();
		if (previous == prereqState.previousStructuralBuildTime)
			return prereqState.structurallyChangedTypes;
	}
	return null;
public boolean isDuplicateLocator(String qualifiedTypeNameString typeLocator) {
	String existing = (Stringthis..get(qualifiedTypeName);
	return existing != null && !existing.equals(typeLocator);
public boolean isKnownPackage(String qualifiedPackageName) {
	if (this. == null) {
		Object[] keyTable = this..;
		for (int i = 0, l = keyTable.lengthi < li++) {
			if (keyTable[i] != null) {
				String packageName = (StringkeyTable[i]; // is a type name of the form p1/p2/A
				int last = packageName.lastIndexOf('/');
				packageName = last == -1 ? null : packageName.substring(0, last);
				while (packageName != null && !names.contains(packageName)) {
					names.add(packageName);
					last = packageName.lastIndexOf('/');
					packageName = last == -1 ? null : packageName.substring(0, last);
				}
			}
		}
		this. = new String[names.size()];
	}
	for (int i = 0, l = this..lengthi < li++)
		if (this.[i].equals(qualifiedPackageName))
			return true;
	return false;
public boolean isKnownType(String qualifiedTypeName) {
	return this..containsKey(qualifiedTypeName);
boolean isSourceFolderEmpty(IContainer sourceFolder) {
	String sourceFolderName = sourceFolder.getProjectRelativePath().addTrailingSeparator().toString();
	Object[] table = this..;
	for (int i = 0, l = table.lengthi < li++)
		if (table[i] != null && ((Stringtable[i]).startsWith(sourceFolderName))
			return false;
	return true;
void record(String typeLocatorchar[][][] qualifiedRefschar[][] simpleRefschar[][] rootRefschar[] mainTypeNameArrayList typeNames) {
	if (typeNames.size() == 1 && CharOperation.equals(mainTypeName, (char[]) typeNames.get(0))) {
		this..put(typeLocatornew ReferenceCollection(qualifiedRefssimpleRefsrootRefs));
else {
		char[][] definedTypeNames = new char[typeNames.size()][]; // can be empty when no types are defined
		typeNames.toArray(definedTypeNames);
		this..put(typeLocatornew AdditionalTypeCollection(definedTypeNamesqualifiedRefssimpleRefsrootRefs));
	}
void recordLocatorForType(String qualifiedTypeNameString typeLocator) {
	this. = null;
	// in the common case, the qualifiedTypeName is a substring of the typeLocator so share the char[] by using String.substring()
	int start = typeLocator.indexOf(qualifiedTypeName, 0);
	if (start > 0)
		qualifiedTypeName = typeLocator.substring(startstart + qualifiedTypeName.length());
	this..put(qualifiedTypeNametypeLocator);
void recordStructuralDependency(IProject prereqProjectState prereqState) {
	if (prereqState != null)
		if (prereqState.lastStructuralBuildTime > 0) // can skip if 0 (full build) since its assumed to be 0 if unknown
			this..put(prereqProject.getName(), new Long(prereqState.lastStructuralBuildTime));
void removeLocator(String typeLocatorToRemove) {
	this. = null;
	this..removeKey(typeLocatorToRemove);
	this..removeValue(typeLocatorToRemove);
void removePackage(IResourceDelta sourceDelta) {
	IResource resource = sourceDelta.getResource();
	switch(resource.getType()) {
		case IResource.FOLDER :
			IResourceDelta[] children = sourceDelta.getAffectedChildren();
			for (int i = 0, l = children.length; i < li++)
				removePackage(children[i]);
			return;
		case IResource.FILE :
			IPath typeLocatorPath = resource.getProjectRelativePath();
			if (org.eclipse.jdt.internal.core.util.Util.isJavaLikeFileName(typeLocatorPath.lastSegment()))
				removeLocator(typeLocatorPath.toString());
	}
void removeQualifiedTypeName(String qualifiedTypeNameToRemove) {
	this. = null;
	this..removeKey(qualifiedTypeNameToRemove);
static State read(IProject projectDataInputStream inthrows IOException {
		..println("About to read state " + project.getName()); //$NON-NLS-1$
	if ( != in.readByte()) {
			..println("Found non-compatible state version... answered null for " + project.getName()); //$NON-NLS-1$
		return null;
	}
	State newState = new State();
	newState.javaProjectName = in.readUTF();
	if (!project.getName().equals(newState.javaProjectName)) {
			..println("Project's name does not match... answered null"); //$NON-NLS-1$
		return null;
	}
	newState.buildNumber = in.readInt();
	newState.lastStructuralBuildTime = in.readLong();
	int length = in.readInt();
	newState.sourceLocations = new ClasspathMultiDirectory[length];
	for (int i = 0; i < lengthi++) {
		IContainer sourceFolder = projectoutputFolder = project;
		String folderName;
		if ((folderName = in.readUTF()).length() > 0) sourceFolder = project.getFolder(folderName);
		if ((folderName = in.readUTF()).length() > 0) outputFolder = project.getFolder(folderName);
			(ClasspathMultiDirectory) ClasspathLocation.forSourceFolder(sourceFolderoutputFolderreadNames(in), readNames(in), in.readBoolean());
		if (in.readBoolean())
			md.hasIndependentOutputFolder = true;
		newState.sourceLocations[i] = md;
	}
	length = in.readInt();
	newState.binaryLocations = new ClasspathLocation[length];
	IWorkspaceRoot root = project.getWorkspace().getRoot();
	for (int i = 0; i < lengthi++) {
		switch (in.readByte()) {
				newState.binaryLocations[i] = newState.sourceLocations[in.readInt()];
				break;
				IPath path = new Path(in.readUTF());
				IContainer outputFolder = path.segmentCount() == 1
					? (IContainer) root.getProject(path.toString())
					: (IContainer) root.getFolder(path);
				newState.binaryLocations[i] = ClasspathLocation.forBinaryFolder(outputFolderin.readBoolean(), readRestriction(in));
				break;
			case  :
				newState.binaryLocations[i] = ClasspathLocation.forLibrary(in.readUTF(), in.readLong(), readRestriction(in));
				break;
			case  :
				newState.binaryLocations[i] = ClasspathLocation.forLibrary(root.getFile(new Path(in.readUTF())), readRestriction(in));
		}
	}
	newState.structuralBuildTimes = new SimpleLookupTable(length = in.readInt());
	for (int i = 0; i < lengthi++)
		newState.structuralBuildTimes.put(in.readUTF(), new Long(in.readLong()));
	String[] internedTypeLocators = new String[length = in.readInt()];
	for (int i = 0; i < lengthi++)
		internedTypeLocators[i] = in.readUTF();
	newState.typeLocators = new SimpleLookupTable(length = in.readInt());
	for (int i = 0; i < lengthi++)
		newState.recordLocatorForType(in.readUTF(), internedTypeLocators[in.readInt()]);
	char[][] internedRootNames = ReferenceCollection.internSimpleNames(readNames(in), false);
	char[][] internedSimpleNames = ReferenceCollection.internSimpleNames(readNames(in), false);
	char[][][] internedQualifiedNames = new char[length = in.readInt()][][];
	for (int i = 0; i < lengthi++) {
		int qLength = in.readInt();
		char[][] qName = new char[qLength][];
		for (int j = 0; j < qLengthj++)
			qName[j] = internedSimpleNames[in.readInt()];
		internedQualifiedNames[i] = qName;
	}
	internedQualifiedNames = ReferenceCollection.internQualifiedNames(internedQualifiedNamesfalse);
	newState.references = new SimpleLookupTable(length = in.readInt());
	for (int i = 0; i < lengthi++) {
		String typeLocator = internedTypeLocators[in.readInt()];
		ReferenceCollection collection = null;
		switch (in.readByte()) {
			case 1 :
				char[][] additionalTypeNames = readNames(in);
				char[][][] qualifiedNames = new char[in.readInt()][][];
				for (int j = 0, m = qualifiedNames.lengthj < mj++)
					qualifiedNames[j] = internedQualifiedNames[in.readInt()];
				char[][] simpleNames = new char[in.readInt()][];
				for (int j = 0, m = simpleNames.lengthj < mj++)
					simpleNames[j] = internedSimpleNames[in.readInt()];
				char[][] rootNames = new char[in.readInt()][];
				for (int j = 0, m = rootNames.lengthj < mj++)
					rootNames[j] = internedRootNames[in.readInt()];
				collection = new AdditionalTypeCollection(additionalTypeNamesqualifiedNamessimpleNamesrootNames);
				break;
			case 2 :
				char[][][] qNames = new char[in.readInt()][][];
				for (int j = 0, m = qNames.lengthj < mj++)
					qNames[j] = internedQualifiedNames[in.readInt()];
				char[][] sNames = new char[in.readInt()][];
				for (int j = 0, m = sNames.lengthj < mj++)
					sNames[j] = internedSimpleNames[in.readInt()];
				char[][] rNames = new char[in.readInt()][];
				for (int j = 0, m = rNames.lengthj < mj++)
					rNames[j] = internedRootNames[in.readInt()];
				collection = new ReferenceCollection(qNamessNamesrNames);
		}
		newState.references.put(typeLocatorcollection);
	}
		..println("Successfully read state for " + newState.javaProjectName); //$NON-NLS-1$
	return newState;
private static char[] readName(DataInputStream inthrows IOException {
	int nLength = in.readInt();
	char[] name = new char[nLength];
	for (int j = 0; j < nLengthj++)
		name[j] = in.readChar();
	return name;
private static char[][] readNames(DataInputStream inthrows IOException {
	int length = in.readInt();
	char[][] names = new char[length][];
	for (int i = 0; i < lengthi++)
		names[i] = readName(in);
	return names;
private static AccessRuleSet readRestriction(DataInputStream inthrows IOException {
	int length = in.readInt();
	if (length == 0) return null// no restriction specified
	AccessRule[] accessRules = new AccessRule[length];
	for (int i = 0; i < lengthi++) {
		char[] pattern = readName(in);
		int problemId = in.readInt();
		accessRules[i] = new ClasspathAccessRule(patternproblemId);
	}
	JavaModelManager manager = JavaModelManager.getJavaModelManager();
	return new AccessRuleSet(accessRulesin.readByte(), manager.intern(in.readUTF()));
	this. = -1; // tag the project since it has no source folders and can be skipped
boolean wasNoopBuild() {
	return this. == -1;
boolean wasStructurallyChanged(IProject prereqProjectState prereqState) {
	if (prereqState != null) {
		Object o = this..get(prereqProject.getName());
		long previous = o == null ? 0 : ((Longo).longValue();
		if (previous == prereqState.lastStructuralBuildTimereturn false;
	}
	return true;
void wasStructurallyChanged(String typeName) {
	if (this. != null) {
			this. = null// too many to keep track of
		else
	}
void write(DataOutputStream outthrows IOException {
	int length;
	Object[] keyTable;
	Object[] valueTable;
/*
 * byte		VERSION
 * String		project name
 * int			build number
 * int			last structural build number
*/
/*
 * ClasspathMultiDirectory[]
 * int			id
 * String		path(s)
*/
	out.writeInt(length = this..length);
	for (int i = 0; i < lengthi++) {
		out.writeUTF(md.sourceFolder.getProjectRelativePath().toString());
		out.writeUTF(md.binaryFolder.getProjectRelativePath().toString());
		writeNames(md.inclusionPatternsout);
		writeNames(md.exclusionPatternsout);
		out.writeBoolean(md.ignoreOptionalProblems);
		out.writeBoolean(md.hasIndependentOutputFolder);
	}
/*
 * ClasspathLocation[]
 * int			id
 * String		path(s)
*/
	out.writeInt(length = this..length);
	next : for (int i = 0; i < lengthi++) {
		if (c instanceof ClasspathMultiDirectory) {
			for (int j = 0, m = this..lengthj < mj++) {
				if (this.[j] == c) {
					out.writeInt(j);
					continue next;
				}
			}
else if (c instanceof ClasspathDirectory) {
			out.writeUTF(cd.binaryFolder.getFullPath().toString());
			out.writeBoolean(cd.isOutputFolder);
			writeRestriction(cd.accessRuleSetout);
else {
			if (jar.resource == null) {
				out.writeUTF(jar.zipFilename);
else {
				out.writeUTF(jar.resource.getFullPath().toString());
			}
			writeRestriction(jar.accessRuleSetout);
		}
	}
/*
 * Structural build numbers table
 * String		prereq project name
 * int			last structural build number
*/
	if (length > 0) {
		keyTable = this..;
		valueTable = this..;
		for (int i = 0, l = keyTable.lengthi < li++) {
			if (keyTable[i] != null) {
				length--;
				out.writeUTF((StringkeyTable[i]);
				out.writeLong(((LongvalueTable[i]).longValue());
			}
		}
		if (. && length != 0)
			..println("structuralBuildNumbers table is inconsistent"); //$NON-NLS-1$
	}
/*
 * String[]	Interned type locators
 */
	out.writeInt(length = this..);
	SimpleLookupTable internedTypeLocators = new SimpleLookupTable(length);
	if (length > 0) {
		keyTable = this..;
		for (int i = 0, l = keyTable.lengthi < li++) {
			if (keyTable[i] != null) {
				length--;
				String key = (StringkeyTable[i];
				out.writeUTF(key);
				internedTypeLocators.put(keynew Integer(internedTypeLocators.elementSize));
			}
		}
		if (. && length != 0)
			..println("references table is inconsistent"); //$NON-NLS-1$
	}
/*
 * Type locators table
 * String		type name
 * int			interned locator id
 */
	out.writeInt(length = this..);
	if (length > 0) {
		keyTable = this..;
		valueTable = this..;
		for (int i = 0, l = keyTable.lengthi < li++) {
			if (keyTable[i] != null) {
				length--;
				out.writeUTF((StringkeyTable[i]);
				Integer index = (IntegerinternedTypeLocators.get(valueTable[i]);
				out.writeInt(index.intValue());
			}
		}
		if (. && length != 0)
			..println("typeLocators table is inconsistent"); //$NON-NLS-1$
	}
/*
 * char[][]	Interned root names
 * char[][][]	Interned qualified names
 * char[][]	Interned simple names
 */
	SimpleLookupTable internedRootNames = new SimpleLookupTable(3);
	SimpleLookupTable internedQualifiedNames = new SimpleLookupTable(31);
	SimpleLookupTable internedSimpleNames = new SimpleLookupTable(31);
	valueTable = this..;
	for (int i = 0, l = valueTable.lengthi < li++) {
		if (valueTable[i] != null) {
			ReferenceCollection collection = (ReferenceCollectionvalueTable[i];
			char[][] rNames = collection.rootReferences;
			for (int j = 0, m = rNames.lengthj < mj++) {
				char[] rName = rNames[j];
				if (!internedRootNames.containsKey(rName)) // remember the names have been interned
					internedRootNames.put(rNamenew Integer(internedRootNames.elementSize));
			}
			char[][][] qNames = collection.qualifiedNameReferences;
			for (int j = 0, m = qNames.lengthj < mj++) {
				char[][] qName = qNames[j];
				if (!internedQualifiedNames.containsKey(qName)) { // remember the names have been interned
					internedQualifiedNames.put(qNamenew Integer(internedQualifiedNames.elementSize));
					for (int k = 0, n = qName.lengthk < nk++) {
						char[] sName = qName[k];
						if (!internedSimpleNames.containsKey(sName)) // remember the names have been interned
							internedSimpleNames.put(sNamenew Integer(internedSimpleNames.elementSize));
					}
				}
			}
			char[][] sNames = collection.simpleNameReferences;
			for (int j = 0, m = sNames.lengthj < mj++) {
				char[] sName = sNames[j];
				if (!internedSimpleNames.containsKey(sName)) // remember the names have been interned
					internedSimpleNames.put(sNamenew Integer(internedSimpleNames.elementSize));
			}
		}
	}
	char[][] internedArray = new char[internedRootNames.elementSize][];
	Object[] rootNames = internedRootNames.keyTable;
	Object[] positions = internedRootNames.valueTable;
	for (int i = positions.length; --i >= 0; ) {
		if (positions[i] != null) {
			int index = ((Integerpositions[i]).intValue();
			internedArray[index] = (char[]) rootNames[i];
		}
	}
	writeNames(internedArrayout);
	// now write the interned simple names
	internedArray = new char[internedSimpleNames.elementSize][];
	Object[] simpleNames = internedSimpleNames.keyTable;
	positions = internedSimpleNames.valueTable;
	for (int i = positions.length; --i >= 0; ) {
		if (positions[i] != null) {
			int index = ((Integerpositions[i]).intValue();
			internedArray[index] = (char[]) simpleNames[i];
		}
	}
	writeNames(internedArrayout);
	// now write the interned qualified names as arrays of interned simple names
	char[][][] internedQArray = new char[internedQualifiedNames.elementSize][][];
	Object[] qualifiedNames = internedQualifiedNames.keyTable;
	positions = internedQualifiedNames.valueTable;
	for (int i = positions.length; --i >= 0; ) {
		if (positions[i] != null) {
			int index = ((Integerpositions[i]).intValue();
			internedQArray[index] = (char[][]) qualifiedNames[i];
		}
	}
	out.writeInt(length = internedQArray.length);
	for (int i = 0; i < lengthi++) {
		char[][] qName = internedQArray[i];
		int qLength = qName.length;
		out.writeInt(qLength);
		for (int j = 0; j < qLengthj++) {
			Integer index = (IntegerinternedSimpleNames.get(qName[j]);
			out.writeInt(index.intValue());
		}
	}
/*
 * References table
 * int		interned locator id
 * ReferenceCollection
*/
	out.writeInt(length = this..);
	if (length > 0) {
		keyTable = this..;
		for (int i = 0, l = keyTable.lengthi < li++) {
			if (keyTable[i] != null) {
				length--;
				Integer index = (IntegerinternedTypeLocators.get(keyTable[i]);
				out.writeInt(index.intValue());
				ReferenceCollection collection = (ReferenceCollectionvalueTable[i];
				if (collection instanceof AdditionalTypeCollection) {
					out.writeByte(1);
					writeNames(atc.definedTypeNamesout);
else {
					out.writeByte(2);
				}
				char[][][] qNames = collection.qualifiedNameReferences;
				int qLength = qNames.length;
				out.writeInt(qLength);
				for (int j = 0; j < qLengthj++) {
					index = (IntegerinternedQualifiedNames.get(qNames[j]);
					out.writeInt(index.intValue());
				}
				char[][] sNames = collection.simpleNameReferences;
				int sLength = sNames.length;
				out.writeInt(sLength);
				for (int j = 0; j < sLengthj++) {
					index = (IntegerinternedSimpleNames.get(sNames[j]);
					out.writeInt(index.intValue());
				}
				char[][] rNames = collection.rootReferences;
				int rLength = rNames.length;
				out.writeInt(rLength);
				for (int j = 0; j < rLengthj++) {
					index = (IntegerinternedRootNames.get(rNames[j]);
					out.writeInt(index.intValue());
				}
			}
		}
		if (. && length != 0)
			..println("references table is inconsistent"); //$NON-NLS-1$
	}
private void writeName(char[] nameDataOutputStream outthrows IOException {
	int nLength = name.length;
	out.writeInt(nLength);
	for (int j = 0; j < nLengthj++)
		out.writeChar(name[j]);
private void writeNames(char[][] namesDataOutputStream outthrows IOException {
	int length = names == null ? 0 : names.length;
	out.writeInt(length);
	for (int i = 0; i < lengthi++)
		writeName(names[i], out);
private void writeRestriction(AccessRuleSet accessRuleSetDataOutputStream outthrows IOException {
	if (accessRuleSet == null) {
		out.writeInt(0);
else {
		AccessRule[] accessRules = accessRuleSet.getAccessRules();
		int length = accessRules.length;
		out.writeInt(length);
		if (length != 0) {
			for (int i = 0; i < lengthi++) {
				AccessRule accessRule = accessRules[i];
				writeName(accessRule.patternout);
				out.writeInt(accessRule.problemId);
			}
			out.writeByte(accessRuleSet.classpathEntryType);
			out.writeUTF(accessRuleSet.classpathEntryName);
		}
	}
Returns a string representation of the receiver.
public String toString() {
	return "State for " + this. //$NON-NLS-1$
" (#" + this. //$NON-NLS-1$
" @ " + new Date(this.//$NON-NLS-1$
")"//$NON-NLS-1$
/* Debug helper
void dump() {
	System.out.println("State for " + javaProjectName + " (" + buildNumber + " @ " + new Date(lastStructuralBuildTime) + ")");
	System.out.println("\tClass path source locations:");
	for (int i = 0, l = sourceLocations.length; i < l; i++)
		System.out.println("\t\t" + sourceLocations[i]);
	System.out.println("\tClass path binary locations:");
	for (int i = 0, l = binaryLocations.length; i < l; i++)
		System.out.println("\t\t" + binaryLocations[i]);
	System.out.print("\tStructural build numbers table:");
	if (structuralBuildTimes.elementSize == 0) {
		System.out.print(" <empty>");
	} else {
		Object[] keyTable = structuralBuildTimes.keyTable;
		Object[] valueTable = structuralBuildTimes.valueTable;
		for (int i = 0, l = keyTable.length; i < l; i++)
			if (keyTable[i] != null)
				System.out.print("\n\t\t" + keyTable[i].toString() + " -> " + valueTable[i].toString());
	}
	System.out.print("\tType locators table:");
	if (typeLocators.elementSize == 0) {
		System.out.print(" <empty>");
	} else {
		Object[] keyTable = typeLocators.keyTable;
		Object[] valueTable = typeLocators.valueTable;
		for (int i = 0, l = keyTable.length; i < l; i++)
			if (keyTable[i] != null)
				System.out.print("\n\t\t" + keyTable[i].toString() + " -> " + valueTable[i].toString());
	}
	System.out.print("\n\tReferences table:");
	if (references.elementSize == 0) {
		System.out.print(" <empty>");
	} else {
		Object[] keyTable = references.keyTable;
		Object[] valueTable = references.valueTable;
		for (int i = 0, l = keyTable.length; i < l; i++) {
			if (keyTable[i] != null) {
				System.out.print("\n\t\t" + keyTable[i].toString());
				ReferenceCollection c = (ReferenceCollection) valueTable[i];
				char[][][] qRefs = c.qualifiedNameReferences;
				System.out.print("\n\t\t\tqualified:");
				if (qRefs.length == 0)
					System.out.print(" <empty>");
				else for (int j = 0, m = qRefs.length; j < m; j++)
						System.out.print("  '" + CharOperation.toString(qRefs[j]) + "'");
				char[][] sRefs = c.simpleNameReferences;
				System.out.print("\n\t\t\tsimple:");
				if (sRefs.length == 0)
					System.out.print(" <empty>");
				else for (int j = 0, m = sRefs.length; j < m; j++)
						System.out.print("  " + new String(sRefs[j]));
				if (c instanceof AdditionalTypeCollection) {
					char[][] names = ((AdditionalTypeCollection) c).definedTypeNames;
					System.out.print("\n\t\t\tadditional type names:");
					for (int j = 0, m = names.length; j < m; j++)
						System.out.print("  " + new String(names[j]));
				}
			}
		}
	}
	System.out.print("\n\n");
*/
New to GrepCode? Check out our FAQ X