deep-c-rsc/JCGO/goclsp/vm/gnu/classpath/jdwp/VMVirtualMachine.java

/*
 * @(#) $(JCGO)/goclsp/vm/gnu/classpath/jdwp/VMVirtualMachine.java --
 * VM specific implementation for JDWP virtual machine.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2008 Ivan Maidanski <ivmai@ivmaisoft.com>
 * All rights reserved.
 **
 * Class specification origin: GNU Classpath v0.93
 */

/*
 * This 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.
 **
 * This software 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 (GPL) for more details.
 **
 * 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
 * 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.EventRequest;

import gnu.classpath.jdwp.exception.InvalidMethodException;
import gnu.classpath.jdwp.exception.JdwpException;
import gnu.classpath.jdwp.exception.NotImplementedException;

import gnu.classpath.jdwp.util.MethodResult;

import gnu.java.lang.VMAccessorGnuJavaLang;

import java.io.File;

import java.lang.reflect.Method;

import java.nio.ByteBuffer;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public final class VMVirtualMachine
{

 private VMVirtualMachine() {}

 public static void suspendAllThreads()
  throws JdwpException
 {
  ThreadGroup jdwpGroup = Jdwp.getDefault().getJdwpThreadGroup();
  ThreadGroup tg = jdwpGroup;
  for (ThreadGroup tgn = tg; tgn != null; tgn = tg.getParent())
   tg = tgn;
  int num = tg.activeCount();
  Thread[] threads = new Thread[num];
  tg.enumerate(threads);
  Thread current = Thread.currentThread();
  Thread t;
  for (int i = 0; i < num; i++)
   if ((t = threads[i]) != null && t != current &&
       t.getThreadGroup() != jdwpGroup)
    suspendThread(t);
  if (current.getThreadGroup() != jdwpGroup)
   suspendThread(current);
 }

 public static void resumeAllThreads()
  throws JdwpException
 {
  Thread current = Thread.currentThread();
  ThreadGroup jdwpGroup = current.getThreadGroup();
  ThreadGroup tg = jdwpGroup;
  for (ThreadGroup tgn = tg; tgn != null; tgn = tg.getParent())
   tg = tgn;
  int num = tg.activeCount();
  Thread[] threads = new Thread[num];
  tg.enumerate(threads);
  Thread t;
  for (int i = 0; i < num; i++)
   if ((t = threads[i]) != null && t != current &&
       t.getThreadGroup() != jdwpGroup)
    resumeThread(t);
 }

 public static void suspendThread(Thread thread)
  throws JdwpException
 {
  VMAccessorJavaLang.suspendNestedVMThread(thread);
 }

 public static void resumeThread(Thread thread)
  throws JdwpException
 {
  VMAccessorJavaLang.resumeNestedVMThread(thread);
 }

 public static int getSuspendCount(Thread thread)
  throws JdwpException
 {
  return VMAccessorJavaLang.getSuspendCountVMThread(thread);
 }

 public static int getAllLoadedClassesCount()
  throws JdwpException
 {
  return VMAccessorGnuJavaLang.getAllLoadedClassCountVMInstrumentationImpl();
 }

 public static Iterator /* Collection */ getAllLoadedClasses()
  throws JdwpException
 {
  return Arrays.asList(
          VMAccessorGnuJavaLang.getAllLoadedClassesVMInstrumentationImpl()).
          iterator();
 }

 public static int getClassStatus(Class klass)
  throws JdwpException
 {
  String status = VMAccessorJavaLang.getClassStatusVMClass(klass);
  return "INITIALIZED".equals(status) ?
          JdwpConstants.ClassStatus.INITIALIZED :
          "PREPARED".equals(status) ? JdwpConstants.ClassStatus.PREPARED :
          "VERIFIED".equals(status) ? JdwpConstants.ClassStatus.VERIFIED :
          JdwpConstants.ClassStatus.ERROR;
 }

 public static VMMethod[] getAllClassMethods(Class klass)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("getAllClassMethods");
 }

 public static VMMethod getClassMethod(Class klass, long id)
  throws JdwpException
 {
  VMMethod[] methods = getAllClassMethods(klass);
  int len = methods.length;
  for (int i = 0; i < len; i++)
   if (methods[i].getId() == id)
    return methods[i];
  throw new InvalidMethodException(id);
 }

 public static ArrayList getFrames(Thread thread, int start, int len)
  throws JdwpException
 {
  VMFrame[] frames = getFrames(thread);
  if (len == -1)
   len = frames.length - start;
  if ((start | len) < 0 || frames.length - start < len)
   throw new ArrayIndexOutOfBoundsException();
  ArrayList list = new ArrayList(len);
  while (len-- > 0)
   list.add(frames[start++]);
  return list;
 }

 public static VMFrame getFrame(Thread thread, ByteBuffer bb)
  throws JdwpException
 {
  VMFrame[] frames = getFrames(thread);
  long id = bb.getLong();
  int len = frames.length;
  for (int i = 0; i < len; i++)
   if (frames[i].getId() == id)
    return frames[i];
  throw new JdwpException(JdwpConstants.Error.INVALID_FRAMEID,
         "invalid frame id (" + id + ")");
 }

 public static int getFrameCount(Thread thread)
  throws JdwpException
 {
  try
  {
   return VMAccessorJavaLang.countStackFramesVMThread(thread);
  }
  catch (IllegalThreadStateException e) {}
  return 0;
 }

 public static int getThreadStatus(Thread thread)
  throws JdwpException
 {
  String state = thread.getState();
  return "TIMED_WAITING".equals(state) ? JdwpConstants.ThreadStatus.SLEEPING :
          "WAITING".equals(state) ? JdwpConstants.ThreadStatus.WAIT :
          "BLOCKED".equals(state) ? JdwpConstants.ThreadStatus.MONITOR :
          "RUNNABLE".equals(state) ? JdwpConstants.ThreadStatus.RUNNING :
          JdwpConstants.ThreadStatus.ZOMBIE;
 }

 public static ArrayList getLoadRequests(ClassLoader cl)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("getLoadRequests");
 }

 public static MethodResult executeMethod(Object obj, Thread thread,
   Class klass, Method method, Object[] values, boolean nonVirtual)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("executeMethod");
 }

 public static String getSourceFile(Class klass)
  throws JdwpException
 {
  String filename = VMAccessorJavaLang.getSourceFilenameVMClass(klass);
  return filename != null ? filename.replace('/', File.separatorChar) :
          "no path information for the file is included";
 }

 public static void registerEvent(EventRequest request)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("registerEvent");
 }

 public static void unregisterEvent(EventRequest request)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("unregisterEvent");
 }

 public static void clearEvents(byte kind)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("clearEvents");
 }

 private static VMFrame[] getFrames(Thread thread)
  throws JdwpException
 {
  /* not implemented */
  throw new NotImplementedException("getFrames");
 }
}