--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/com/sun/tools/jdi/PacketStream.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,628 @@
+/*
+ * Copyright 1998-2005 Sun Microsystems, Inc. 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. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+package com.sun.tools.jdi;
+
+import com.sun.jdi.*;
+import java.util.*;
+import java.io.ByteArrayOutputStream;
+
+class PacketStream {
+ final VirtualMachineImpl vm;
+ private int inCursor = 0;
+ final Packet pkt;
+ private ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
+ private boolean isCommitted = false;
+
+ PacketStream(VirtualMachineImpl vm, int cmdSet, int cmd) {
+ this.vm = vm;
+ this.pkt = new Packet();
+ pkt.cmdSet = (short)cmdSet;
+ pkt.cmd = (short)cmd;
+ }
+
+ PacketStream(VirtualMachineImpl vm, Packet pkt) {
+ this.vm = vm;
+ this.pkt = pkt;
+ this.isCommitted = true; /* read only stream */
+ }
+
+ int id() {
+ return pkt.id;
+ }
+
+ void send() {
+ if (!isCommitted) {
+ pkt.data = dataStream.toByteArray();
+ vm.sendToTarget(pkt);
+ isCommitted = true;
+ }
+ }
+
+ void waitForReply() throws JDWPException {
+ if (!isCommitted) {
+ throw new InternalException("waitForReply without send");
+ }
+
+ vm.waitForTargetReply(pkt);
+
+ if (pkt.errorCode != Packet.ReplyNoError) {
+ throw new JDWPException(pkt.errorCode);
+ }
+ }
+
+ void writeBoolean(boolean data) {
+ if(data) {
+ dataStream.write( 1 );
+ } else {
+ dataStream.write( 0 );
+ }
+ }
+
+ void writeByte(byte data) {
+ dataStream.write( data );
+ }
+
+ void writeChar(char data) {
+ dataStream.write( (byte)((data >>> 8) & 0xFF) );
+ dataStream.write( (byte)((data >>> 0) & 0xFF) );
+ }
+
+ void writeShort(short data) {
+ dataStream.write( (byte)((data >>> 8) & 0xFF) );
+ dataStream.write( (byte)((data >>> 0) & 0xFF) );
+ }
+
+ void writeInt(int data) {
+ dataStream.write( (byte)((data >>> 24) & 0xFF) );
+ dataStream.write( (byte)((data >>> 16) & 0xFF) );
+ dataStream.write( (byte)((data >>> 8) & 0xFF) );
+ dataStream.write( (byte)((data >>> 0) & 0xFF) );
+ }
+
+ void writeLong(long data) {
+ dataStream.write( (byte)((data >>> 56) & 0xFF) );
+ dataStream.write( (byte)((data >>> 48) & 0xFF) );
+ dataStream.write( (byte)((data >>> 40) & 0xFF) );
+ dataStream.write( (byte)((data >>> 32) & 0xFF) );
+
+ dataStream.write( (byte)((data >>> 24) & 0xFF) );
+ dataStream.write( (byte)((data >>> 16) & 0xFF) );
+ dataStream.write( (byte)((data >>> 8) & 0xFF) );
+ dataStream.write( (byte)((data >>> 0) & 0xFF) );
+ }
+
+ void writeFloat(float data) {
+ writeInt(Float.floatToIntBits(data));
+ }
+
+ void writeDouble(double data) {
+ writeLong(Double.doubleToLongBits(data));
+ }
+
+ void writeID(int size, long data) {
+ switch (size) {
+ case 8:
+ writeLong(data);
+ break;
+ case 4:
+ writeInt((int)data);
+ break;
+ case 2:
+ writeShort((short)data);
+ break;
+ default:
+ throw new UnsupportedOperationException("JDWP: ID size not supported: " + size);
+ }
+ }
+
+ void writeNullObjectRef() {
+ writeObjectRef(0);
+ }
+
+ void writeObjectRef(long data) {
+ writeID(vm.sizeofObjectRef, data);
+ }
+
+ void writeClassRef(long data) {
+ writeID(vm.sizeofClassRef, data);
+ }
+
+ void writeMethodRef(long data) {
+ writeID(vm.sizeofMethodRef, data);
+ }
+
+ void writeFieldRef(long data) {
+ writeID(vm.sizeofFieldRef, data);
+ }
+
+ void writeFrameRef(long data) {
+ writeID(vm.sizeofFrameRef, data);
+ }
+
+ void writeByteArray(byte[] data) {
+ dataStream.write(data, 0, data.length);
+ }
+
+ void writeString(String string) {
+ try {
+ byte[] stringBytes = string.getBytes("UTF8");
+ writeInt(stringBytes.length);
+ writeByteArray(stringBytes);
+ } catch (java.io.UnsupportedEncodingException e) {
+ throw new InternalException("Cannot convert string to UTF8 bytes");
+ }
+ }
+
+ void writeLocation(Location location) {
+ ReferenceTypeImpl refType = (ReferenceTypeImpl)location.declaringType();
+ byte tag;
+ if (refType instanceof ClassType) {
+ tag = JDWP.TypeTag.CLASS;
+ } else if (refType instanceof InterfaceType) {
+ // It's possible to have executable code in an interface
+ tag = JDWP.TypeTag.INTERFACE;
+ } else {
+ throw new InternalException("Invalid Location");
+ }
+ writeByte(tag);
+ writeClassRef(refType.ref());
+ writeMethodRef(((MethodImpl)location.method()).ref());
+ writeLong(location.codeIndex());
+ }
+
+ void writeValue(Value val) {
+ try {
+ writeValueChecked(val);
+ } catch (InvalidTypeException exc) { // should never happen
+ throw new RuntimeException(
+ "Internal error: Invalid Tag/Type pair");
+ }
+ }
+
+ void writeValueChecked(Value val) throws InvalidTypeException {
+ writeByte(ValueImpl.typeValueKey(val));
+ writeUntaggedValue(val);
+ }
+
+ void writeUntaggedValue(Value val) {
+ try {
+ writeUntaggedValueChecked(val);
+ } catch (InvalidTypeException exc) { // should never happen
+ throw new RuntimeException(
+ "Internal error: Invalid Tag/Type pair");
+ }
+ }
+
+ void writeUntaggedValueChecked(Value val) throws InvalidTypeException {
+ byte tag = ValueImpl.typeValueKey(val);
+ if (isObjectTag(tag)) {
+ if (val == null) {
+ writeObjectRef(0);
+ } else {
+ if (!(val instanceof ObjectReference)) {
+ throw new InvalidTypeException();
+ }
+ writeObjectRef(((ObjectReferenceImpl)val).ref());
+ }
+ } else {
+ switch (tag) {
+ case JDWP.Tag.BYTE:
+ if(!(val instanceof ByteValue))
+ throw new InvalidTypeException();
+
+ writeByte(((PrimitiveValue)val).byteValue());
+ break;
+
+ case JDWP.Tag.CHAR:
+ if(!(val instanceof CharValue))
+ throw new InvalidTypeException();
+
+ writeChar(((PrimitiveValue)val).charValue());
+ break;
+
+ case JDWP.Tag.FLOAT:
+ if(!(val instanceof FloatValue))
+ throw new InvalidTypeException();
+
+ writeFloat(((PrimitiveValue)val).floatValue());
+ break;
+
+ case JDWP.Tag.DOUBLE:
+ if(!(val instanceof DoubleValue))
+ throw new InvalidTypeException();
+
+ writeDouble(((PrimitiveValue)val).doubleValue());
+ break;
+
+ case JDWP.Tag.INT:
+ if(!(val instanceof IntegerValue))
+ throw new InvalidTypeException();
+
+ writeInt(((PrimitiveValue)val).intValue());
+ break;
+
+ case JDWP.Tag.LONG:
+ if(!(val instanceof LongValue))
+ throw new InvalidTypeException();
+
+ writeLong(((PrimitiveValue)val).longValue());
+ break;
+
+ case JDWP.Tag.SHORT:
+ if(!(val instanceof ShortValue))
+ throw new InvalidTypeException();
+
+ writeShort(((PrimitiveValue)val).shortValue());
+ break;
+
+ case JDWP.Tag.BOOLEAN:
+ if(!(val instanceof BooleanValue))
+ throw new InvalidTypeException();
+
+ writeBoolean(((PrimitiveValue)val).booleanValue());
+ break;
+ }
+ }
+ }
+
+
+
+ /**
+ * Read byte represented as one bytes.
+ */
+ byte readByte() {
+ byte ret = pkt.data[inCursor];
+ inCursor += 1;
+ return ret;
+ }
+
+ /**
+ * Read boolean represented as one byte.
+ */
+ boolean readBoolean() {
+ byte ret = readByte();
+ return (ret != 0);
+ }
+
+ /**
+ * Read char represented as two bytes.
+ */
+ char readChar() {
+ int b1, b2;
+
+ b1 = pkt.data[inCursor++] & 0xff;
+ b2 = pkt.data[inCursor++] & 0xff;
+
+ return (char)((b1 << 8) + b2);
+ }
+
+ /**
+ * Read short represented as two bytes.
+ */
+ short readShort() {
+ int b1, b2;
+
+ b1 = pkt.data[inCursor++] & 0xff;
+ b2 = pkt.data[inCursor++] & 0xff;
+
+ return (short)((b1 << 8) + b2);
+ }
+
+ /**
+ * Read int represented as four bytes.
+ */
+ int readInt() {
+ int b1,b2,b3,b4;
+
+ b1 = pkt.data[inCursor++] & 0xff;
+ b2 = pkt.data[inCursor++] & 0xff;
+ b3 = pkt.data[inCursor++] & 0xff;
+ b4 = pkt.data[inCursor++] & 0xff;
+
+ return ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
+ }
+
+ /**
+ * Read long represented as eight bytes.
+ */
+ long readLong() {
+ long b1,b2,b3,b4;
+ long b5,b6,b7,b8;
+
+ b1 = pkt.data[inCursor++] & 0xff;
+ b2 = pkt.data[inCursor++] & 0xff;
+ b3 = pkt.data[inCursor++] & 0xff;
+ b4 = pkt.data[inCursor++] & 0xff;
+
+ b5 = pkt.data[inCursor++] & 0xff;
+ b6 = pkt.data[inCursor++] & 0xff;
+ b7 = pkt.data[inCursor++] & 0xff;
+ b8 = pkt.data[inCursor++] & 0xff;
+
+ return ((b1 << 56) + (b2 << 48) + (b3 << 40) + (b4 << 32)
+ + (b5 << 24) + (b6 << 16) + (b7 << 8) + b8);
+ }
+
+ /**
+ * Read float represented as four bytes.
+ */
+ float readFloat() {
+ return Float.intBitsToFloat(readInt());
+ }
+
+ /**
+ * Read double represented as eight bytes.
+ */
+ double readDouble() {
+ return Double.longBitsToDouble(readLong());
+ }
+
+ /**
+ * Read string represented as four byte length followed by
+ * characters of the string.
+ */
+ String readString() {
+ String ret;
+ int len = readInt();
+
+ try {
+ ret = new String(pkt.data, inCursor, len, "UTF8");
+ } catch(java.io.UnsupportedEncodingException e) {
+ System.err.println(e);
+ ret = "Conversion error!";
+ }
+ inCursor += len;
+ return ret;
+ }
+
+ private long readID(int size) {
+ switch (size) {
+ case 8:
+ return readLong();
+ case 4:
+ return (long)readInt();
+ case 2:
+ return (long)readShort();
+ default:
+ throw new UnsupportedOperationException("JDWP: ID size not supported: " + size);
+ }
+ }
+
+ /**
+ * Read object represented as vm specific byte sequence.
+ */
+ long readObjectRef() {
+ return readID(vm.sizeofObjectRef);
+ }
+
+ long readClassRef() {
+ return readID(vm.sizeofClassRef);
+ }
+
+ ObjectReferenceImpl readTaggedObjectReference() {
+ byte typeKey = readByte();
+ return vm.objectMirror(readObjectRef(), typeKey);
+ }
+
+ ObjectReferenceImpl readObjectReference() {
+ return vm.objectMirror(readObjectRef());
+ }
+
+ StringReferenceImpl readStringReference() {
+ long ref = readObjectRef();
+ return vm.stringMirror(ref);
+ }
+
+ ArrayReferenceImpl readArrayReference() {
+ long ref = readObjectRef();
+ return vm.arrayMirror(ref);
+ }
+
+ ThreadReferenceImpl readThreadReference() {
+ long ref = readObjectRef();
+ return vm.threadMirror(ref);
+ }
+
+ ThreadGroupReferenceImpl readThreadGroupReference() {
+ long ref = readObjectRef();
+ return vm.threadGroupMirror(ref);
+ }
+
+ ClassLoaderReferenceImpl readClassLoaderReference() {
+ long ref = readObjectRef();
+ return vm.classLoaderMirror(ref);
+ }
+
+ ClassObjectReferenceImpl readClassObjectReference() {
+ long ref = readObjectRef();
+ return vm.classObjectMirror(ref);
+ }
+
+ ReferenceTypeImpl readReferenceType() {
+ byte tag = readByte();
+ long ref = readObjectRef();
+ return vm.referenceType(ref, tag);
+ }
+
+ /**
+ * Read method reference represented as vm specific byte sequence.
+ */
+ long readMethodRef() {
+ return readID(vm.sizeofMethodRef);
+ }
+
+ /**
+ * Read field reference represented as vm specific byte sequence.
+ */
+ long readFieldRef() {
+ return readID(vm.sizeofFieldRef);
+ }
+
+ /**
+ * Read field represented as vm specific byte sequence.
+ */
+ Field readField() {
+ ReferenceTypeImpl refType = (ReferenceTypeImpl)readReferenceType();
+ long fieldRef = readFieldRef();
+ return refType.getFieldMirror(fieldRef);
+ }
+
+ /**
+ * Read frame represented as vm specific byte sequence.
+ */
+ long readFrameRef() {
+ return readID(vm.sizeofFrameRef);
+ }
+
+ /**
+ * Read a value, first byte describes type of value to read.
+ */
+ ValueImpl readValue() {
+ byte typeKey = readByte();
+ return readUntaggedValue(typeKey);
+ }
+
+ ValueImpl readUntaggedValue(byte typeKey) {
+ ValueImpl val = null;
+
+ if (isObjectTag(typeKey)) {
+ val = vm.objectMirror(readObjectRef(), typeKey);
+ } else {
+ switch(typeKey) {
+ case JDWP.Tag.BYTE:
+ val = new ByteValueImpl(vm, readByte());
+ break;
+
+ case JDWP.Tag.CHAR:
+ val = new CharValueImpl(vm, readChar());
+ break;
+
+ case JDWP.Tag.FLOAT:
+ val = new FloatValueImpl(vm, readFloat());
+ break;
+
+ case JDWP.Tag.DOUBLE:
+ val = new DoubleValueImpl(vm, readDouble());
+ break;
+
+ case JDWP.Tag.INT:
+ val = new IntegerValueImpl(vm, readInt());
+ break;
+
+ case JDWP.Tag.LONG:
+ val = new LongValueImpl(vm, readLong());
+ break;
+
+ case JDWP.Tag.SHORT:
+ val = new ShortValueImpl(vm, readShort());
+ break;
+
+ case JDWP.Tag.BOOLEAN:
+ val = new BooleanValueImpl(vm, readBoolean());
+ break;
+
+ case JDWP.Tag.VOID:
+ val = new VoidValueImpl(vm);
+ break;
+ }
+ }
+ return val;
+ }
+
+ /**
+ * Read location represented as vm specific byte sequence.
+ */
+ Location readLocation() {
+ byte tag = readByte();
+ long classRef = readObjectRef();
+ long methodRef = readMethodRef();
+ long codeIndex = readLong();
+ if (classRef != 0) {
+ /* Valid location */
+ ReferenceTypeImpl refType = vm.referenceType(classRef, tag);
+ return new LocationImpl(vm, refType, methodRef, codeIndex);
+ } else {
+ /* Null location (example: uncaught exception) */
+ return null;
+ }
+ }
+
+ byte[] readByteArray(int length) {
+ byte[] array = new byte[length];
+ System.arraycopy(pkt.data, inCursor, array, 0, length);
+ inCursor += length;
+ return array;
+ }
+
+ List<Value> readArrayRegion() {
+ byte typeKey = readByte();
+ int length = readInt();
+ List<Value> list = new ArrayList<Value>(length);
+ boolean gettingObjects = isObjectTag(typeKey);
+ for (int i = 0; i < length; i++) {
+ /*
+ * Each object comes back with a type key which might
+ * identify a more specific type than the type key we
+ * passed in, so we use it in the decodeValue call.
+ * (For primitives, we just use the original one)
+ */
+ if (gettingObjects) {
+ typeKey = readByte();
+ }
+ Value value = readUntaggedValue(typeKey);
+ list.add(value);
+ }
+
+ return list;
+ }
+
+ void writeArrayRegion(List<Value> srcValues) {
+ writeInt(srcValues.size());
+ for (int i = 0; i < srcValues.size(); i++) {
+ Value value = srcValues.get(i);
+ writeUntaggedValue(value);
+ }
+ }
+
+ int skipBytes(int n) {
+ inCursor += n;
+ return n;
+ }
+
+ byte command() {
+ return (byte)pkt.cmd;
+ }
+
+ static boolean isObjectTag(byte tag) {
+ return (tag == JDWP.Tag.OBJECT) ||
+ (tag == JDWP.Tag.ARRAY) ||
+ (tag == JDWP.Tag.STRING) ||
+ (tag == JDWP.Tag.THREAD) ||
+ (tag == JDWP.Tag.THREAD_GROUP) ||
+ (tag == JDWP.Tag.CLASS_LOADER) ||
+ (tag == JDWP.Tag.CLASS_OBJECT);
+ }
+}