Menu
▾
▴
[Jnode-svn-commits] SF.net SVN: jnode:[5826] trunk/core/src
|
From: <ls...@us...> - 2011-06-25 21:08:07
|
Revision: 5826
http://jnode.svn.sourceforge.net/jnode/?rev=5826&view=rev
Author: lsantha
Date: 2011-06-25 21:07:57 +0000 (Sat, 25 Jun 2011)
Log Message:
-----------
Improved remote debugging. Now standard Java debuggers can connect to JNode.
Modified Paths:
--------------
trunk/core/src/classpath/ext/gnu/classpath/jdwp/processor/VirtualMachineCommandSet.java
trunk/core/src/classpath/vm/gnu/classpath/jdwp/NativeVMVirtualMachine.java
trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/NativeTransportFactory.java
Added Paths:
-----------
trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/JNodeSocketTransport.java
trunk/core/src/emu/gnu/
trunk/core/src/emu/gnu/classpath/
trunk/core/src/emu/gnu/classpath/jdwp/
trunk/core/src/emu/gnu/classpath/jdwp/EmuVirtualMachine.java
trunk/core/src/emu/gnu/classpath/jdwp/Main.java
Removed Paths:
-------------
trunk/core/src/classpath/vm/gnu/classpath/jdwp/JNodeSocketTransport.java
Modified: trunk/core/src/classpath/ext/gnu/classpath/jdwp/processor/VirtualMachineCommandSet.java
===================================================================
--- trunk/core/src/classpath/ext/gnu/classpath/jdwp/processor/VirtualMachineCommandSet.java 2011-06-24 08:53:44 UTC (rev 5825)
+++ trunk/core/src/classpath/ext/gnu/classpath/jdwp/processor/VirtualMachineCommandSet.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -273,7 +273,7 @@
ThreadGroup root = getRootThreadGroup(jdwpGroup);
os.writeInt(1); // Just one top level group allowed?
- idMan.getObjectId(root);
+ idMan.getObjectId(root).write(os);
}
private void executeDispose(ByteBuffer bb, DataOutputStream os)
Deleted: trunk/core/src/classpath/vm/gnu/classpath/jdwp/JNodeSocketTransport.java
===================================================================
--- trunk/core/src/classpath/vm/gnu/classpath/jdwp/JNodeSocketTransport.java 2011-06-24 08:53:44 UTC (rev 5825)
+++ trunk/core/src/classpath/vm/gnu/classpath/jdwp/JNodeSocketTransport.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -1,166 +0,0 @@
-/*
- * $Id$
- *
- * Copyright (C) 2003-2010 JNode.org
- *
- * This library is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation; either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * This library 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 Lesser General Public
- * License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; If not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-package gnu.classpath.jdwp;
-
-import java.net.Socket;
-import java.net.ServerSocket;
-import java.util.HashMap;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import javax.net.ServerSocketFactory;
-import javax.net.SocketFactory;
-import gnu.classpath.jdwp.transport.ITransport;
-import gnu.classpath.jdwp.transport.TransportException;
-
-/**
- *
- */
-public class JNodeSocketTransport implements ITransport {
-
- /**
- * Name of this transport
- */
- public static final String NAME = "dt_socket";
-
- // Configure properties
- private static final String _PROPERTY_ADDRESS = "address";
- private static final String _PROPERTY_SERVER = "server";
-
- // Port number
- private int port;
-
- // Host name
- private String host;
-
- // Are we acting as a server?
- private boolean server = false;
-
- // Socket
- private Socket socket;
-
- /**
- * Setup the connection configuration from the given properties
- *
- * @param properties the properties of the JDWP session
- * @throws gnu.classpath.jdwp.transport.TransportException for any configury errors
- */
- public void configure (HashMap properties) throws TransportException {
- // Get address [form: "hostname:port"]
- String p = (String) properties.get(_PROPERTY_ADDRESS);
- if (p != null) {
- String[] s = p.split(":");
- if (s.length == 2) {
- host = s[0];
- port = Integer.parseInt(s[1]);
- // @classpath-bugfix Michael Klaus (Mic...@gm...)
- } else if (s.length == 1) {
- port = Integer.parseInt(s[0]);
- // @classpath-bugfix-end
- }
- }
-
- // Get server [form: "y" or "n"]
- p = (String) properties.get(_PROPERTY_SERVER);
- if (p != null) {
- if (p.toLowerCase().equals("y"))
- server = true;
- }
- }
-
- public static class ServerSocketHolder {
- private static ServerSocket ss;
- public static void close(){
- if(ss != null){
- try {
- ss.close();
- } catch (Exception e){
-
- } finally {
- ss = null;
- }
- }
- }
-
- static Socket getSocket(int port, int backlog) throws IOException{
- if(ss == null){
- ServerSocketFactory ssf = ServerSocketFactory.getDefault();
- ss = ssf.createServerSocket(port, backlog);
- }
- return ss.accept();
- }
- }
-
- /**
- * Initialize this socket connection. This includes
- * connecting to the host (or listening for it).
- *
- * @throws TransportException if a transport-related error occurs
- */
- public void initialize () throws TransportException {
- try {
- if (server) {
- // Get a server socket
- socket = ServerSocketHolder.getSocket(port, 1);
- } else {
- // Get a client socket (the factory will connect it)
- SocketFactory sf = SocketFactory.getDefault();
- socket = sf.createSocket(host, port);
- }
- }
- catch (IOException ioe) {
- // This will grab UnknownHostException, too.
- throw new TransportException(ioe);
- }
- }
-
- /**
- * Shutdown the socket. This could cause SocketExceptions
- * for anyone blocked on socket i/o
- */
- public void shutdown () {
- try {
- socket.close();
- } catch (Throwable t) {
- // We don't really care about errors at this point
- }
- }
-
- /**
- * Returns an <code>InputStream</code> for the transport
- *
- * @throws IOException if an I/O error occurs creating the stream
- * or the socket is not connected
- */
- public InputStream getInputStream () throws IOException {
- return socket.getInputStream();
- }
-
- /**
- * Returns an <code>OutputStream</code> for the transport
- *
- * @throws IOException if an I/O error occurs creating the stream
- * or the socket is not connected
- */
- public OutputStream getOutputStream () throws IOException {
- return socket.getOutputStream();
- }
-}
Modified: trunk/core/src/classpath/vm/gnu/classpath/jdwp/NativeVMVirtualMachine.java
===================================================================
--- trunk/core/src/classpath/vm/gnu/classpath/jdwp/NativeVMVirtualMachine.java 2011-06-24 08:53:44 UTC (rev 5825)
+++ trunk/core/src/classpath/vm/gnu/classpath/jdwp/NativeVMVirtualMachine.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -27,6 +27,7 @@
import gnu.classpath.jdwp.util.MethodResult;
import gnu.classpath.jdwp.event.EventRequest;
+import org.jnode.annotation.NoInline;
import org.jnode.vm.facade.VmUtils;
import org.jnode.vm.isolate.VmIsolate;
import org.jnode.vm.classmgr.VmIsolatedStatics;
@@ -41,23 +42,34 @@
* @author Levente S\u00e1ntha
*/
class NativeVMVirtualMachine {
+ @NoInline
+// public static boolean debug() {
+// return true;
+// }
+
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#suspendThread(java.lang.Thread)
*/
private static void suspendThread(Thread arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.suspendThread()");
}
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#resumeThread(java.lang.Thread)
*/
private static void resumeThread(Thread arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.resumeThread()");
}
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#getSuspendCount(java.lang.Thread)
*/
private static int getSuspendCount(Thread arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getSuspendCount()");
return 0;
}
/**
@@ -65,12 +77,16 @@
*/
private static int getAllLoadedClassesCount() {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getAllLoadedClassesCount()");
return 0;
}
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#getAllLoadedClasses()
*/
private static Iterator getAllLoadedClasses() {
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getAllLoadedClasses()");
return new Iterator() {
private VmStaticsIterator iter = new VmStaticsIterator(VmUtils.getVm().getSharedStatics());
private Iterator<VmIsolatedStatics> isolated = VmIsolate.staticsIterator();
@@ -102,6 +118,8 @@
*/
private static int getClassStatus(Class arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getClassStatus()");
return 0;
}
/**
@@ -109,6 +127,8 @@
*/
private static VMMethod[] getAllClassMethods(Class arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getAllClassMethods()");
return null;
}
/**
@@ -116,6 +136,8 @@
*/
private static VMMethod getClassMethod(Class arg1, long arg2) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getClassMethod()");
return null;
}
/**
@@ -123,6 +145,8 @@
*/
private static ArrayList getFrames(Thread arg1, int arg2, int arg3) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getFrame()");
return null;
}
/**
@@ -130,6 +154,8 @@
*/
private static VMFrame getFrame(Thread arg1, ByteBuffer arg2) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getFrame()");
return null;
}
/**
@@ -137,6 +163,8 @@
*/
private static int getFrameCount(Thread arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getFrameCount()");
return 0;
}
/**
@@ -144,6 +172,8 @@
*/
private static int getThreadStatus(Thread arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getThreadStatus()");
return 0;
}
/**
@@ -151,6 +181,8 @@
*/
private static ArrayList getLoadRequests(ClassLoader arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getLoadRequest()");
return null;
}
/**
@@ -158,6 +190,8 @@
*/
private static MethodResult executeMethod(Object arg1, Thread arg2, Class arg3, Method arg4, Object[] arg5, boolean arg6) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.executeMethod()");
return null;
}
/**
@@ -165,6 +199,8 @@
*/
private static String getSourceFile(Class arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.getSourceFile()");
return null;
}
/**
@@ -172,21 +208,30 @@
*/
private static void registerEvent(EventRequest arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.registerEvent() " + arg1.getId() + " " + arg1.getEventKind() +
+ " " + arg1.getSuspendPolicy() + " " + arg1.getFilters());
}
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#unregisterEvent(gnu.classpath.jdwp.event.EventRequest)
*/
private static void unregisterEvent(EventRequest arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.unregisterEvent()");
}
/**
* @see gnu.classpath.jdwp.VMVirtualMachine#clearEvents(byte)
*/
private static void clearEvents(byte arg1) {
//todo implement it
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.clearEvents()");
}
public static void redefineClass(Class oldClass, byte[] classData){
+// if(debug())
+ System.out.println("NativeVMVirtualMachine.redefineClass()");
VmType old_type = VmType.fromClass(oldClass);
VmType new_type = ClassDecoder.defineClass(oldClass.getName(),
ByteBuffer.wrap(classData), false,
Copied: trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/JNodeSocketTransport.java (from rev 5819, trunk/core/src/classpath/vm/gnu/classpath/jdwp/JNodeSocketTransport.java)
===================================================================
--- trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/JNodeSocketTransport.java (rev 0)
+++ trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/JNodeSocketTransport.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -0,0 +1,166 @@
+/*
+ * $Id$
+ *
+ * Copyright (C) 2003-2010 JNode.org
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * This library 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 Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; If not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+package gnu.classpath.jdwp.transport;
+
+import java.net.Socket;
+import java.net.ServerSocket;
+import java.util.HashMap;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import javax.net.ServerSocketFactory;
+import javax.net.SocketFactory;
+import gnu.classpath.jdwp.transport.ITransport;
+import gnu.classpath.jdwp.transport.TransportException;
+
+/**
+ *
+ */
+public class JNodeSocketTransport implements ITransport {
+
+ /**
+ * Name of this transport
+ */
+ public static final String NAME = "dt_socket";
+
+ // Configure properties
+ private static final String _PROPERTY_ADDRESS = "address";
+ private static final String _PROPERTY_SERVER = "server";
+
+ // Port number
+ private int port;
+
+ // Host name
+ private String host;
+
+ // Are we acting as a server?
+ private boolean server = false;
+
+ // Socket
+ private Socket socket;
+
+ /**
+ * Setup the connection configuration from the given properties
+ *
+ * @param properties the properties of the JDWP session
+ * @throws gnu.classpath.jdwp.transport.TransportException for any configury errors
+ */
+ public void configure (HashMap properties) throws TransportException {
+ // Get address [form: "hostname:port"]
+ String p = (String) properties.get(_PROPERTY_ADDRESS);
+ if (p != null) {
+ String[] s = p.split(":");
+ if (s.length == 2) {
+ host = s[0];
+ port = Integer.parseInt(s[1]);
+ // @classpath-bugfix Michael Klaus (Mic...@gm...)
+ } else if (s.length == 1) {
+ port = Integer.parseInt(s[0]);
+ // @classpath-bugfix-end
+ }
+ }
+
+ // Get server [form: "y" or "n"]
+ p = (String) properties.get(_PROPERTY_SERVER);
+ if (p != null) {
+ if (p.toLowerCase().equals("y"))
+ server = true;
+ }
+ }
+
+ public static class ServerSocketHolder {
+ private static ServerSocket ss;
+ public static void close(){
+ if(ss != null){
+ try {
+ ss.close();
+ } catch (Exception e){
+
+ } finally {
+ ss = null;
+ }
+ }
+ }
+
+ static Socket getSocket(int port, int backlog) throws IOException{
+ if(ss == null){
+ ServerSocketFactory ssf = ServerSocketFactory.getDefault();
+ ss = ssf.createServerSocket(port, backlog);
+ }
+ return ss.accept();
+ }
+ }
+
+ /**
+ * Initialize this socket connection. This includes
+ * connecting to the host (or listening for it).
+ *
+ * @throws TransportException if a transport-related error occurs
+ */
+ public void initialize () throws TransportException {
+ try {
+ if (server) {
+ // Get a server socket
+ socket = ServerSocketHolder.getSocket(port, 1);
+ } else {
+ // Get a client socket (the factory will connect it)
+ SocketFactory sf = SocketFactory.getDefault();
+ socket = sf.createSocket(host, port);
+ }
+ }
+ catch (IOException ioe) {
+ // This will grab UnknownHostException, too.
+ throw new TransportException(ioe);
+ }
+ }
+
+ /**
+ * Shutdown the socket. This could cause SocketExceptions
+ * for anyone blocked on socket i/o
+ */
+ public void shutdown () {
+ try {
+ socket.close();
+ } catch (Throwable t) {
+ // We don't really care about errors at this point
+ }
+ }
+
+ /**
+ * Returns an <code>InputStream</code> for the transport
+ *
+ * @throws IOException if an I/O error occurs creating the stream
+ * or the socket is not connected
+ */
+ public InputStream getInputStream () throws IOException {
+ return socket.getInputStream();
+ }
+
+ /**
+ * Returns an <code>OutputStream</code> for the transport
+ *
+ * @throws IOException if an I/O error occurs creating the stream
+ * or the socket is not connected
+ */
+ public OutputStream getOutputStream () throws IOException {
+ return socket.getOutputStream();
+ }
+}
Modified: trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/NativeTransportFactory.java
===================================================================
--- trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/NativeTransportFactory.java 2011-06-24 08:53:44 UTC (rev 5825)
+++ trunk/core/src/classpath/vm/gnu/classpath/jdwp/transport/NativeTransportFactory.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -20,8 +20,6 @@
package gnu.classpath.jdwp.transport;
-import gnu.classpath.jdwp.JNodeSocketTransport;
-
/**
*
*/
Copied: trunk/core/src/emu/gnu/classpath/jdwp/EmuVirtualMachine.java (from rev 5819, trunk/core/src/classpath/ext/gnu/classpath/jdwp/VMVirtualMachine.java)
===================================================================
--- trunk/core/src/emu/gnu/classpath/jdwp/EmuVirtualMachine.java (rev 0)
+++ trunk/core/src/emu/gnu/classpath/jdwp/EmuVirtualMachine.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -0,0 +1,404 @@
+/* VMVirtualMachine.java -- A reference implementation of a JDWP virtual
+ machine
+
+ Copyright (C) 2005, 2006 Free Software Foundation
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package gnu.classpath.jdwp;
+
+import gnu.classpath.jdwp.event.ClassPrepareEvent;
+import gnu.classpath.jdwp.event.EventRequest;
+import gnu.classpath.jdwp.event.VmInitEvent;
+import gnu.classpath.jdwp.exception.JdwpException;
+import gnu.classpath.jdwp.util.MethodResult;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * A virtual machine according to JDWP.
+ *
+ * @author Keith Seitz <ke...@re...>
+ */
+public class EmuVirtualMachine
+{
+ /**
+ * Suspend a thread
+ *
+ * @param thread the thread to suspend
+ */
+ public static void suspendThread (Thread thread)
+ throws JdwpException{
+ System.out.println("suspendThread");
+ }
+
+ /**
+ * Suspend all threads
+ */
+ public static void suspendAllThreads ()
+ throws JdwpException
+ {
+ // Our JDWP thread group -- don't suspend any of those threads
+ Thread current = Thread.currentThread ();
+ ThreadGroup jdwpGroup = current.getThreadGroup ();
+
+ // Find the root ThreadGroup
+ ThreadGroup group = jdwpGroup;
+ ThreadGroup parent = group.getParent ();
+ while (parent != null)
+ {
+ group = parent;
+ parent = group.getParent ();
+ }
+
+ // Get all the threads in the system
+ int num = group.activeCount ();
+ Thread[] threads = new Thread[num];
+ group.enumerate (threads);
+
+ for (int i = 0; i < num; ++i)
+ {
+ Thread t = threads[i];
+ if (t != null)
+ {
+ if (t.getThreadGroup () == jdwpGroup || t == current)
+ {
+ // Don't suspend the current thread or any JDWP thread
+ continue;
+ }
+ else
+ suspendThread (t);
+ }
+ }
+
+ // Now suspend the current thread
+ suspendThread (current);
+ }
+
+ /**
+ * Resume a thread. A thread must be resumed as many times
+ * as it has been suspended.
+ *
+ * @param thread the thread to resume
+ */
+ public static void resumeThread (Thread thread)
+ throws JdwpException {
+ System.out.println("resumeThread");
+ }
+
+ /**
+ * Resume all threads. This simply decrements the thread's
+ * suspend count. It can not be used to force the application
+ * to run.
+ */
+ public static void resumeAllThreads ()
+ throws JdwpException
+ {
+ // Our JDWP thread group -- don't resume
+ Thread current = Thread.currentThread ();
+ ThreadGroup jdwpGroup = current.getThreadGroup ();
+
+ // Find the root ThreadGroup
+ ThreadGroup group = jdwpGroup;
+ ThreadGroup parent = group.getParent ();
+ while (parent != null)
+ {
+ group = parent;
+ parent = group.getParent ();
+ }
+
+ // Get all the threads in the system
+ int num = group.activeCount ();
+ Thread[] threads = new Thread[num];
+ group.enumerate (threads);
+
+ for (int i = 0; i < num; ++i)
+ {
+ Thread t = threads[i];
+ if (t != null)
+ {
+ if (t.getThreadGroup () == jdwpGroup || t == current)
+ {
+ // Don't resume the current thread or any JDWP thread
+ continue;
+ }
+ else
+ resumeThread (t);
+ }
+ }
+ }
+
+ /**
+ * Get the suspend count for a give thread
+ *
+ * @param thread the thread whose suspend count is desired
+ * @return the number of times the thread has been suspended
+ */
+ public static int getSuspendCount (Thread thread)
+ throws JdwpException {
+ System.out.println("getSuspendCount");
+ return 0;
+ }
+
+ /**
+ * Returns a count of the number of loaded classes in the VM
+ */
+ public static int getAllLoadedClassesCount ()
+ throws JdwpException {
+ System.out.println("getAllLoadedClassesCount");
+ return 0;
+ }
+
+ /**
+ * Returns an iterator over all the loaded classes in the VM
+ */
+ public static Iterator getAllLoadedClasses ()
+ throws JdwpException {
+ System.out.println("getAllLoadedClasses");
+ ArrayList a = new ArrayList();
+ a.add(String.class);
+ a.add(Object.class);
+ a.add(Integer.class);
+ a.add(EmuVirtualMachine.class);
+ return a.iterator();
+ }
+
+ /**
+ * Returns the status of the given class
+ *
+ * @param clazz the class whose status is desired
+ * @return a flag containing the class's status
+ * @see gnu.classpath.jdwp.JdwpConstants.ClassStatus
+ */
+ public static int getClassStatus (Class clazz)
+ throws JdwpException {
+ System.out.println("getClassStatus");
+ return 0;
+ }
+
+ /**
+ * Returns all of the methods defined in the given class. This
+ * includes all methods, constructors, and class initializers.
+ *
+ * @param klass the class whose methods are desired
+ * @return an array of virtual machine methods
+ */
+ public static VMMethod[] getAllClassMethods (Class klass)
+ throws JdwpException {
+ System.out.println("getAllClassMethods");
+ return new VMMethod[0];
+ }
+
+ /**
+ * A factory method for getting valid virtual machine methods
+ * which may be passed to/from the debugger.
+ *
+ * @param klass the class in which the method is defined
+ * @param id the ID of the desired method
+ * @return the desired internal representation of the method
+ * @throws gnu.classpath.jdwp.exception.InvalidMethodException if the method is not defined
+ * in the class
+ * @throws gnu.classpath.jdwp.exception.JdwpException for any other error
+ */
+ public static VMMethod getClassMethod(Class klass, long id)
+ throws JdwpException {
+ System.out.println("getClassMethod");
+ return null;
+ }
+
+ /**
+ * Returns the thread's call stack
+ *
+ * @param thread thread for which to get call stack
+ * @param start index of first frame to return
+ * @param length number of frames to return (-1 for all frames)
+ * @return a list of frames
+ */
+ public static ArrayList getFrames (Thread thread, int start,
+ int length)
+ throws JdwpException {
+ System.out.println("getFrames");
+ return new ArrayList();
+ }
+
+ /**
+ * Returns the frame for a given thread with the frame ID in
+ * the buffer
+ *
+ * I don't like this.
+ *
+ * @param thread the frame's thread
+ * @param bb buffer containing the frame's ID
+ * @return the desired frame
+ */
+ public static VMFrame getFrame (Thread thread, ByteBuffer bb)
+ throws JdwpException {
+ System.out.println("getFrame");
+ return null;
+ }
+
+ /**
+ * Returns the number of frames in the thread's stack
+ *
+ * @param thread the thread for which to get a frame count
+ * @return the number of frames in the thread's stack
+ */
+ public static int getFrameCount (Thread thread)
+ throws JdwpException {
+ System.out.println("getFrameCount");
+ return 0;
+ }
+
+
+ /**
+ * Returns the status of a thread
+ *
+ * @param thread the thread for which to get status
+ * @return integer status of the thread
+ * @see gnu.classpath.jdwp.JdwpConstants.ThreadStatus
+ */
+ public static int getThreadStatus (Thread thread)
+ throws JdwpException {
+ System.out.println("getThreadStatus");
+ return 0;
+ }
+
+ /**
+ * Returns a list of all classes which this class loader has been
+ * requested to load
+ *
+ * @param cl the class loader
+ * @return a list of all visible classes
+ */
+ public static ArrayList getLoadRequests (ClassLoader cl)
+ throws JdwpException {
+ System.out.println("getLoadRequests");
+ return new ArrayList();
+ }
+
+ /**
+ * Executes a method in the virtual machine
+ *
+ * @param obj instance in which to invoke method (null for static)
+ * @param thread the thread in which to invoke the method
+ * @param clazz the class in which the method is defined
+ * @param method the method to invoke
+ * @param values arguments to pass to method
+ * @param nonVirtual "otherwise, normal virtual invoke
+ * (instance methods only) "
+ * @return a result object containing the results of the invocation
+ */
+ public static MethodResult executeMethod (Object obj, Thread thread,
+ Class clazz, Method method,
+ Object[] values,
+ boolean nonVirtual)
+ throws JdwpException {
+ System.out.println("executeMethod");
+ return null;
+ }
+
+ /**
+ * "Returns the name of source file in which a reference type was declared"
+ *
+ * @param clazz the class for which to return a source file
+ * @return a string containing the source file name; "no path information
+ * for the file is included"
+ */
+ public static String getSourceFile (Class clazz)
+ throws JdwpException {
+ System.out.println("getSourceFile");
+ return null;
+ }
+
+ /**
+ * Register a request from the debugger
+ *
+ * Virtual machines have two options. Either do nothing and allow
+ * the event manager to take care of the request (useful for broadcast-type
+ * events like class prepare/load/unload, thread start/end, etc.)
+ * or do some internal work to set up the event notification (useful for
+ * execution-related events like breakpoints, single-stepping, etc.).
+ */
+ public static void registerEvent (EventRequest request)
+ throws JdwpException {
+ System.out.println("registerEvent " + request.getId() + " " + request.getEventKind() + " " +
+ request.getSuspendPolicy() + " " + request.getFilters());
+
+ if(request.getEventKind() == JdwpConstants.EventKind.VM_INIT) {
+ new Thread(){
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(1000);
+ Jdwp.notify(new VmInitEvent(Thread.currentThread()));
+ Jdwp.notify(new ClassPrepareEvent(Thread.currentThread(), Class.class, 0));
+ } catch (InterruptedException ie) {
+ ie.printStackTrace();
+ }
+ }
+ }.start();
+ }
+ }
+
+ /**
+ * Unregisters the given request
+ *
+ * @param request the request to unregister
+ */
+ public static void unregisterEvent (EventRequest request)
+ throws JdwpException {
+ System.out.println("unregisterEvent");
+
+ }
+
+
+ /**
+ * Clear all events of the given kind
+ *
+ * @param kind the type of events to clear
+ */
+ public static void clearEvents (byte kind)
+ throws JdwpException {
+ System.out.println("clearEvents");
+ }
+
+ public static void redefineClass(Class old_class, byte[] classData) {
+ System.out.println("redefineClass");
+ }
+}
Added: trunk/core/src/emu/gnu/classpath/jdwp/Main.java
===================================================================
--- trunk/core/src/emu/gnu/classpath/jdwp/Main.java (rev 0)
+++ trunk/core/src/emu/gnu/classpath/jdwp/Main.java 2011-06-25 21:07:57 UTC (rev 5826)
@@ -0,0 +1,59 @@
+package gnu.classpath.jdwp;
+
+import gnu.classpath.jdwp.transport.JNodeSocketTransport;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.Reader;
+
+/**
+ * User: lsantha
+ * Date: 6/25/11 5:13 PM
+ */
+public class Main {
+ private static final String str_quit = "Type 'q' to exit";
+
+ private static final int DEFAULT_PORT = 6789;
+
+ private boolean up = true;
+
+ public static void main(String[] args) throws Exception {
+ new Main().execute();
+ }
+
+ public void execute() throws Exception {
+ // FIXME - in the even of internal exceptions, JDWP writes to System.out.
+ final String ps = "transport=dt_socket,suspend=n,address=" + DEFAULT_PORT + ",server=y";
+ Thread t = new Thread(new Runnable() {
+ public void run() {
+ while (up()) {
+ Jdwp jdwp = new Jdwp();
+ jdwp.configure(ps);
+ jdwp.run();
+ jdwp.waitToFinish();
+ jdwp.shutdown();
+ }
+ // workaround for the restricted capabilities of JDWP support in GNU Classpath.
+ JNodeSocketTransport.ServerSocketHolder.close();
+ }
+ });
+ t.start();
+
+ Reader in = new InputStreamReader(System.in);
+ PrintWriter out = new PrintWriter(System.out);
+ while (in.read() != 'q') {
+ out.println(str_quit);
+ }
+ // FIXME - this just stops the 'debug' command. The listener will keep running
+ // until the remote debugger disconnects. We should have a way to disconnect at
+ // this end.
+ down();
+ }
+
+ public synchronized boolean up() {
+ return up;
+ }
+
+ public synchronized void down() {
+ up = false;
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
