harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ge...@apache.org
Subject svn commit: r480141 [12/38] - in /harmony/enhanced/jdktools/trunk/modules/jpda: ./ doc/ doc/images/ make/ src/ src/common/ src/common/other/ src/common/other/jpda/ src/common/other/jpda/jdwp/ src/common/other/jpda/jdwp/agent/ src/common/other/jpda/jdwp...
Date Tue, 28 Nov 2006 17:49:31 GMT
Added: harmony/enhanced/jdktools/trunk/modules/jpda/src/common/other/jpda/jdwp/agent/core/PacketParser.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/jdktools/trunk/modules/jpda/src/common/other/jpda/jdwp/agent/core/PacketParser.h?view=auto&rev=480141
==============================================================================
--- harmony/enhanced/jdktools/trunk/modules/jpda/src/common/other/jpda/jdwp/agent/core/PacketParser.h
(added)
+++ harmony/enhanced/jdktools/trunk/modules/jpda/src/common/other/jpda/jdwp/agent/core/PacketParser.h
Tue Nov 28 09:49:08 2006
@@ -0,0 +1,1161 @@
+/*
+ * Copyright 2005-2006 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.
+ */
+
+/**
+ * @author Anton V. Karnachuk
+ * @version $Revision: 1.16.2.1 $
+ */
+
+/**
+ * @file
+ * PacketParser.h
+ *
+ */
+
+#ifndef _PACKET_PARSER_H_
+#define _PACKET_PARSER_H_
+    
+#include "jdwp.h"
+#include "jdwpTransport.h"
+#include "AgentBase.h"
+#include "jdwpTypes.h"
+
+#include "jni.h"
+
+namespace jdwp {
+
+    /** 
+     * PacketWrapper is a wrapper for <code>jdwpPacket</code> providing methods
to
+     * read the <code>jdwpPacket</code> header values.
+     */
+    class PacketWrapper : public AgentBase {
+
+    public:
+
+        /**
+         * A default constructor.
+         */
+        PacketWrapper();
+
+        /**
+         * Returns <code>TRUE</code> if the packet was read from the transport.
+         */
+        bool IsPacketInitialized();
+
+        /**
+         * Returns the value of the length field of the JDWP packet.
+         */
+        jint GetLength() const {
+            return m_packet.type.cmd.len;
+        }
+
+        /**
+         * Returns the value of the ID field of the JDWP packet.
+         */
+        jint GetId() const {
+            return m_packet.type.cmd.id;
+        }
+
+        /**
+         * Returns the value of the flags field of the JDWP packet. 
+         */
+        jbyte GetFlags() const {
+            return m_packet.type.cmd.flags;
+        }
+
+        /**
+         * Returns the value of the command-set field of the JDWP packet. 
+         */
+        jdwpCommandSet GetCommandSet() const {
+            return static_cast<jdwpCommandSet>(m_packet.type.cmd.cmdSet);
+        }
+
+        /**
+         * Returns the value of the command field of the JDWP packet.
+         */
+        jdwpCommand GetCommand() const {
+            return static_cast<jdwpCommand>(m_packet.type.cmd.cmd);
+        }
+
+        /**
+         * Returns the value of the error field of the JDWP packet.
+         */
+        jint GetError() const {
+            return m_packet.type.reply.errorCode;
+        }
+
+    protected:
+
+        /**
+         * The internal class GCList stores a global references and
+         * allocated memory for an instance of the PacketWrapper 
+         * class. All allocated links are freeing on Reset().
+         */
+        class GCList : public AgentBase {
+
+        public:
+
+            /**
+             * A constructor.
+             */
+            GCList();
+
+            /**
+             * Stores the reference to allocated memory.
+             *
+             * @param ref - string
+             */
+            void StoreStringRef(char* ref) throw (OutOfMemoryException);
+
+            /**
+             * Stores the reference to the JNI global reference.
+             *
+             * @param globalRef - global reference
+             */
+            void StoreGlobalRef(jobject globalRef) throw (OutOfMemoryException);
+
+            /**
+             * Deletes all stored references.
+             *
+             * @param jni - the JNI interface pointer
+             */
+            void Reset(JNIEnv *jni);
+
+            /**
+             * Moves all data to other GCList instance.
+             *
+             * @param to - another GC list
+             */
+            void MoveData(GCList* to);
+
+        private:
+            // memory references
+            unsigned int m_memoryRefAllocatedSize;
+            char** m_memoryRef;
+            unsigned int m_memoryRefPosition;
+
+            // global references
+            unsigned int m_globalRefAllocatedSize;
+            jobject* m_globalRef;
+            unsigned int m_globalRefPosition;
+        };
+
+        jdwpPacket m_packet;
+        GCList m_garbageList;
+
+        /**
+         * Resets all data.
+         *
+         * @param jni - the JNI interface pointer
+         */
+        void Reset(JNIEnv *jni);
+
+        /**
+         * Moves all data to another PacketWrapper instance.
+         *
+         * @param jni - the JNI interface pointer
+         * @param to  - another packet wrapper
+         */
+        void MoveData(JNIEnv *jni, PacketWrapper* to);
+    };
+
+    /**
+     * The InputPacketParser  class supports reading data from 
+     * <code>jdwpPacket</code>. Inherited from PacketWrapper it 
+     * contains methods to read <code>jdwpPacket</code> header values and 
+     * extend methods for incremental reading from the packet's data. For the 
+     * JDWP types, such as <code>ObjectID</code>, <code>ReferenceTypeID</code>,
+	 * it returns a global reference to the object, and puts the created reference 
+     * into special collections. The Reset() method deletes all 
+     * the created a global references.
+     */
+    class InputPacketParser : public PacketWrapper {
+
+    public:
+
+        /**
+         * Creates an empty instance of <code>InputPacketComposer</code>.
+         */
+        InputPacketParser(): PacketWrapper(), m_position(0) {}
+
+        /** 
+         * Reads the packet from transport into the internal packet structure.
+         *
+         * @throws InternalErrorException if not enough bytes in 
+         *         the packet data exist.
+         */
+        void ReadPacketFromTransport() throw (TransportException);
+
+        /** 
+         * Sequentially reads the byte value from the JDWP packet's data. 
+         *
+         * @return Next byte value from the packet's data.
+         *
+         * @throws InternalErrorException if the number of bytes in the packet
+         *         data is not enough.
+         */
+        jbyte ReadByte() throw (InternalErrorException);
+
+        /**
+         * Sequentially reads boolean value from the JDWP packet's data. 
+         *
+         * @return The next boolean value from the packet's data.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         */
+        jboolean ReadBoolean() throw (InternalErrorException);
+
+        /** 
+         * Sequentially reads int value from the JDWP packet's data. 
+         *
+         * @return The next int value from the packet's data.
+         *
+         * @throws InternalErrorException if the number 
+         * of bytes in the packet data is not enough.
+         */
+        jint ReadInt() throw (InternalErrorException);
+
+        /** 
+         * Sequentially reads a long value from the JDWP packet's data.
+         *
+         * @return A long byte value from the packet's data.
+         *
+         * @throws InternalErrorException if the number 
+         * of bytes in the packet data is not enough.
+         */
+        jlong ReadLong() throw (InternalErrorException);
+        
+        /**
+         * Sequentially reads <code>ObjectID</code> value from the JDWP 
+         * packet's data.
+         * In contrast with the <code>ReadObjectID</code> method, 
+         * <code>ReadRawObjectID</code> does not map
+         * <code>ObjectID</code> to the jobject.
+         *
+         * @return The raw <code>ObjectID</code> value read form the packet.
+         *
+         * @throws InternalErrorException if the number of bytes
+         *         in the packet data is not enough.
+         */
+        ObjectID ReadRawObjectID() throw (InternalErrorException);
+
+        /** 
+         * Sequentially reads <code>ObjectID</code> value from JDWP 
+         * packet's data and converts it to <code>jobject</code> through 
+         * <code>ObjectManager</code>. Returns the JNI global reference to 
+         * <code>jobject</code> or null. 
+         * The given global reference is stored inside PacketWrapper 
+         * and can be destroyed with the method Reset().
+         * The given method should be used only in special cases where null 
+         * <code>ObjectID</code> is acceptible.
+         * In usual cases the method <code>ReadObjectID()</code> should be used.
+         *
+         * @param jni - the JNI interface pointer
+         * 
+         * @return The JNI global reference to <code>jobject</code> or null 
+         * reference for null <code>ObjectID</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ObjectID</code> is invalid or the object was 
+         *         garbage-collected.
+         */
+        jobject ReadObjectIDOrNull(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads <code>ObjectID</code> value from the JDWP 
+         * packet's data and converts it to the <code>jobject</code> 
+         * through <code>ObjectManager</code>. Returns the JNI global reference

+         * to the given <code>jobject</code>. The global reference is stored

+         * inside PacketWrapper and can be destroyed 
+         * with the method Reset().
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return The JNI global reference to <code>jobject</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a 
+         *         global reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ObjectID</code> is invalid or object was garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         *         <code>ObjectID</code> is null.
+         */
+        jobject ReadObjectID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>ReferenceTypeID</code> value from 
+         * the JDWP packet's data and converts it to the <code>jclass</code>

+         * through <code>ObjectManager</code>. Returns JNI global reference to
the 
+         * given <code>jclass</code> or null.
+         * The global reference is stored inside PacketWrapper and can 
+         * be destroyed with the method Reset().
+         * 
+         * The given method should be used only in special cases where null 
+         * <code>referenceTypeID</code> is acceptible.
+         * In usual cases the method <code>ReadReferenceTypeID()</code> should

+         * be used.
+         *
+         * @param jni - the JNI interface pointer
+         * 
+         * @return The JNI global reference to the <code>jobject</code>.
+         *
+         * @throws InternalErrorException if the number of bytes in 
+         *         the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws <code>AgentException(JDWP_ERROR_INVALID_CLASS)</code> if 
+         *         <code>ReferenceTypeID</code> is invalid.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         the corresponding class was garbage-collected.
+         */
+        jclass ReadReferenceTypeIDOrNull(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>ReferenceTypeID</code> value from the

+         * JDWP packet's data and converts it to the <code>jclass</code> through

+         * <code>ObjectManager</code>. Returns JNI global reference to that 
+         * <code>jclass</code>.
+         * The given global reference is stored inside PacketWrapper
+         * and can be destroyed with the method Reset().
+         * The given method should be used only in special cases where null 
+         * <code>referenceTypeID</code> is acceptible.
+         * In usual cases the method <code>ReadReferenceTypeID()</code> should

+         * be used.
+         *
+         * @param jni - the JNI interface pointer
+         * 
+         * @return The JNI global reference to the <code>jobject</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create global 
+         *         reference.
+         * @throws <code>AgentException(JDWP_ERROR_INVALID_CLASS)</code> 
+         *         if <code>ReferenceTypeID</code> is invalid.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) 
+         *         if the corresponding class was garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) 
+         *         if <code>ReferenceTypeID</code> is null.
+         */
+        jclass ReadReferenceTypeID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>FieldID</code> value from the JDWP 
+         * packet's data and converts it to the <code>jfieldID</code> 
+         * through <code>ObjectManager</code>.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return <code>jfieldID</code>
+         *
+         * @throws InternalErrorException if the number of 
+         *         bytes in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create 
+         *         a global reference.
+         */
+        jfieldID ReadFieldID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>MethodID</code> value from the JDWP 
+         * packet's data and converts it to the <code>jmethodID</code> 
+         * through <code>ObjectManager</code>.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return <code>jmethodID</code>
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create 
+         *         a global reference.
+         */
+        jmethodID ReadMethodID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>FrameID</code> value from the JDWP 
+         * packet's data and converts it to the <code>jint</code> through 
+         * <code>ObjectManager</code>.
+         *
+         * @param jni - the JNI interface pointer
+         * @return <code>jint</code>
+         *
+         * @throws InternalErrorException if the number of 
+         *         bytes in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a 
+         *         global reference.
+         */
+        jint ReadFrameID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>Location</code> object from the 
+         * JDWP packet's data and converts it to <code>jdwpLocation</code> 
+         * through <code>ObjectManager</code>.
+         *
+         * @param jni - the JNI interface pointer
+         * 
+         * @return <code>jdwpLocation</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a 
+         *         global reference.
+         */
+        jdwpLocation ReadLocation(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>ThreadID</code> value from the JDWP
+         * packet's data and convert it to <code>jthreadGroup</code> through

+         * <code>ObjectManager</code>. Returns JNI global reference to the 
+         * given object. 
+         * This global reference is stored inside PacketWrapper 
+         * and can be destroyed with the method Reset().
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return The JNI global reference to <code>jthread</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ThreadID</code> is invalid or object was garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         *         <code>ThreadID</code> is null.
+         */
+        jthread ReadThreadID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>ThreadGroupID</code> value from the 
+         * JDWP packet's data and converts it to <code>jthreadGroup</code> 
+         * through <code>ObjectManager</code>. Returns the JNI global reference

+         * to the given object. 
+         * This global reference is stored inside PacketWrapper 
+         * and can be destroyed with the method Reset().
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return The JNI global reference to <code>jthreadGroup</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ThreadGroupID</code> is invalid or the object was 
+         *         garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         *         <code>ThreadGroupID</code> is null.
+         */
+        jthreadGroup ReadThreadGroupID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>StringID</code> value from the JDWP 
+         * packet's data. 
+         * <code>StringID</code> is mapped through <code>ObjectManager</code>

+         * to <code>jstring</code>. 
+         * <code>ReadStringID()</code> returns the JNI global reference to that
+         * <code>jstring</code>.
+         * The given global reference is stored inside PacketWrapper
+         * and can be destroyed through the <code>Reset(JNIEnv *)</code> method.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return The JNI global reference to <code>jstring</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>StringID</code> is invalid or the object was 
+         *         garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) 
+         *         if <code>StringID</code> is null.
+         */
+        jstring ReadStringID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the <code>ArrayID</code> value from the JDWP 
+         * packet's data. 
+         * <code>ArrayID</code> is mapped through <code>ObjectManager</code>

+         * to <code>jstring</code>. 
+         * <code>ReadStringID()</code> returns the JNI global reference to 
+         * that <code>jstring</code>.
+         * The given global reference is stored inside PacketWrapper 
+         * and can be destroyed through the <code>Reset(JNIEnv *)</code> method.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @return The JNI global reference to <code>jarray</code>.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ArrayID</code> is invalid or the object was 
+         *         garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         * <code>ArrayID</code> is null.
+         */
+        jarray ReadArrayID(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the string value from the JDWP packet's data.
+         * One does not need to dispose this allocated memory, which is stored 
+         * inside PacketWrapper and can be destroyed through the 
+         * <code>Reset(JNIEnv *)</code> method.
+         *
+         * @return The string value.
+         *
+         * @throws InternalErrorException if the number of bytes 
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         */
+        char* ReadString() throw (InternalErrorException, OutOfMemoryException);
+
+        /** 
+         * Sequentially reads the string value from the JDWP packet's data.
+         * The given method allocates memory for the string value.
+         * You must destroy this memory with your own.
+         *
+         * @return The string value.
+         *
+         * @throws InternalErrorException if the number of bytes
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         */
+        char* ReadStringNoFree() throw (InternalErrorException, OutOfMemoryException);
+
+        /** 
+         * Sequentially reads the <code>JDWP.Tag</code> value and the following

+         * JDWP value. If the value is a reference type, it is converted to 
+         * <code>jobject</code> through <code>ObjectManager</code>
and a global 
+         * reference is stored in returning <code>jdwpTaggedValue</code>.
+         * All global references are stored inside PacketWrapper
+         * and can be destroyed with the method Reset().
+         *
+         * @param jni - the JNI interface pointer
+         * 
+         * @return <code>jdwpTaggedValue</code>.
+         *
+         * @throws InternalErrorException if the number of bytes in 
+         *         the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ObjectID</code> is invalid or the object was 
+         *         garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         *         <code>ObjectID</code> is null.
+         */
+        jdwpTaggedValue ReadValue(JNIEnv *jni) throw (AgentException);
+
+        /** 
+         * Sequentially reads the JDWP value for the selected <code>JDWP.Tag</code>

+         * value. If the value is a reference type, it is converted to 
+         * <code>jobject</code> through <code>ObjectManager</code>
and a global 
+         * reference is returned.
+         * All global references are stored inside PacketWrapper 
+         * and can be destroyed with the method Reset().
+         *
+         * @param jni - the JNI interface pointer
+         * @param tag - the <code>jdwpTag</code> tag
+         *
+         * @return <code>jvalue</code>.
+         *
+         * @throws InternalErrorException if the number of bytes
+         *         in the packet data is not enough.
+         * @throws OutOfMemoryException if cannot create a global 
+         *         reference.
+         * @throws AgentException(JDWP_ERROR_INVALID_OBJECT) if 
+         *         <code>ObjectID</code> is invalid or the object was 
+         *         garbage-collected.
+         * @throws AgentException(JDWP_ERROR_NULL_POINTER) if 
+         *         <code>ObjectID</code> is null.
+         */
+        jvalue ReadUntaggedValue(JNIEnv *jni, jdwpTag tag) throw (AgentException);
+
+        /** 
+         * Disposes all stored global references and allocated strings 
+         * and prepares InputPacketParser  for
+         * working with the next packets.
+         * 
+         * @param jni - the JNI interface pointer
+         */
+        void Reset(JNIEnv *jni);
+
+        /** 
+         * Moves all data to other InputPacketParser  instance. 
+         * 
+         * @param jni - the JNI interface pointer
+         * @param to  - another InputPacketParser 
+         */
+        void MoveData(JNIEnv *jni, InputPacketParser* to);
+
+    protected:
+        jchar ReadChar() throw (InternalErrorException);
+        jshort ReadShort() throw (InternalErrorException);
+        jfloat ReadFloat() throw (InternalErrorException);
+        jdouble ReadDouble() throw (InternalErrorException);
+
+    private:
+        int m_position;
+
+        void ReadBigEndianData(void* data, int len) throw (InternalErrorException); 
+        void ReadRawData(void* data, int len) throw (InternalErrorException);
+    };
+
+    /**
+     * OutputPacketComposer  class supports writing data to
+     * <code>jdwpPacket</code>. Inherited from PacketWrapper 
+     * it contain methods to read <code>jdwpPacket</code> header values 
+     * and extend methods for writing packet's headers and incremental 
+     * writing packet's data. 
+     */
+    class OutputPacketComposer : public PacketWrapper {
+
+    public:
+
+        /**
+         * Creates an empty instance of OutputPacketComposer .
+         */
+        OutputPacketComposer()
+            : PacketWrapper(), m_position(0), m_allocatedSize(0)
+            , m_registeredObjectIDTable(0), m_registeredObjectIDCount(0)
+            , m_registeredObjectIDTableSise(0) {}
+
+        /**
+         * Fills header fields with the values specific for the new JDWP reply.
+         *
+         * @param id        - the reply ID
+         * @param errorCode - the JDWP error code
+         */
+        void CreateJDWPReply(jint id, jdwpError errorCode) throw (InternalErrorException);
+
+        /**
+         * Fills header fields with the values specific for the new JDWP event.
+         *
+         * @param id         - event ID
+         * @param commandSet - the JDWP command set
+         * @param command    - the JDWP command
+         *
+         * @throws InternalErrorException
+         */
+        void CreateJDWPEvent(jint id, jdwpCommandSet commandSet, jdwpCommand command) throw
(InternalErrorException);
+        
+        /**
+         * Writes an enclosed packet to transport.
+         * 
+         * @throws TransportException.
+         */
+        void WritePacketToTransport() throw (TransportException);
+
+        /** 
+         * Sets an error code.
+         * Should be used for the JDWP reply only.
+         *
+         * @param error - the JDWP error code
+         */
+        void SetError(jdwpError error) {
+            m_packet.type.reply.errorCode = error;
+        }
+
+        /**
+         * Sequentially writes the byte value to the JDWP packet's data.
+         *
+         * @param value - the <code>jbyte</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteByte(jbyte value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the boolean value to the JDWP packet's data.
+         * 
+         * @param value - the <code>jboolean</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteBoolean(jboolean value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the int value to the JDWP packet's data.
+         *
+         * @param value - the <code>jint</code> value
+         * @throws OutOfMemoryException.
+         */
+        void WriteInt(jint value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the long value to the JDWP packet's data.
+         *
+         * @param value- the <code>jlong</code> value
+         * @throws OutOfMemoryException.
+         */
+        void WriteLong(jlong value) throw (OutOfMemoryException);
+        
+        /**
+         * Sequentially writes the <code>jobject</code> value to the 
+         * JDWP packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jobject</code> value
+         *
+         * @throws AgentException.
+         */
+        void WriteObjectID(JNIEnv *jni, jobject value) throw (AgentException);
+
+        /**
+         * Sequentially writes the <code>jclass</code> value to  
+         * the JDWP packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jclass</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteReferenceTypeID(JNIEnv *jni, jclass value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jfieldID</code> value to 
+         * the JDWP packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jfieldID</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteFieldID(JNIEnv *jni, jfieldID value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jmethodID</code> value to the JDWP
+         * packet's data.
+         * 
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jmethodID</code> value
+         * 
+         * @throws OutOfMemoryException.
+         */
+        void WriteMethodID(JNIEnv *jni, jmethodID value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jthread</code> value to the JDWP 
+         * packet's data.
+         *
+         * @param jni         - the JNI interface pointer
+         * @param jvmThread   - the Java thread
+         * @param frameDepth  - the frame depth
+         * @param framesCount - the number of frames
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteFrameID(JNIEnv *jni, jthread jvmThread, jint frameDepth, jint framesCount)
throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the location value to the JDWP packet's data.
+         *
+         * @param jni      - the JNI interface pointer
+         * @param typeTag  - the JDWP type tag
+         * @param classID  - the Java class
+         * @param methodID - the Java method ID
+         * @param location - the Java location
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteLocation(JNIEnv *jni, jdwpTypeTag typeTag, jclass classID, jmethodID methodID,
jlocation location) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the location value to the JDWP packet's data.
+         * 
+         * @param jni      - the JNI interface pointer
+         * @param location - the JDWP location
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteLocation(JNIEnv *jni, jdwpLocation *location) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jthread</code> value to the JDWP 
+         * packet's data.
+         * 
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jthread</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteThreadID(JNIEnv *jni, jthread value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jthreadGroup</code> value to the JDWP

+         * packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jthreadGroup</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteThreadGroupID(JNIEnv *jni, jthreadGroup value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jstring</code> value to the JDWP 
+         * packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jstring</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteStringID(JNIEnv *jni, jstring value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the <code>jarray</code> value to the JDWP 
+         * packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param value - the <code>jarray</code> value
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteArrayID(JNIEnv *jni, jarray value) throw (OutOfMemoryException);
+        
+        /**
+         * Sequentially writes the string to the JDWP packet's data.
+         *
+         * @param value - a null-terminated string
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteString(const char* value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the string to the JDWP packet's data.
+         *
+         * @param value  - the string
+         * @param length - the string length
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteString(const char* value, jint length) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the tagged-object ID.
+         *
+         * @param jni    - the JNI interface pointer
+         * @param object - the Java object
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteTaggedObjectID(JNIEnv *jni, jobject object) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the value object to the JDWP packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param tag   - the JDWP tag
+         * @param value - the Java value object
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteValue(JNIEnv *jni, jdwpTag tag, jvalue value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the array of value objects to the JDWP packet's 
+         * data.
+         *
+         * @param jni    - the JNI interface pointer
+         * @param tag    - the JDWP tag
+         * @param length - the count of the Java value objects
+         * @param value  - the array of the Java value objects
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteValues(JNIEnv *jni, jdwpTag tag, jint length, jvalue* value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the untagged value object to the JDWP 
+         * packet's data.
+         *
+         * @param jni   - the JNI interface pointer
+         * @param tag   - the JDWP tag
+         * @param value - the Java value object
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteUntaggedValue(JNIEnv *jni, jdwpTag tag, jvalue value) throw (OutOfMemoryException);
+
+        /**
+         * Sequentially writes the array length, then the byte array values 
+         * to the JDWP packet's data.
+         *
+         * @param byte   - the pointer to the byte array
+         * @param length - the byte array length
+         *
+         * @throws OutOfMemoryException.
+         */
+        void WriteByteArray(jbyte* byte, jint length) throw (OutOfMemoryException);
+
+        /** 
+         * Disposes all stored references and prepares 
+         * OutputPacketComposer  for working with the next packets.
+         * 
+         * @param jni - the JNI interface pointer
+         */
+        void Reset(JNIEnv *jni);
+
+        /** 
+         * Moves all data to another OutputPacketComposer  instance.
+         *
+         * @param jni - the JNI interface pointer
+         * @param to  - the pointer to the instance of 
+         *              OutputPacketComposer 
+         */
+        void MoveData(JNIEnv *jni, OutputPacketComposer* to);
+
+    protected:
+        void SetLength(jint length) { m_packet.type.cmd.len = length; }
+        void SetId(jint id) { m_packet.type.cmd.id = id; }
+        void SetFlags(jbyte flags) { m_packet.type.cmd.flags = flags; }
+        void SetCommandSet(jdwpCommandSet cmdSet) { m_packet.type.cmd.cmdSet = cmdSet; }
+        void SetCommand(jdwpCommand command) { m_packet.type.cmd.cmd = command; }
+
+        void WriteChar(jchar value) throw (OutOfMemoryException);
+        void WriteShort(jshort value) throw (OutOfMemoryException);
+        void WriteFloat(jfloat value) throw (OutOfMemoryException);
+        void WriteDouble(jdouble value) throw (OutOfMemoryException);
+
+    private:
+        size_t m_position;
+        size_t m_allocatedSize;
+        
+        ObjectID *m_registeredObjectIDTable;
+        int m_registeredObjectIDCount;
+        int m_registeredObjectIDTableSise; // in ObjectID
+
+        void AllocateMemoryForData(int length) throw (OutOfMemoryException);
+        void WriteData(const void* data, int length) throw (OutOfMemoryException);
+        void WriteRawData(const void* data, int length) throw (OutOfMemoryException);
+        void WriteBigEndianData(void* data, int length) throw (OutOfMemoryException);
+
+        /** 
+         * Registers given <code>objectID</code> in a special table containing

+         * all <code>ObjectID</code> values sent to the debugger by the JDWP
agent 
+         * in this reply packet. The given table is used to increase the count 
+         * of references for all registered <code>ObjectID</code> values. For
more 
+         * information see the <code>IncreaseObjectIDRefCounts()</code> function.
+         *
+         * @param objectID - the <code>objectID</code> to be registered
+         *
+         * @exception OutOfMemoryException the same as 
+         *            <code>AgentException (JDWP_ERROR_OUT_OF_MEMORY)</code>
- if an
+         *            out-of-memory error has occurred during execution of this 
+         *            function while allocating memory for the table.
+         * @exception InternalErrorException is the same as 
+         *            <code>AgentException(JDWP_ERROR_INTERNAL)</code> - if an

+         *            unexpected internal JDWP agent error has occurred.
+         */
+        void RegisterObjectID(ObjectID objectID) throw (AgentException);
+
+        /** 
+         * Increases by one the count of references for all <code>ObjectID</code>
values
+         * registered in the reply packet. This count for each <code>objectID</code>
+         * means how many times given <code>objectID</code> was sent to the debugger

+         * by the JDWP agent as a part of the reply data in the reply packet. The 
+         * count is used for correct disposing of given <code>objectID</code>.

+        */
+        void IncreaseObjectIDRefCounts();
+
+    };
+
+    /**
+     * The CommandParser class is a container for a pair of 
+     * InputPacketParser and OutputPacketComposer  
+     * packets that represents reply to the JDWP command.
+     */
+    class CommandParser : public AgentBase {
+
+    public:
+
+        /**
+         * The given method initializes command and reply structures.
+         * There should be no access for command and reply packet's data before
+         * invoking ReadPacket().
+         * 
+         * @exception TransportException.
+         */
+        void ReadCommand() throw (TransportException);
+
+        /**
+         * Writes the reply packet to the transport and resets the 
+         * CommandParser  object.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @exception TransportException
+         */
+        void WriteReply(JNIEnv *jni) throw (TransportException);
+
+        /**
+         * Moves all data to another CommandParser  instance.
+         *
+         * @param jni - the JNI interface pointer
+         * @param to  - the pointer to another CommandParser 
+         */
+        void MoveData(JNIEnv *jni, CommandParser* to);
+
+        /**
+         * Public field for working with InputPacketParser .
+         */
+        InputPacketParser command;
+
+        /**
+         * Public field for working with OutputPacketComposer .
+         */
+        OutputPacketComposer reply;
+
+    private:
+
+        /**
+         * Resets the given CommandParser  object.
+         */
+        void Reset(JNIEnv *jni);
+
+    };
+
+    /**
+     * The CommandParser  class is a container for the 
+     * OutputPacketComposer  packet representing the JDWP event.
+     */
+    class EventComposer : public AgentBase {
+
+    public:
+
+        /**
+         * A constructor.
+         *
+         * @param id         - the JDWP event ID
+         * @param commandSet - the JDWP command set
+         * @param command    - the JDWP command
+         * @param sp         - the suspend policy
+         */
+        EventComposer(jint id, jdwpCommandSet commandSet, jdwpCommand command,
+            jdwpSuspendPolicy sp);
+
+        /**
+         * Writes a thread ID to the output packet and creates a global reference
+         * to the thread.
+         *
+         * @param jni    - the JNI interface pointer
+         * @param thread - the Java thread
+         *
+         * @exception OutOfMemoryException.
+         */
+        void WriteThread(JNIEnv *jni, jthread thread)
+            throw (OutOfMemoryException);
+
+        /**
+         * Disposes all stored references and prepares CommandParser 
+         * for reading the next packets.
+         *
+         * @param jni - the JNI interface pointer
+         *
+         * @exception TransportException.
+         */
+        void WriteEvent(JNIEnv *jni) throw (TransportException);
+
+        /**
+         * Resets the current JDWP event.
+         *
+         * @param jni - the JNI interface pointer
+         */
+        void Reset(JNIEnv *jni);
+
+        /**
+         * Gets a thread suspend policy.
+         */
+        jdwpSuspendPolicy GetSuspendPolicy() { return m_suspendPolicy; }
+
+        /**
+         * Gets a Java thread.
+         */
+        jthread GetThread() { return m_thread; }
+
+        /**
+         * The packet was written to the transport.
+         */
+        bool IsSent() { return m_isSent; }
+
+        /**
+         * The thread is waiting on a suspension point.
+         */
+        bool IsWaiting() { return m_isWaiting; }
+
+        /**
+         * Notifies that the thread is waiting on a suspension point.
+         */
+        void SetWaiting(bool waiting) { m_isWaiting = waiting; }
+
+        /**
+         * The thread is released after a suspension.
+         */
+        bool IsReleased() { return m_isReleased; }
+
+        /**
+         * Releases the thread after a suspension.
+         */
+        void SetReleased(bool released) { m_isReleased = released; }
+
+        /**
+         * The auto-death event.
+         */
+        bool IsAutoDeathEvent() { return m_isAutoDeathEvent; }
+
+        /**
+         * Sets the auto-death event.
+         */
+        void SetAutoDeathEvent(bool yes) { m_isAutoDeathEvent = yes; }
+
+        /**
+         * A public field for working with <code>OutputPacketComposer<code/>.
+         */
+        OutputPacketComposer event;
+
+    private:
+
+        jthread m_thread;
+        jdwpSuspendPolicy m_suspendPolicy;
+        volatile bool m_isSent;
+        volatile bool m_isReleased;
+        volatile bool m_isWaiting;
+        volatile bool m_isAutoDeathEvent;
+
+    };
+
+}
+
+#endif // _PACKET_PARSER_H_

Propchange: harmony/enhanced/jdktools/trunk/modules/jpda/src/common/other/jpda/jdwp/agent/core/PacketParser.h
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message