/*
* 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.*;
import com.sun.jdi.request.StepRequest;
import com.sun.jdi.request.MethodEntryRequest;
import com.sun.jdi.request.MethodExitRequest;
import java.util.*;
import java.io.*;
class Env {
static EventRequestSpecList specList = new EventRequestSpecList();
private static VMConnection connection;
private static SourceMapper sourceMapper = new SourceMapper("");
private static List<String> excludes;
private static final int SOURCE_CACHE_SIZE = 5;
private static List<SourceCode> sourceCache = new LinkedList<SourceCode>();
private static HashMap<String, Value> savedValues = new HashMap<String, Value>();
private static Method atExitMethod;
static void init(String connectSpec, boolean openNow, int flags) {
connection = new VMConnection(connectSpec, flags);
if (!connection.isLaunch() || openNow) {
connection.open();
}
}
static VMConnection connection() {
return connection;
}
static VirtualMachine vm() {
return connection.vm();
}
static void shutdown() {
shutdown(null);
}
static void shutdown(String message) {
if (connection != null) {
try {
connection.disposeVM();
} catch (VMDisconnectedException e) {
// Shutting down after the VM has gone away. This is
// not an error, and we just ignore it.
}
}
if (message != null) {
MessageOutput.lnprint(message);
MessageOutput.println();
}
System.exit(0);
}
static void setSourcePath(String srcPath) {
sourceMapper = new SourceMapper(srcPath);
sourceCache.clear();
}
static void setSourcePath(List<String> srcList) {
sourceMapper = new SourceMapper(srcList);
sourceCache.clear();
}
static String getSourcePath() {
return sourceMapper.getSourcePath();
}
static private List<String> excludes() {
if (excludes == null) {
setExcludes("java.*, javax.*, sun.*, com.sun.*");
}
return excludes;
}
static String excludesString() {
StringBuffer buffer = new StringBuffer();
for (String pattern : excludes()) {
buffer.append(pattern);
buffer.append(",");
}
return buffer.toString();
}
static void addExcludes(StepRequest request) {
for (String pattern : excludes()) {
request.addClassExclusionFilter(pattern);
}
}
static void addExcludes(MethodEntryRequest request) {
for (String pattern : excludes()) {
request.addClassExclusionFilter(pattern);
}
}
static void addExcludes(MethodExitRequest request) {
for (String pattern : excludes()) {
request.addClassExclusionFilter(pattern);
}
}
static void setExcludes(String excludeString) {
StringTokenizer t = new StringTokenizer(excludeString, " ,;");
List<String> list = new ArrayList<String>();
while (t.hasMoreTokens()) {
list.add(t.nextToken());
}
excludes = list;
}
static Method atExitMethod() {
return atExitMethod;
}
static void setAtExitMethod(Method mmm) {
atExitMethod = mmm;
}
/**
* Return a Reader cooresponding to the source of this location.
* Return null if not available.
* Note: returned reader must be closed.
*/
static BufferedReader sourceReader(Location location) {
return sourceMapper.sourceReader(location);
}
static synchronized String sourceLine(Location location, int lineNumber)
throws IOException {
if (lineNumber == -1) {
throw new IllegalArgumentException();
}
try {
String fileName = location.sourceName();
Iterator<SourceCode> iter = sourceCache.iterator();
SourceCode code = null;
while (iter.hasNext()) {
SourceCode candidate = iter.next();
if (candidate.fileName().equals(fileName)) {
code = candidate;
iter.remove();
break;
}
}
if (code == null) {
BufferedReader reader = sourceReader(location);
if (reader == null) {
throw new FileNotFoundException(fileName);
}
code = new SourceCode(fileName, reader);
if (sourceCache.size() == SOURCE_CACHE_SIZE) {
sourceCache.remove(sourceCache.size() - 1);
}
}
sourceCache.add(0, code);
return code.sourceLine(lineNumber);
} catch (AbsentInformationException e) {
throw new IllegalArgumentException();
}
}
/** 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)});
}
}
/** Convert a long to a hexadecimal string. */
static String toHex(long n) {
char s1[] = new char[16];
char s2[] = new char[18];
/* Store digits in reverse order. */
int i = 0;
do {
long d = n & 0xf;
s1[i++] = (char)((d < 10) ? ('0' + d) : ('a' + d - 10));
} while ((n >>>= 4) > 0);
/* Now reverse the array. */
s2[0] = '0';
s2[1] = 'x';
int j = 2;
while (--i >= 0) {
s2[j++] = s1[i];
}
return new String(s2, 0, j);
}
/** Convert hexadecimal strings to longs. */
static long fromHex(String hexStr) {
String str = hexStr.startsWith("0x") ?
hexStr.substring(2).toLowerCase() : hexStr.toLowerCase();
if (hexStr.length() == 0) {
throw new NumberFormatException();
}
long ret = 0;
for (int i = 0; i < str.length(); i++) {
int c = str.charAt(i);
if (c >= '0' && c <= '9') {
ret = (ret * 16) + (c - '0');
} else if (c >= 'a' && c <= 'f') {
ret = (ret * 16) + (c - 'a' + 10);
} else {
throw new NumberFormatException();
}
}
return ret;
}
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;
}
static Set<String> getSaveKeys() {
return savedValues.keySet();
}
static Value getSavedValue(String key) {
return savedValues.get(key);
}
static void setSavedValue(String key, Value value) {
savedValues.put(key, value);
}
static class SourceCode {
private String fileName;
private List<String> sourceLines = new ArrayList<String>();
SourceCode(String fileName, BufferedReader reader) throws IOException {
this.fileName = fileName;
try {
String line = reader.readLine();
while (line != null) {
sourceLines.add(line);
line = reader.readLine();
}
} finally {
reader.close();
}
}
String fileName() {
return fileName;
}
String sourceLine(int number) {
int index = number - 1; // list is 0-indexed
if (index >= sourceLines.size()) {
return null;
} else {
return sourceLines.get(index);
}
}
}
}