/*
* Copyright (c) 1998, 2011, 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.
*/
/*
* This source code is provided to illustrate the usage of a given feature
* or technique and has been deliberately simplified. Additional steps
* required for a production-quality application, such as security checks,
* input validation and proper error handling, might not be present in
* this sample code.
*/
package com.sun.tools.example.debug.tty;
import com.sun.jdi.ThreadReference;
import com.sun.jdi.ThreadGroupReference;
import com.sun.jdi.IncompatibleThreadStateException;
import com.sun.jdi.StackFrame;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
class ThreadInfo {
// This is a list of all known ThreadInfo objects. It survives
// ThreadInfo.invalidateAll, unlike the other static fields below.
private static List<ThreadInfo> threads = Collections.synchronizedList(new ArrayList<ThreadInfo>());
private static boolean gotInitialThreads = false;
private static ThreadInfo current = null;
private static ThreadGroupReference group = null;
private final ThreadReference thread;
private int currentFrameIndex = 0;
private ThreadInfo(ThreadReference thread) {
this.thread = thread;
if (thread == null) {
MessageOutput.fatalError("Internal error: null ThreadInfo created");
}
}
private static void initThreads() {
if (!gotInitialThreads) {
for (ThreadReference thread : Env.vm().allThreads()) {
threads.add(new ThreadInfo(thread));
}
gotInitialThreads = true;
}
}
static void addThread(ThreadReference thread) {
synchronized (threads) {
initThreads();
ThreadInfo ti = new ThreadInfo(thread);
// Guard against duplicates. Duplicates can happen during
// initialization when a particular thread might be added both
// by a thread start event and by the initial call to threads()
if (getThreadInfo(thread) == null) {
threads.add(ti);
}
}
}
static void removeThread(ThreadReference thread) {
if (thread.equals(ThreadInfo.current)) {
// Current thread has died.
// Be careful getting the thread name. If its death happens
// as part of VM termination, it may be too late to get the
// information, and an exception will be thrown.
String currentThreadName;
try {
currentThreadName = "\"" + thread.name() + "\"";
} catch (Exception e) {
currentThreadName = "";
}
setCurrentThread(null);
MessageOutput.println();
MessageOutput.println("Current thread died. Execution continuing...",
currentThreadName);
}
threads.remove(getThreadInfo(thread));
}
static List<ThreadInfo> threads() {
synchronized(threads) {
initThreads();
// Make a copy to allow iteration without synchronization
return new ArrayList<ThreadInfo>(threads);
}
}
static void invalidateAll() {
current = null;
group = null;
synchronized (threads) {
for (ThreadInfo ti : threads()) {
ti.invalidate();
}
}
}
static void setThreadGroup(ThreadGroupReference tg) {
group = tg;
}
static void setCurrentThread(ThreadReference tr) {
if (tr == null) {
setCurrentThreadInfo(null);
} else {
ThreadInfo tinfo = getThreadInfo(tr);
setCurrentThreadInfo(tinfo);
}
}
static void setCurrentThreadInfo(ThreadInfo tinfo) {
current = tinfo;
if (current != null) {
current.invalidate();
}
}
/**
* Get the current ThreadInfo object.
*
* @return the ThreadInfo for the current thread.
*/
static ThreadInfo getCurrentThreadInfo() {
return current;
}
/**
* Get the thread from this ThreadInfo object.
*
* @return the Thread wrapped by this ThreadInfo.
*/
ThreadReference getThread() {
return thread;
}
static ThreadGroupReference group() {
if (group == null) {
// Current thread group defaults to the first top level
// thread group.
setThreadGroup(Env.vm().topLevelThreadGroups().get(0));
}
return group;
}
static ThreadInfo getThreadInfo(long id) {
ThreadInfo retInfo = null;
synchronized (threads) {
for (ThreadInfo ti : threads()) {
if (ti.thread.uniqueID() == id) {
retInfo = ti;
break;
}
}
}
return retInfo;
}
static ThreadInfo getThreadInfo(ThreadReference tr) {
return getThreadInfo(tr.uniqueID());
}
static ThreadInfo getThreadInfo(String idToken) {
ThreadInfo tinfo = null;
if (idToken.startsWith("t@")) {
idToken = idToken.substring(2);
}
try {
long threadId = Long.decode(idToken).longValue();
tinfo = getThreadInfo(threadId);
} catch (NumberFormatException e) {
tinfo = null;
}
return tinfo;
}
/**
* Get the thread stack frames.
*
* @return a <code>List</code> of the stack frames.
*/
List<StackFrame> getStack() throws IncompatibleThreadStateException {
return thread.frames();
}
/**
* Get the current stackframe.
*
* @return the current stackframe.
*/
StackFrame getCurrentFrame() throws IncompatibleThreadStateException {
if (thread.frameCount() == 0) {
return null;
}
return thread.frame(currentFrameIndex);
}
/**
* Invalidate the current stackframe index.
*/
void invalidate() {
currentFrameIndex = 0;
}
/* Throw IncompatibleThreadStateException if not suspended */
private void assureSuspended() throws IncompatibleThreadStateException {
if (!thread.isSuspended()) {
throw new IncompatibleThreadStateException();
}
}
/**
* Get the current stackframe index.
*
* @return the number of the current stackframe. Frame zero is the
* closest to the current program counter
*/
int getCurrentFrameIndex() {
return currentFrameIndex;
}
/**
* Set the current stackframe to a specific frame.
*
* @param nFrame the number of the desired stackframe. Frame zero is the
* closest to the current program counter
* @exception IllegalAccessError when the thread isn't
* suspended or waiting at a breakpoint
* @exception ArrayIndexOutOfBoundsException when the
* requested frame is beyond the stack boundary
*/
void setCurrentFrameIndex(int nFrame) throws IncompatibleThreadStateException {
assureSuspended();
if ((nFrame < 0) || (nFrame >= thread.frameCount())) {
throw new ArrayIndexOutOfBoundsException();
}
currentFrameIndex = nFrame;
}
/**
* Change the current stackframe to be one or more frames higher
* (as in, away from the current program counter).
*
* @param nFrames the number of stackframes
* @exception IllegalAccessError when the thread isn't
* suspended or waiting at a breakpoint
* @exception ArrayIndexOutOfBoundsException when the
* requested frame is beyond the stack boundary
*/
void up(int nFrames) throws IncompatibleThreadStateException {
setCurrentFrameIndex(currentFrameIndex + nFrames);
}
/**
* Change the current stackframe to be one or more frames lower
* (as in, toward the current program counter). *
* @param nFrames the number of stackframes
* @exception IllegalAccessError when the thread isn't
* suspended or waiting at a breakpoint
* @exception ArrayIndexOutOfBoundsException when the
* requested frame is beyond the stack boundary
*/
void down(int nFrames) throws IncompatibleThreadStateException {
setCurrentFrameIndex(currentFrameIndex - nFrames);
}
}