public void exceptionEvent(ExceptionEvent event) {
ObjectReference or = event.exception();
ReferenceType rt = or.referenceType();
String exceptionName = rt.name();
// Field messageField = Throwable.class.getField("detailMessage");
Field messageField = rt.fieldByName("detailMessage");
// System.out.println("field " + messageField);
Value messageValue = or.getValue(messageField);
// System.out.println("mess val " + messageValue);
// "java.lang.ArrayIndexOutOfBoundsException"
int last = exceptionName.lastIndexOf('.');
String message = exceptionName.substring(last + 1);
if (messageValue != null) {
String messageStr = messageValue.toString();
if (messageStr.startsWith("\"")) {
messageStr = messageStr.substring(1, messageStr.length() - 1);
}
message += ": " + messageStr;
}
// System.out.println("mess type " + messageValue.type());
// StringReference messageReference = (StringReference) messageValue.type();
// First just report the exception and its placement
reportException(message, or, event.thread());
// Then try to pretty it up with a better message
handleCommonErrors(exceptionName, message, listener);
if (editor != null) {
editor.deactivateRun();
}
}
static ReferenceType getReferenceTypeFromToken(String idToken) {
ReferenceType cls = null;
if (Character.isDigit(idToken.charAt(0))) {
cls = null;
} else if (idToken.startsWith("*.")) {
// This notation saves typing by letting the user omit leading
// package names. The first
// loaded class whose name matches this limited regular
// expression is selected.
idToken = idToken.substring(1);
for (ReferenceType type : Env.vm().allClasses()) {
if (type.name().endsWith(idToken)) {
cls = type;
break;
}
}
} else {
// It's a class name
List<ReferenceType> classes = Env.vm().classesByName(idToken);
if (classes.size() > 0) {
// TO DO: handle multiples
cls = classes.get(0);
}
}
return cls;
}
private void commandClasses() throws NoSessionException {
OutputSink out = env.getOutputSink();
// out.println("** classes list **");
for (ReferenceType refType : runtime.allClasses()) {
out.println(refType.name());
}
out.show();
}
/** Return a description of an object. */
static String description(ObjectReference ref) {
ReferenceType clazz = ref.referenceType();
long id = ref.uniqueID();
if (clazz == null) {
return toHex(id);
} else {
return MessageOutput.format(
"object description and hex id", new Object[] {clazz.name(), toHex(id)});
}
}
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);
}
}
}
/** Get source object associated with a class or interface. Returns null if not available. */
public SourceModel sourceForClass(ReferenceType refType) {
SourceModel sm = classToSource.get(refType);
if (sm != null) {
return sm;
}
try {
String filename = refType.sourceName();
String refName = refType.name();
int iDot = refName.lastIndexOf('.');
String pkgName = (iDot >= 0) ? refName.substring(0, iDot + 1) : "";
String full = pkgName.replace('.', File.separatorChar) + filename;
File path = sourcePath.resolve(full);
if (path != null) {
sm = sourceForFile(path);
classToSource.put(refType, sm);
return sm;
}
return null;
} catch (AbsentInformationException e) {
return null;
}
}
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();
}
}