src/share/classes/com/sun/tools/jdi/PacketStream.java - platform/external/oj-libjdwp - Git at Google

 /*
  * Copyright (c) 1998, 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.
  */

 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 = 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);
     }
 }
	/*
	* Copyright (c) 1998, 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.
	*/

	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 = 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);
	}
	}