Back to index...

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

	import java.io.*;
	import java.util.*;

	import com.sun.jdi.*;
	import com.sun.tools.example.debug.bdi.*;

	public class CommandInterpreter {

	boolean echo;

	Environment env;

	private ContextManager context;
	private ExecutionManager runtime;
	private ClassManager classManager;
	private SourceManager sourceManager;

	private OutputSink out; //### Hack! Should be local in each method used.
	private String lastCommand = "help";

	public CommandInterpreter(Environment env) {
	this(env, true);
	}

	public CommandInterpreter(Environment env, boolean echo) {
	this.env = env;
	this.echo = echo;
	this.runtime = env.getExecutionManager();
	this.context = env.getContextManager();
	this.classManager = env.getClassManager();
	this.sourceManager = env.getSourceManager();
	}

	private ThreadReference[] threads = null;

	/*
	* The numbering of threads is relative to the current set of threads,
	* and may be affected by the creation and termination of new threads.
	* Commands issued using such thread ids will only give reliable behavior
	* relative to what was shown earlier in 'list' commands if the VM is interrupted.
	* We need a better scheme.
	*/

	private ThreadReference[] threads() throws NoSessionException {
	if (threads == null) {
	ThreadIterator ti = new ThreadIterator(getDefaultThreadGroup());
	List<ThreadReference> tlist = new ArrayList<ThreadReference>();
	while (ti.hasNext()) {
	tlist.add(ti.nextThread());
	}
	threads = tlist.toArray(new ThreadReference[tlist.size()]);
	}
	return threads;
	}

	private ThreadReference findThread(String idToken) throws NoSessionException {
	String id;
	ThreadReference thread = null;
	if (idToken.startsWith("t@")) {
	id = idToken.substring(2);
	} else {
	id = idToken;
	}
	try {
	ThreadReference[] threads = threads();
	long threadID = Long.parseLong(id, 16);
	for (ThreadReference thread2 : threads) {
	if (thread2.uniqueID() == threadID) {
	thread = thread2;
	break;
	}
	}
	if (thread == null) {
	//env.failure("No thread for id \"" + idToken + "\"");
	env.failure("\"" + idToken + "\" is not a valid thread id.");
	}
	} catch (NumberFormatException e) {
	env.error("Thread id \"" + idToken + "\" is ill-formed.");
	thread = null;
	}
	return thread;
	}

	private ThreadIterator allThreads() throws NoSessionException {
	threads = null;
	//### Why not use runtime.allThreads().iterator() ?
	return new ThreadIterator(runtime.topLevelThreadGroups());
	}

	private ThreadIterator currentThreadGroupThreads() throws NoSessionException {
	threads = null;
	return new ThreadIterator(getDefaultThreadGroup());
	}

	private ThreadGroupIterator allThreadGroups() throws NoSessionException {
	threads = null;
	return new ThreadGroupIterator(runtime.topLevelThreadGroups());
	}

	private ThreadGroupReference defaultThreadGroup;

	private ThreadGroupReference getDefaultThreadGroup() throws NoSessionException {
	if (defaultThreadGroup == null) {
	defaultThreadGroup = runtime.systemThreadGroup();
	}
	return defaultThreadGroup;
	}

	private void setDefaultThreadGroup(ThreadGroupReference tg) {
	defaultThreadGroup = tg;
	}

	/*
	* Command handlers.
	*/

	// Command: classes

	private void commandClasses() throws NoSessionException {
	OutputSink out = env.getOutputSink();
	//out.println(" classes list ");
	for (ReferenceType refType : runtime.allClasses()) {
	out.println(refType.name());
	}
	out.show();
	}


	// Command: methods

	private void commandMethods(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("No class specified.");
	return;
	}
	String idClass = t.nextToken();
	ReferenceType cls = findClass(idClass);
	if (cls != null) {
	List<Method> methods = cls.allMethods();
	OutputSink out = env.getOutputSink();
	for (int i = 0; i < methods.size(); i++) {
	Method method = methods.get(i);
	out.print(method.declaringType().name() + " " +
	method.name() + "(");
	Iterator<String> it = method.argumentTypeNames().iterator();
	if (it.hasNext()) {
	while (true) {
	out.print(it.next());
	if (!it.hasNext()) {
	break;
	}
	out.print(", ");
	}
	}
	out.println(")");
	}
	out.show();
	} else {
	//### Should validate class name syntax.
	env.failure("\"" + idClass + "\" is not a valid id or class name.");
	}
	}

	private ReferenceType findClass(String pattern) throws NoSessionException {
	List<ReferenceType> results = runtime.findClassesMatchingPattern(pattern);
	if (results.size() > 0) {
	//### Should handle multiple results sensibly.
	return results.get(0);
	}
	return null;
	}

	// Command: threads

	private void commandThreads(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	OutputSink out = env.getOutputSink();
	printThreadGroup(out, getDefaultThreadGroup(), 0);
	out.show();
	return;
	}
	String name = t.nextToken();
	ThreadGroupReference tg = findThreadGroup(name);
	if (tg == null) {
	env.failure(name + " is not a valid threadgroup name.");
	} else {
	OutputSink out = env.getOutputSink();
	printThreadGroup(out, tg, 0);
	out.show();
	}
	}

	private ThreadGroupReference findThreadGroup(String name) throws NoSessionException {
	//### Issue: Uniqueness of thread group names is not enforced.
	ThreadGroupIterator tgi = allThreadGroups();
	while (tgi.hasNext()) {
	ThreadGroupReference tg = tgi.nextThreadGroup();
	if (tg.name().equals(name)) {
	return tg;
	}
	}
	return null;
	}

	private int printThreadGroup(OutputSink out, ThreadGroupReference tg, int iThread) {
	out.println("Group " + tg.name() + ":");
	List<ThreadReference> tlist = tg.threads();
	int maxId = 0;
	int maxName = 0;
	for (int i = 0 ; i < tlist.size() ; i++) {
	ThreadReference thr = tlist.get(i);
	int len = Utils.description(thr).length();
	if (len > maxId) {
	maxId = len;
	}
	String name = thr.name();
	int iDot = name.lastIndexOf('.');
	if (iDot >= 0 && name.length() > iDot) {
	name = name.substring(iDot + 1);
	}
	if (name.length() > maxName) {
	maxName = name.length();
	}
	}
	String maxNumString = String.valueOf(iThread + tlist.size());
	int maxNumDigits = maxNumString.length();
	for (int i = 0 ; i < tlist.size() ; i++) {
	ThreadReference thr = tlist.get(i);
	char buf[] = new char[80];
	for (int j = 0; j < 79; j++) {
	buf[j] = ' ';
	}
	buf[79] = '\0';
	StringBuffer sbOut = new StringBuffer();
	sbOut.append(buf);

	// Right-justify the thread number at start of output string
	String numString = String.valueOf(iThread + i + 1);
	sbOut.insert(maxNumDigits - numString.length(),
	numString);
	sbOut.insert(maxNumDigits, ".");

	int iBuf = maxNumDigits + 2;
	sbOut.insert(iBuf, Utils.description(thr));
	iBuf += maxId + 1;
	String name = thr.name();
	int iDot = name.lastIndexOf('.');
	if (iDot >= 0 && name.length() > iDot) {
	name = name.substring(iDot + 1);
	}
	sbOut.insert(iBuf, name);
	iBuf += maxName + 1;
	sbOut.insert(iBuf, Utils.getStatus(thr));
	sbOut.setLength(79);
	out.println(sbOut.toString());
	}
	for (ThreadGroupReference tg0 : tg.threadGroups()) {
	if (!tg.equals(tg0)) { // TODO ref mgt
	iThread += printThreadGroup(out, tg0, iThread + tlist.size());
	}
	}
	return tlist.size();
	}

	// Command: threadgroups

	private void commandThreadGroups() throws NoSessionException {
	ThreadGroupIterator it = allThreadGroups();
	int cnt = 0;
	OutputSink out = env.getOutputSink();
	while (it.hasNext()) {
	ThreadGroupReference tg = it.nextThreadGroup();
	++cnt;
	out.println("" + cnt + ". " + Utils.description(tg) + " " + tg.name());
	}
	out.show();
	}

	// Command: thread

	private void commandThread(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("Thread number not specified.");
	return;
	}
	ThreadReference thread = findThread(t.nextToken());
	if (thread != null) {
	//### Should notify user.
	context.setCurrentThread(thread);
	}
	}

	// Command: threadgroup

	private void commandThreadGroup(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("Threadgroup name not specified.");
	return;
	}
	String name = t.nextToken();
	ThreadGroupReference tg = findThreadGroup(name);
	if (tg == null) {
	env.failure(name + " is not a valid threadgroup name.");
	} else {
	//### Should notify user.
	setDefaultThreadGroup(tg);
	}
	}

	// Command: run

	private void commandRun(StringTokenizer t) throws NoSessionException {
	if (doLoad(false, t)) {
	env.notice("Running ...");
	}
	}

	// Command: load

	private void commandLoad(StringTokenizer t) throws NoSessionException {
	if (doLoad(true, t)) {}
	}

	private boolean doLoad(boolean suspended,
	StringTokenizer t) throws NoSessionException {

	String clname;

	if (!t.hasMoreTokens()) {
	clname = context.getMainClassName();
	if (!clname.equals("")) {
	// Run from prevously-set class name.
	try {
	String vmArgs = context.getVmArguments();
	runtime.run(suspended,
	vmArgs,
	clname,
	context.getProgramArguments());
	return true;
	} catch (VMLaunchFailureException e) {
	env.failure("Attempt to launch main class \"" + clname + "\" failed.");
	}
	} else {
	env.failure("No main class specified and no current default defined.");
	}
	} else {
	clname = t.nextToken();
	StringBuffer sbuf = new StringBuffer();
	// Allow VM arguments to be specified here?
	while (t.hasMoreTokens()) {
	String tok = t.nextToken();
	sbuf.append(tok);
	if (t.hasMoreTokens()) {
	sbuf.append(' ');
	}
	}
	String args = sbuf.toString();
	try {
	String vmArgs = context.getVmArguments();
	runtime.run(suspended, vmArgs, clname, args);
	context.setMainClassName(clname);
	//context.setVmArguments(vmArgs);
	context.setProgramArguments(args);
	return true;
	} catch (VMLaunchFailureException e) {
	env.failure("Attempt to launch main class \"" + clname + "\" failed.");
	}
	}
	return false;
	}

	// Command: connect

	private void commandConnect(StringTokenizer t) {
	try {
	LaunchTool.queryAndLaunchVM(runtime);
	} catch (VMLaunchFailureException e) {
	env.failure("Attempt to connect failed.");
	}
	}

	// Command: attach

	private void commandAttach(StringTokenizer t) {
	String portName;
	if (!t.hasMoreTokens()) {
	portName = context.getRemotePort();
	if (!portName.equals("")) {
	try {
	runtime.attach(portName);
	} catch (VMLaunchFailureException e) {
	env.failure("Attempt to attach to port \"" + portName + "\" failed.");
	}
	} else {
	env.failure("No port specified and no current default defined.");
	}
	} else {
	portName = t.nextToken();
	try {
	runtime.attach(portName);
	} catch (VMLaunchFailureException e) {
	env.failure("Attempt to attach to port \"" + portName + "\" failed.");
	}
	context.setRemotePort(portName);
	}
	}

	// Command: detach

	private void commandDetach(StringTokenizer t) throws NoSessionException {
	runtime.detach();
	}

	// Command: interrupt

	private void commandInterrupt(StringTokenizer t) throws NoSessionException {
	runtime.interrupt();
	}

	// Command: suspend

	private void commandSuspend(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	// Suspend all threads in the current thread group.
	//### Issue: help message says default is all threads.
	//### Behavior here agrees with 'jdb', however.
	ThreadIterator ti = currentThreadGroupThreads();
	while (ti.hasNext()) {
	// TODO - don't suspend debugger threads
	ti.nextThread().suspend();
	}
	env.notice("All (non-system) threads suspended.");
	} else {
	while (t.hasMoreTokens()) {
	ThreadReference thread = findThread(t.nextToken());
	if (thread != null) {
	//thread.suspend();
	runtime.suspendThread(thread);
	}
	}
	}
	}

	// Command: resume

	private void commandResume(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	// Suspend all threads in the current thread group.
	//### Issue: help message says default is all threads.
	//### Behavior here agrees with 'jdb', however.
	ThreadIterator ti = currentThreadGroupThreads();
	while (ti.hasNext()) {
	// TODO - don't suspend debugger threads
	ti.nextThread().resume();
	}
	env.notice("All threads resumed.");
	} else {
	while (t.hasMoreTokens()) {
	ThreadReference thread = findThread(t.nextToken());
	if (thread != null) {
	//thread.resume();
	runtime.resumeThread(thread);
	}
	}
	}
	}

	// Command: cont

	private void commandCont() throws NoSessionException {
	try {
	runtime.go();
	} catch (VMNotInterruptedException e) {
	//### failure?
	env.notice("Target VM is already running.");
	}
	}

	// Command: step

	private void commandStep(StringTokenizer t) throws NoSessionException{
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	try {
	if (t.hasMoreTokens() &&
	t.nextToken().toLowerCase().equals("up")) {
	runtime.stepOut(current);
	} else {
	runtime.stepIntoLine(current);
	}
	} catch (AbsentInformationException e) {
	env.failure("No linenumber information available -- " +
	"Try \"stepi\" to step by instructions.");
	}
	}

	// Command: stepi

	private void commandStepi() throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	runtime.stepIntoInstruction(current);
	}

	// Command: next

	private void commandNext() throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	try {
	runtime.stepOverLine(current);
	} catch (AbsentInformationException e) {
	env.failure("No linenumber information available -- " +
	"Try \"nexti\" to step by instructions.");
	}
	}

	// Command: nexti (NEW)

	private void commandNexti() throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	runtime.stepOverInstruction(current);
	}

	// Command: kill

	private void commandKill(StringTokenizer t) throws NoSessionException {
	//### Should change the way in which thread ids and threadgroup names
	//### are distinguished.
	if (!t.hasMoreTokens()) {
	env.error("Usage: kill <threadgroup name> or <thread id>");
	return;
	}
	while (t.hasMoreTokens()) {
	String idToken = t.nextToken();
	ThreadReference thread = findThread(idToken);
	if (thread != null) {
	runtime.stopThread(thread);
	env.notice("Thread " + thread.name() + " killed.");
	return;
	} else {
	/* Check for threadgroup name, NOT skipping "system". */
	//### Should skip "system"? Classic 'jdb' does this.
	//### Should deal with possible non-uniqueness of threadgroup names.
	ThreadGroupIterator itg = allThreadGroups();
	while (itg.hasNext()) {
	ThreadGroupReference tg = itg.nextThreadGroup();
	if (tg.name().equals(idToken)) {
	ThreadIterator it = new ThreadIterator(tg);
	while (it.hasNext()) {
	runtime.stopThread(it.nextThread());
	}
	env.notice("Threadgroup " + tg.name() + "killed.");
	return;
	}
	}
	env.failure("\"" + idToken +
	"\" is not a valid threadgroup or id.");
	}
	}
	}


	/*************
	// TODO
	private void commandCatchException(StringTokenizer t) throws NoSessionException {}
	// TODO
	private void commandIgnoreException(StringTokenizer t) throws NoSessionException {}
	*************/

	// Command: up

	//### Print current frame after command?

	int readCount(StringTokenizer t) {
	int cnt = 1;
	if (t.hasMoreTokens()) {
	String idToken = t.nextToken();
	try {
	cnt = Integer.valueOf(idToken).intValue();
	} catch (NumberFormatException e) {
	cnt = -1;
	}
	}
	return cnt;
	}

	void commandUp(StringTokenizer t) throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	int nLevels = readCount(t);
	if (nLevels <= 0) {
	env.error("usage: up [n frames]");
	return;
	}
	try {
	int delta = context.moveCurrentFrameIndex(current, -nLevels);
	if (delta == 0) {
	env.notice("Already at top of stack.");
	} else if (-delta < nLevels) {
	env.notice("Moved up " + delta + " frames to top of stack.");
	}
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	}
	}

	private void commandDown(StringTokenizer t) throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	int nLevels = readCount(t);
	if (nLevels <= 0) {
	env.error("usage: down [n frames]");
	return;
	}
	try {
	int delta = context.moveCurrentFrameIndex(current, nLevels);
	if (delta == 0) {
	env.notice("Already at bottom of stack.");
	} else if (delta < nLevels) {
	env.notice("Moved down " + delta + " frames to bottom of stack.");
	}
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	}
	}

	// Command: frame

	private void commandFrame(StringTokenizer t) throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No current thread.");
	return;
	}
	if (!t.hasMoreTokens()) {
	env.error("usage: frame <frame-index>");
	return;
	}
	String idToken = t.nextToken();
	int n;
	try {
	n = Integer.valueOf(idToken).intValue();
	} catch (NumberFormatException e) {
	n = 0;
	}
	if (n <= 0) {
	env.error("use positive frame index");
	return;
	}
	try {
	int delta = context.setCurrentFrameIndex(current, n);
	if (delta == 0) {
	env.notice("Frame unchanged.");
	} else if (delta < 0) {
	env.notice("Moved up " + -delta + " frames.");
	} else {
	env.notice("Moved down " + delta + " frames.");
	}
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	}
	}

	// Command: where

	//### Should we insist that VM be interrupted here?
	//### There is an inconsistency between the 'where' command
	//### and 'up' and 'down' in this respect.

	private void commandWhere(StringTokenizer t, boolean showPC)
	throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (!t.hasMoreTokens()) {
	if (current == null) {
	env.error("No thread specified.");
	return;
	}
	dumpStack(current, showPC);
	} else {
	String token = t.nextToken();
	if (token.toLowerCase().equals("all")) {
	ThreadIterator it = allThreads();
	while (it.hasNext()) {
	ThreadReference thread = it.next();
	out.println(thread.name() + ": ");
	dumpStack(thread, showPC);
	}
	} else {
	ThreadReference thread = findThread(t.nextToken());
	//### Do we want to set current thread here?
	//### Should notify user of change.
	if (thread != null) {
	context.setCurrentThread(thread);
	}
	dumpStack(thread, showPC);
	}
	}
	}

	private void dumpStack(ThreadReference thread, boolean showPC) {
	//### Check for these.
	//env.failure("Thread no longer exists.");
	//env.failure("Target VM must be in interrupted state.");
	//env.failure("Current thread isn't suspended.");
	//### Should handle extremely long stack traces sensibly for user.
	List<StackFrame> stack = null;
	try {
	stack = thread.frames();
	} catch (IncompatibleThreadStateException e) {
	env.failure("Thread is not suspended.");
	}
	//### Fix this!
	//### Previously mishandled cases where thread was not current.
	//### Now, prints all of the stack regardless of current frame.
	int frameIndex = 0;
	//int frameIndex = context.getCurrentFrameIndex();
	if (stack == null) {
	env.failure("Thread is not running (no stack).");
	} else {
	OutputSink out = env.getOutputSink();
	int nFrames = stack.size();
	for (int i = frameIndex; i < nFrames; i++) {
	StackFrame frame = stack.get(i);
	Location loc = frame.location();
	Method meth = loc.method();
	out.print(" [" + (i + 1) + "] ");
	out.print(meth.declaringType().name());
	out.print('.');
	out.print(meth.name());
	out.print(" (");
	if (meth.isNative()) {
	out.print("native method");
	} else if (loc.lineNumber() != -1) {
	try {
	out.print(loc.sourceName());
	} catch (AbsentInformationException e) {
	out.print("<unknown>");
	}
	out.print(':');
	out.print(loc.lineNumber());
	}
	out.print(')');
	if (showPC) {
	long pc = loc.codeIndex();
	if (pc != -1) {
	out.print(", pc = " + pc);
	}
	}
	out.println();
	}
	out.show();
	}
	}

	private void listEventRequests() throws NoSessionException {
	// Print set breakpoints
	List<EventRequestSpec> specs = runtime.eventRequestSpecs();
	if (specs.isEmpty()) {
	env.notice("No breakpoints/watchpoints/exceptions set.");
	} else {
	OutputSink out = env.getOutputSink();
	out.println("Current breakpoints/watchpoints/exceptions set:");
	for (EventRequestSpec bp : specs) {
	out.println("\t" + bp);
	}
	out.show();
	}
	}

	private BreakpointSpec parseBreakpointSpec(String bptSpec) {
	StringTokenizer t = new StringTokenizer(bptSpec);
	BreakpointSpec bpSpec = null;
	// try {
	String token = t.nextToken("@:( \t\n\r");
	// We can't use hasMoreTokens here because it will cause any leading
	// paren to be lost.
	String rest;
	try {
	rest = t.nextToken("").trim();
	} catch (NoSuchElementException e) {
	rest = null;
	}
	if ((rest != null) && rest.startsWith("@")) {
	t = new StringTokenizer(rest.substring(1));
	String sourceName = token;
	String lineToken = t.nextToken();
	int lineNumber = Integer.valueOf(lineToken).intValue();
	if (t.hasMoreTokens()) {
	return null;
	}
	bpSpec = runtime.createSourceLineBreakpoint(sourceName,
	lineNumber);
	} else if ((rest != null) && rest.startsWith(":")) {
	t = new StringTokenizer(rest.substring(1));
	String classId = token;
	String lineToken = t.nextToken();
	int lineNumber = Integer.valueOf(lineToken).intValue();
	if (t.hasMoreTokens()) {
	return null;
	}
	bpSpec = runtime.createClassLineBreakpoint(classId, lineNumber);
	} else {
	// Try stripping method from class.method token.
	int idot = token.lastIndexOf(".");
	if ( (idot <= 0) \|\| /* No dot or dot in first char */
	(idot >= token.length() - 1) ) { /* dot in last char */
	return null;
	}
	String methodName = token.substring(idot + 1);
	String classId = token.substring(0, idot);
	List<String> argumentList = null;
	if (rest != null) {
	if (!rest.startsWith("(") \|\| !rest.endsWith(")")) {
	//### Should throw exception with error message
	//out.println("Invalid method specification: "
	// + methodName + rest);
	return null;
	}
	// Trim the parens
	//### What about spaces in arglist?
	rest = rest.substring(1, rest.length() - 1);
	argumentList = new ArrayList<String>();
	t = new StringTokenizer(rest, ",");
	while (t.hasMoreTokens()) {
	argumentList.add(t.nextToken());
	}
	}
	bpSpec = runtime.createMethodBreakpoint(classId,
	methodName,
	argumentList);
	}
	// } catch (Exception e) {
	// env.error("Exception attempting to create breakpoint: " + e);
	// return null;
	// }
	return bpSpec;
	}

	private void commandStop(StringTokenizer t) throws NoSessionException {
	String token;

	if (!t.hasMoreTokens()) {
	listEventRequests();
	} else {
	token = t.nextToken();
	// Ignore optional "at" or "in" token.
	// Allowed for backward compatibility.
	if (token.equals("at") \|\| token.equals("in")) {
	if (t.hasMoreTokens()) {
	token = t.nextToken();
	} else {
	env.error("Missing breakpoint specification.");
	return;
	}
	}
	BreakpointSpec bpSpec = parseBreakpointSpec(token);
	if (bpSpec != null) {
	//### Add sanity-checks for deferred breakpoint.
	runtime.install(bpSpec);
	} else {
	env.error("Ill-formed breakpoint specification.");
	}
	}
	}

	private void commandClear(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	// Print set breakpoints
	listEventRequests();
	return;
	}
	//### need 'clear all'
	BreakpointSpec bpSpec = parseBreakpointSpec(t.nextToken());
	if (bpSpec != null) {
	List<EventRequestSpec> specs = runtime.eventRequestSpecs();

	if (specs.isEmpty()) {
	env.notice("No breakpoints set.");
	} else {
	List<EventRequestSpec> toDelete = new ArrayList<EventRequestSpec>();
	for (EventRequestSpec spec : specs) {
	if (spec.equals(bpSpec)) {
	toDelete.add(spec);
	}
	}
	// The request used for matching should be found
	if (toDelete.size() <= 1) {
	env.notice("No matching breakpoint set.");
	}
	for (EventRequestSpec spec : toDelete) {
	runtime.delete(spec);
	}
	}
	} else {
	env.error("Ill-formed breakpoint specification.");
	}
	}

	// Command: list

	private void commandList(StringTokenizer t) throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.error("No thread specified.");
	return;
	}
	Location loc;
	try {
	StackFrame frame = context.getCurrentFrame(current);
	if (frame == null) {
	env.failure("Thread has not yet begun execution.");
	return;
	}
	loc = frame.location();
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	return;
	}
	SourceModel source = sourceManager.sourceForLocation(loc);
	if (source == null) {
	if (loc.method().isNative()) {
	env.failure("Current method is native.");
	return;
	}
	env.failure("No source available for " + Utils.locationString(loc) + ".");
	return;
	}
	ReferenceType refType = loc.declaringType();
	int lineno = loc.lineNumber();
	if (t.hasMoreTokens()) {
	String id = t.nextToken();
	// See if token is a line number.
	try {
	lineno = Integer.valueOf(id).intValue();
	} catch (NumberFormatException nfe) {
	// It isn't -- see if it's a method name.
	List<Method> meths = refType.methodsByName(id);
	if (meths == null \|\| meths.size() == 0) {
	env.failure(id +
	" is not a valid line number or " +
	"method name for class " +
	refType.name());
	return;
	} else if (meths.size() > 1) {
	env.failure(id +
	" is an ambiguous method name in" +
	refType.name());
	return;
	}
	loc = meths.get(0).location();
	lineno = loc.lineNumber();
	}
	}
	int startLine = (lineno > 4) ? lineno - 4 : 1;
	int endLine = startLine + 9;
	String sourceLine = source.sourceLine(lineno);
	if (sourceLine == null) {
	env.failure("" +
	lineno +
	" is an invalid line number for " +
	refType.name());
	} else {
	OutputSink out = env.getOutputSink();
	for (int i = startLine; i <= endLine; i++) {
	sourceLine = source.sourceLine(i);
	if (sourceLine == null) {
	break;
	}
	out.print(i);
	out.print("\t");
	if (i == lineno) {
	out.print("=> ");
	} else {
	out.print(" ");
	}
	out.println(sourceLine);
	}
	out.show();
	}
	}

	// Command: use
	// Get or set the source file path list.

	private void commandUse(StringTokenizer t) {
	if (!t.hasMoreTokens()) {
	out.println(sourceManager.getSourcePath().asString());
	} else {
	//### Should throw exception for invalid path.
	//### E.g., vetoable property change.
	sourceManager.setSourcePath(new SearchPath(t.nextToken()));
	}
	}

	// Command: sourcepath
	// Get or set the source file path list. (Alternate to 'use'.)

	private void commandSourcepath(StringTokenizer t) {
	if (!t.hasMoreTokens()) {
	out.println(sourceManager.getSourcePath().asString());
	} else {
	//### Should throw exception for invalid path.
	//### E.g., vetoable property change.
	sourceManager.setSourcePath(new SearchPath(t.nextToken()));
	}
	}

	// Command: classpath
	// Get or set the class file path list.

	private void commandClasspath(StringTokenizer t) {
	if (!t.hasMoreTokens()) {
	out.println(classManager.getClassPath().asString());
	} else {
	//### Should throw exception for invalid path.
	//### E.g., vetoable property change.
	classManager.setClassPath(new SearchPath(t.nextToken()));
	}
	}

	// Command: view
	// Display source for source file or class.

	private void commandView(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("Argument required");
	} else {
	String name = t.nextToken();
	if (name.endsWith(".java") \|\|
	name.indexOf(File.separatorChar) >= 0) {
	env.viewSource(name);
	} else {
	//### JDI crashes taking line number for class.
	/*****
	ReferenceType cls = findClass(name);
	if (cls != null) {
	env.viewLocation(cls.location());
	} else {
	env.failure("No such class");
	}
	*****/
	String fileName = name.replace('.', File.separatorChar) + ".java";
	env.viewSource(fileName);
	}
	}
	}

	// Command: locals
	// Print all local variables in current stack frame.

	private void commandLocals() throws NoSessionException {
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No default thread specified: " +
	"use the \"thread\" command first.");
	return;
	}
	StackFrame frame;
	try {
	frame = context.getCurrentFrame(current);
	if (frame == null) {
	env.failure("Thread has not yet created any stack frames.");
	return;
	}
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	return;
	}

	List<LocalVariable> vars;
	try {
	vars = frame.visibleVariables();
	if (vars == null \|\| vars.size() == 0) {
	env.failure("No local variables");
	return;
	}
	} catch (AbsentInformationException e) {
	env.failure("Local variable information not available." +
	" Compile with -g to generate variable information");
	return;
	}

	OutputSink out = env.getOutputSink();
	out.println("Method arguments:");
	for (LocalVariable var : vars) {
	if (var.isArgument()) {
	printVar(out, var, frame);
	}
	}
	out.println("Local variables:");
	for (LocalVariable var : vars) {
	if (!var.isArgument()) {
	printVar(out, var, frame);
	}
	}
	out.show();
	return;
	}

	/**
	* Command: monitor
	* Monitor an expression
	*/
	private void commandMonitor(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("Argument required");
	} else {
	env.getMonitorListModel().add(t.nextToken(""));
	}
	}

	/**
	* Command: unmonitor
	* Unmonitor an expression
	*/
	private void commandUnmonitor(StringTokenizer t) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	env.error("Argument required");
	} else {
	env.getMonitorListModel().remove(t.nextToken(""));
	}
	}

	// Print a stack variable.

	private void printVar(OutputSink out, LocalVariable var, StackFrame frame) {
	out.print(" " + var.name());
	if (var.isVisible(frame)) {
	Value val = frame.getValue(var);
	out.println(" = " + val.toString());
	} else {
	out.println(" is not in scope");
	}
	}

	// Command: print
	// Evaluate an expression.

	private void commandPrint(StringTokenizer t, boolean dumpObject) throws NoSessionException {
	if (!t.hasMoreTokens()) {
	//### Probably confused if expresion contains whitespace.
	env.error("No expression specified.");
	return;
	}
	ThreadReference current = context.getCurrentThread();
	if (current == null) {
	env.failure("No default thread specified: " +
	"use the \"thread\" command first.");
	return;
	}
	StackFrame frame;
	try {
	frame = context.getCurrentFrame(current);
	if (frame == null) {
	env.failure("Thread has not yet created any stack frames.");
	return;
	}
	} catch (VMNotInterruptedException e) {
	env.failure("Target VM must be in interrupted state.");
	return;
	}
	while (t.hasMoreTokens()) {
	String expr = t.nextToken("");
	Value val = null;
	try {
	val = runtime.evaluate(frame, expr);
	} catch(Exception e) {
	env.error("Exception: " + e);
	//### Fix this!
	}
	if (val == null) {
	return; // Error message already printed
	}
	OutputSink out = env.getOutputSink();
	if (dumpObject && (val instanceof ObjectReference) &&
	!(val instanceof StringReference)) {
	ObjectReference obj = (ObjectReference)val;
	ReferenceType refType = obj.referenceType();
	out.println(expr + " = " + val.toString() + " {");
	dump(out, obj, refType, refType);
	out.println("}");
	} else {
	out.println(expr + " = " + val.toString());
	}
	out.show();
	}
	}

	private void dump(OutputSink out,
	ObjectReference obj, ReferenceType refType,
	ReferenceType refTypeBase) {
	for (Field field : refType.fields()) {
	out.print(" ");
	if (!refType.equals(refTypeBase)) {
	out.print(refType.name() + ".");
	}
	out.print(field.name() + ": ");
	Object o = obj.getValue(field);
	out.println((o == null) ? "null" : o.toString()); // Bug ID 4374471
	}
	if (refType instanceof ClassType) {
	ClassType sup = ((ClassType)refType).superclass();
	if (sup != null) {
	dump(out, obj, sup, refTypeBase);
	}
	} else if (refType instanceof InterfaceType) {
	for (InterfaceType sup : ((InterfaceType)refType).superinterfaces()) {
	dump(out, obj, sup, refTypeBase);
	}
	}
	}

	/*
	* Display help message.
	*/

	private void help() {
	out.println(" command list ");
	out.println("threads [threadgroup] -- list threads");
	out.println("thread <thread id> -- set default thread");
	out.println("suspend [thread id(s)] -- suspend threads (default: all)");
	out.println("resume [thread id(s)] -- resume threads (default: all)");
	out.println("where [thread id] \| all -- dump a thread's stack");
	out.println("wherei [thread id] \| all -- dump a thread's stack, with pc info");
	out.println("threadgroups -- list threadgroups");
	out.println("threadgroup <name> -- set current threadgroup\n");
	// out.println("print <expression> -- print value of expression");
	out.println("dump <expression> -- print all object information\n");
	// out.println("eval <expression> -- evaluate expression (same as print)");
	out.println("locals -- print all local variables in current stack frame\n");
	out.println("classes -- list currently known classes");
	out.println("methods <class id> -- list a class's methods\n");
	out.println("stop [in] <class id>.<method>[(argument_type,...)] -- set a breakpoint in a method");
	out.println("stop [at] <class id>:<line> -- set a breakpoint at a line");
	out.println("up [n frames] -- move up a thread's stack");
	out.println("down [n frames] -- move down a thread's stack");
	out.println("frame <frame-id> -- to a frame");
	out.println("clear <class id>.<method>[(argument_type,...)] -- clear a breakpoint in a method");
	out.println("clear <class id>:<line> -- clear a breakpoint at a line");
	out.println("clear -- list breakpoints");
	out.println("step -- execute current line");
	out.println("step up -- execute until the current method returns to its caller");
	out.println("stepi -- execute current instruction");
	out.println("next -- step one line (step OVER calls)");
	out.println("nexti -- step one instruction (step OVER calls)");
	out.println("cont -- continue execution from breakpoint\n");
	// out.println("catch <class id> -- break for the specified exception");
	// out.println("ignore <class id> -- ignore when the specified exception\n");
	out.println("view classname\|filename -- display source file");
	out.println("list [line number\|method] -- print source code context at line or method");
	out.println("use <source file path> -- display or change the source path\n");
	//### new
	out.println("sourcepath <source file path> -- display or change the source path\n");
	//### new
	out.println("classpath <class file path> -- display or change the class path\n");
	out.println("monitor <expression> -- evaluate an expression each time the program stops\n");
	out.println("unmonitor <monitor#> -- delete a monitor\n");
	out.println("read <filename> -- read and execute a command file\n");
	// out.println("memory -- report memory usage");
	// out.println("gc -- free unused objects\n");
	out.println("run <class> [args] -- start execution of a Java class");
	out.println("run -- re-execute last class run");
	out.println("load <class> [args] -- start execution of a Java class, initially suspended");
	out.println("load -- re-execute last class run, initially suspended");
	out.println("attach <portname> -- debug existing process\n");
	out.println("detach -- detach from debuggee process\n");
	out.println("kill <thread(group)> -- kill a thread or threadgroup\n");
	out.println("!! -- repeat last command");
	out.println("help (or ?) -- list commands");
	out.println("exit (or quit) -- exit debugger");
	}

	/*
	* Execute a command.
	*/

	public void executeCommand(String command) {
	//### Treatment of 'out' here is dirty...
	out = env.getOutputSink();
	if (echo) {
	out.println(">>> " + command);
	}
	StringTokenizer t = new StringTokenizer(command);
	try {
	String cmd;
	if (t.hasMoreTokens()) {
	cmd = t.nextToken().toLowerCase();
	lastCommand = cmd;
	} else {
	cmd = lastCommand;
	}
	if (cmd.equals("print")) {
	commandPrint(t, false);
	} else if (cmd.equals("eval")) {
	commandPrint(t, false);
	} else if (cmd.equals("dump")) {
	commandPrint(t, true);
	} else if (cmd.equals("locals")) {
	commandLocals();
	} else if (cmd.equals("classes")) {
	commandClasses();
	} else if (cmd.equals("methods")) {
	commandMethods(t);
	} else if (cmd.equals("threads")) {
	commandThreads(t);
	} else if (cmd.equals("thread")) {
	commandThread(t);
	} else if (cmd.equals("suspend")) {
	commandSuspend(t);
	} else if (cmd.equals("resume")) {
	commandResume(t);
	} else if (cmd.equals("cont")) {
	commandCont();
	} else if (cmd.equals("threadgroups")) {
	commandThreadGroups();
	} else if (cmd.equals("threadgroup")) {
	commandThreadGroup(t);
	} else if (cmd.equals("run")) {
	commandRun(t);
	} else if (cmd.equals("load")) {
	commandLoad(t);
	} else if (cmd.equals("connect")) {
	commandConnect(t);
	} else if (cmd.equals("attach")) {
	commandAttach(t);
	} else if (cmd.equals("detach")) {
	commandDetach(t);
	} else if (cmd.equals("interrupt")) {
	commandInterrupt(t);
	//### Not implemented.
	// } else if (cmd.equals("catch")) {
	// commandCatchException(t);
	//### Not implemented.
	// } else if (cmd.equals("ignore")) {
	// commandIgnoreException(t);
	} else if (cmd.equals("step")) {
	commandStep(t);
	} else if (cmd.equals("stepi")) {
	commandStepi();
	} else if (cmd.equals("next")) {
	commandNext();
	} else if (cmd.equals("nexti")) {
	commandNexti();
	} else if (cmd.equals("kill")) {
	commandKill(t);
	} else if (cmd.equals("where")) {
	commandWhere(t, false);
	} else if (cmd.equals("wherei")) {
	commandWhere(t, true);
	} else if (cmd.equals("up")) {
	commandUp(t);
	} else if (cmd.equals("down")) {
	commandDown(t);
	} else if (cmd.equals("frame")) {
	commandFrame(t);
	} else if (cmd.equals("stop")) {
	commandStop(t);
	} else if (cmd.equals("clear")) {
	commandClear(t);
	} else if (cmd.equals("list")) {
	commandList(t);
	} else if (cmd.equals("use")) {
	commandUse(t);
	} else if (cmd.equals("sourcepath")) {
	commandSourcepath(t);
	} else if (cmd.equals("classpath")) {
	commandClasspath(t);
	} else if (cmd.equals("monitor")) {
	commandMonitor(t);
	} else if (cmd.equals("unmonitor")) {
	commandUnmonitor(t);
	} else if (cmd.equals("view")) {
	commandView(t);
	// } else if (cmd.equals("read")) {
	// readCommand(t);
	} else if (cmd.equals("help") \|\| cmd.equals("?")) {
	help();
	} else if (cmd.equals("quit") \|\| cmd.equals("exit")) {
	try {
	runtime.detach();
	} catch (NoSessionException e) {
	// ignore
	}
	env.terminate();
	} else {
	//### Dubious repeat-count feature inherited from 'jdb'
	if (t.hasMoreTokens()) {
	try {
	int repeat = Integer.parseInt(cmd);
	String subcom = t.nextToken("");
	while (repeat-- > 0) {
	executeCommand(subcom);
	}
	return;
	} catch (NumberFormatException exc) {
	}
	}
	out.println("huh? Try help...");
	out.flush();
	}
	} catch (NoSessionException e) {
	out.println("There is no currently attached VM session.");
	out.flush();
	} catch (Exception e) {
	out.println("Internal exception: " + e.toString());
	out.flush();
	System.out.println("JDB internal exception: " + e.toString());
	e.printStackTrace();
	}
	out.show();
	}
	}

Back to index...