Back to index...

	/*
	* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/


	/*
	* The Original Code is HAT. The Initial Developer of the
	* Original Code is Bill Foote, with contributions from others
	* at JavaSoft/Sun.
	*/

	package com.sun.tools.hat.internal.model;

	import com.sun.tools.hat.internal.parser.ReadBuffer;
	import java.io.IOException;

	/**
	* An array of values, that is, an array of ints, boolean, floats or the like.
	*
	* @author Bill Foote
	*/
	public class JavaValueArray extends JavaLazyReadObject
	/imports/ implements ArrayTypeCodes {

	private static String arrayTypeName(byte sig) {
	switch (sig) {
	case 'B':
	return "byte[]";
	case 'Z':
	return "boolean[]";
	case 'C':
	return "char[]";
	case 'S':
	return "short[]";
	case 'I':
	return "int[]";
	case 'F':
	return "float[]";
	case 'J':
	return "long[]";
	case 'D':
	return "double[]";
	default:
	throw new RuntimeException("invalid array element sig: " + sig);
	}
	}

	private static int elementSize(byte type) {
	switch (type) {
	case T_BYTE:
	case T_BOOLEAN:
	return 1;
	case T_CHAR:
	case T_SHORT:
	return 2;
	case T_INT:
	case T_FLOAT:
	return 4;
	case T_LONG:
	case T_DOUBLE:
	return 8;
	default:
	throw new RuntimeException("invalid array element type: " + type);
	}
	}

	/*
	* Java primitive array record (HPROF_GC_PRIM_ARRAY_DUMP) looks
	* as below:
	*
	* object ID
	* stack trace serial number (int)
	* length of the instance data (int)
	* element type (byte)
	* array data
	*/
	protected final int readValueLength() throws IOException {
	JavaClass cl = getClazz();
	ReadBuffer buf = cl.getReadBuffer();
	int idSize = cl.getIdentifierSize();
	long offset = getOffset() + idSize + 4;
	// length of the array
	int len = buf.getInt(offset);
	// typecode of array element type
	byte type = buf.getByte(offset + 4);
	return len * elementSize(type);
	}

	protected final byte[] readValue() throws IOException {
	JavaClass cl = getClazz();
	ReadBuffer buf = cl.getReadBuffer();
	int idSize = cl.getIdentifierSize();
	long offset = getOffset() + idSize + 4;
	// length of the array
	int length = buf.getInt(offset);
	// typecode of array element type
	byte type = buf.getByte(offset + 4);
	if (length == 0) {
	return Snapshot.EMPTY_BYTE_ARRAY;
	} else {
	length *= elementSize(type);
	byte[] res = new byte[length];
	buf.get(offset + 5, res);
	return res;
	}
	}

	// JavaClass set only after resolve.
	private JavaClass clazz;

	// This field contains elementSignature byte and
	// divider to be used to calculate length. Note that
	// length of content byte[] is not same as array length.
	// Actual array length is (byte[].length / divider)
	private int data;

	// First 8 bits of data is used for element signature
	private static final int SIGNATURE_MASK = 0x0FF;

	// Next 8 bits of data is used for length divider
	private static final int LENGTH_DIVIDER_MASK = 0x0FF00;

	// Number of bits to shift to get length divider
	private static final int LENGTH_DIVIDER_SHIFT = 8;

	public JavaValueArray(byte elementSignature, long offset) {
	super(offset);
	this.data = (elementSignature & SIGNATURE_MASK);
	}

	public JavaClass getClazz() {
	return clazz;
	}

	public void visitReferencedObjects(JavaHeapObjectVisitor v) {
	super.visitReferencedObjects(v);
	}

	public void resolve(Snapshot snapshot) {
	if (clazz instanceof JavaClass) {
	return;
	}
	byte elementSig = getElementType();
	clazz = snapshot.findClass(arrayTypeName(elementSig));
	if (clazz == null) {
	clazz = snapshot.getArrayClass("" + ((char) elementSig));
	}
	getClazz().addInstance(this);
	super.resolve(snapshot);
	}

	public int getLength() {
	int divider = (data & LENGTH_DIVIDER_MASK) >>> LENGTH_DIVIDER_SHIFT;
	if (divider == 0) {
	byte elementSignature = getElementType();
	switch (elementSignature) {
	case 'B':
	case 'Z':
	divider = 1;
	break;
	case 'C':
	case 'S':
	divider = 2;
	break;
	case 'I':
	case 'F':
	divider = 4;
	break;
	case 'J':
	case 'D':
	divider = 8;
	break;
	default:
	throw new RuntimeException("unknown primitive type: " +
	elementSignature);
	}
	data \|= (divider << LENGTH_DIVIDER_SHIFT);
	}
	return (getValueLength() / divider);
	}

	public Object getElements() {
	final int len = getLength();
	final byte et = getElementType();
	byte[] data = getValue();
	int index = 0;
	switch (et) {
	case 'Z': {
	boolean[] res = new boolean[len];
	for (int i = 0; i < len; i++) {
	res[i] = booleanAt(index, data);
	index++;
	}
	return res;
	}
	case 'B': {
	byte[] res = new byte[len];
	for (int i = 0; i < len; i++) {
	res[i] = byteAt(index, data);
	index++;
	}
	return res;
	}
	case 'C': {
	char[] res = new char[len];
	for (int i = 0; i < len; i++) {
	res[i] = charAt(index, data);
	index += 2;
	}
	return res;
	}
	case 'S': {
	short[] res = new short[len];
	for (int i = 0; i < len; i++) {
	res[i] = shortAt(index, data);
	index += 2;
	}
	return res;
	}
	case 'I': {
	int[] res = new int[len];
	for (int i = 0; i < len; i++) {
	res[i] = intAt(index, data);
	index += 4;
	}
	return res;
	}
	case 'J': {
	long[] res = new long[len];
	for (int i = 0; i < len; i++) {
	res[i] = longAt(index, data);
	index += 8;
	}
	return res;
	}
	case 'F': {
	float[] res = new float[len];
	for (int i = 0; i < len; i++) {
	res[i] = floatAt(index, data);
	index += 4;
	}
	return res;
	}
	case 'D': {
	double[] res = new double[len];
	for (int i = 0; i < len; i++) {
	res[i] = doubleAt(index, data);
	index += 8;
	}
	return res;
	}
	default: {
	throw new RuntimeException("unknown primitive type?");
	}
	}
	}

	public byte getElementType() {
	return (byte) (data & SIGNATURE_MASK);
	}

	private void checkIndex(int index) {
	if (index < 0 \|\| index >= getLength()) {
	throw new ArrayIndexOutOfBoundsException(index);
	}
	}

	private void requireType(char type) {
	if (getElementType() != type) {
	throw new RuntimeException("not of type : " + type);
	}
	}

	public boolean getBooleanAt(int index) {
	checkIndex(index);
	requireType('Z');
	return booleanAt(index, getValue());
	}

	public byte getByteAt(int index) {
	checkIndex(index);
	requireType('B');
	return byteAt(index, getValue());
	}

	public char getCharAt(int index) {
	checkIndex(index);
	requireType('C');
	return charAt(index << 1, getValue());
	}

	public short getShortAt(int index) {
	checkIndex(index);
	requireType('S');
	return shortAt(index << 1, getValue());
	}

	public int getIntAt(int index) {
	checkIndex(index);
	requireType('I');
	return intAt(index << 2, getValue());
	}

	public long getLongAt(int index) {
	checkIndex(index);
	requireType('J');
	return longAt(index << 3, getValue());
	}

	public float getFloatAt(int index) {
	checkIndex(index);
	requireType('F');
	return floatAt(index << 2, getValue());
	}

	public double getDoubleAt(int index) {
	checkIndex(index);
	requireType('D');
	return doubleAt(index << 3, getValue());
	}

	public String valueString() {
	return valueString(true);
	}

	public String valueString(boolean bigLimit) {
	// Char arrays deserve special treatment
	StringBuffer result;
	byte[] value = getValue();
	int max = value.length;
	byte elementSignature = getElementType();
	if (elementSignature == 'C') {
	result = new StringBuffer();
	for (int i = 0; i < value.length; ) {
	char val = charAt(i, value);
	result.append(val);
	i += 2;
	}
	} else {
	int limit = 8;
	if (bigLimit) {
	limit = 1000;
	}
	result = new StringBuffer("{");
	int num = 0;
	for (int i = 0; i < value.length; ) {
	if (num > 0) {
	result.append(", ");
	}
	if (num >= limit) {
	result.append("... ");
	break;
	}
	num++;
	switch (elementSignature) {
	case 'Z': {
	boolean val = booleanAt(i, value);
	if (val) {
	result.append("true");
	} else {
	result.append("false");
	}
	i++;
	break;
	}
	case 'B': {
	int val = 0xFF & byteAt(i, value);
	result.append("0x" + Integer.toString(val, 16));
	i++;
	break;
	}
	case 'S': {
	short val = shortAt(i, value);
	i += 2;
	result.append("" + val);
	break;
	}
	case 'I': {
	int val = intAt(i, value);
	i += 4;
	result.append("" + val);
	break;
	}
	case 'J': { // long
	long val = longAt(i, value);
	result.append("" + val);
	i += 8;
	break;
	}
	case 'F': {
	float val = floatAt(i, value);
	result.append("" + val);
	i += 4;
	break;
	}
	case 'D': { // double
	double val = doubleAt(i, value);
	result.append("" + val);
	i += 8;
	break;
	}
	default: {
	throw new RuntimeException("unknown primitive type?");
	}
	}
	}
	result.append("}");
	}
	return result.toString();
	}

	}

Back to index...