package org.eclipse.dltk.rhino.dbgp;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Observable;
import java.util.Observer;
import java.util.WeakHashMap;
import org.mozilla.javascript.Context;
import org.mozilla.javascript.Function;
import org.mozilla.javascript.NativeArray;
import org.mozilla.javascript.NativeJavaArray;
import org.mozilla.javascript.NativeJavaClass;
import org.mozilla.javascript.NativeJavaObject;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;
import org.mozilla.javascript.Undefined;
import org.mozilla.javascript.UniqueTag;
import org.mozilla.javascript.Wrapper;
import org.mozilla.javascript.debug.DebugFrame;
import org.mozilla.javascript.debug.DebuggableScript;
import org.mozilla.javascript.debug.Debugger;
import org.mozilla.javascript.debug.IDeguggerWithWatchPoints;
import org.mozilla.javascript.xml.XMLObject;
public class DBGPDebugger extends Thread
implements Debugger, Observer, IDeguggerWithWatchPoints {
private Socket socket;
private OutputStream out;
private HashMap strategies = new HashMap();
HashMap properties = new HashMap();
String runTransctionId;
static abstract class Command {
abstract void parseAndExecute(String command, HashMap options);
}
private static void writeResponseLength(OutputStream out, int value)
throws IOException {
out.write(String.valueOf(value).getBytes());
}
void printResponse(String response) {
try {
byte[] bytes = response.getBytes("UTF-8"); //$NON-NLS-1$
writeResponseLength(out, bytes.length);
out.write(0);
out.write(bytes, 0, bytes.length);
out.write(0);
out.flush();
} catch (IOException e) {
try {
socket.close();
} catch (IOException e2) {
// ignore
}
}
}
DBGPStackManager stackmanager;
public boolean isInited;
public void setContext(Context cx) {
DBGPStackManager manager = DBGPStackManager.getManager(cx);
manager.setDebugger(this);
this.stackmanager = manager;
}
public DBGPDebugger(Socket socket, String file, String string, Context ct)
throws IOException {
super();
this.socket = socket;
stackmanager = DBGPStackManager.getManager(ct);
stackmanager.suspend();
out = new BufferedOutputStream(socket.getOutputStream(), 2048);
stackmanager.setDebugger(this);
String response = "<init appid=\"APPID\"\r\n" + " idekey=\""
+ string + "\"\r\n" + " session=\"" + string + "\"\r\n"
+ " thread=\"THREAD_ID\"\r\n"
+ " parent=\"PARENT_APPID\"\r\n"
+ " language=\"javascript\"\r\n"
+ " protocol_version=\"1.0\"\r\n"
+ " fileuri=\"file://" + file + "\"\r\n" + "/>";
printResponse(response);
strategies.put("feature_get", new FeatureGetCommand(this));
strategies.put("feature_set", new FeatureSetCommand(this));
strategies.put("stdin", new StdInCommand(this));
strategies.put("stdout", new StdOutCommand(this));
strategies.put("stderr", new StdErrCommand(this));
strategies.put("run", new RunCommand(this));
strategies.put("context_names", new ContextNamesCommand(this));
strategies.put("stop", new StopCommand(this));
strategies.put("step_over", new StepOverCommand(this));
strategies.put("step_into", new StepIntoCommand(this));
strategies.put("step_out", new StepOutCommand(this));
strategies.put("breakpoint_get", new GetBreakPointCommand(this));
strategies.put("breakpoint_set", new SetBreakPointCommand(this));
strategies.put("breakpoint_remove", new RemoveBreakPointCommand(this));
strategies.put("breakpoint_update", new UpdateBreakPointCommand(this));
strategies.put("context_get", new ContextGetCommand(this));
strategies.put("property_set", new PropertySetCommand(this));
strategies.put("eval", new EvalCommand(this));
strategies.put("property_get", new PropertyGetCommand(this));
strategies.put("break", new BreakCommand(this));
strategies.put("stack_depth", new StackDepthCommand(this));
strategies.put("stack_get", new StackGetCommand(this));
}
protected void printProperty(String id, String fullName, Object value,
StringBuffer properties, int level, boolean addChilds) {
boolean hasChilds = false;
int numC = 0;
String vlEncoded;
String name_of_object_class = "";
String data_type = getDataType(value);
if (value instanceof Scriptable) {
hasChilds = true;
StringBuffer stringBuffer = new StringBuffer();
Scriptable p = (Scriptable) value;
value = stringBuffer;
String nv = p.getClassName();
name_of_object_class = nv;
if (p instanceof NativeJavaObject) {
NativeJavaObject obj = (NativeJavaObject) p;
Object unwrap = obj.unwrap();
if (unwrap instanceof Class) {
nv = ((Class) unwrap).getName();
} else if (unwrap.getClass().isArray()) {
nv = "Array";
// String string = unwrap.getClass().getName();
// int len = Array.getLength(unwrap);
// int q = string.indexOf('[');
// if (q != -1)
// string = string.substring(0, q);
// int q1 = string.indexOf(']');
// nv = string + "[" + len + "]";
// if (q1 != -1)
// nv += string.substring(q1);
} else {
if (unwrap instanceof String) {
nv = "JavaString " + '"' + unwrap.toString() + '"';
} else {
String string = unwrap.toString();
nv = string;
// nv = unwrap.getClass().getName() + "(" + string +
// ")";
}
}
} else if (p instanceof Wrapper) {
Wrapper wrapper = (Wrapper) p;
Object wrapped = wrapper.unwrap();
if (wrapped == null) {
nv = "Undefined";
} else if (!wrapped.getClass().isArray()) {
// if it is an array let the normal array handling do the
// job
// now just do toString();
nv = wrapped.toString();
}
} else if (p instanceof XMLObject) {
nv = ((XMLObject) p).toString();
data_type = "XML";
}
stringBuffer.append(Base64Helper.encodeString(nv));
if (addChilds) {
HashSet duplicates = new HashSet();
Scriptable prototype = p;
while (prototype != null) {
numC += createChilds(fullName, level, stringBuffer,
prototype, duplicates);
prototype = prototype.getPrototype();
}
} else {
HashSet duplicates = new HashSet();
Scriptable prototype = p;
while (prototype != null) {
Object[] ids = null;
if (prototype instanceof LazyInitScope) {
ids = ((LazyInitScope) prototype).getInitializedIds();
} else {
ids = prototype.getIds();
}
for (int a = 0; a < ids.length; a++) {
if (!duplicates.add(ids[a]))
continue;
Object pvalue = null;
try {
if (ids[a] instanceof Integer) {
pvalue = p.get(((Integer) ids[a]).intValue(),
p);
} else
pvalue = p.get(ids[a].toString(), p);
} catch (Exception e) {
// dont let the debugger crash.
e.printStackTrace();
}
if (!(pvalue instanceof Function)) // HACK because
// ShowFunctionsAction
// doesnt work because of
// the lazy behavior of
// plugins in Eclipse
{
numC++;
}
}
prototype = prototype.getPrototype();
}
}
vlEncoded = stringBuffer.toString();
} else {
if (!(value instanceof Undefined)) {
if (value == UniqueTag.NOT_FOUND) {
vlEncoded = "";
} else
vlEncoded = Base64Helper.encodeString(
value != null ? value.toString() : "null");
} else {
vlEncoded = Base64Helper.encodeString("Undefined");
}
if (value != null)
name_of_object_class = value.getClass().getName();
}
id = escapeHTML(id);
fullName = escapeHTML(fullName);
properties.append("<property\r\n" + " name=\"" + id + "\"\r\n"
+ " fullname=\"" + fullName + "\"\r\n" + " type=\""
+ data_type + "\"\r\n" + " classname=\""
+ name_of_object_class + "\"\r\n" + " constant=\"0\"\r\n"
+ " children=\"" + (hasChilds ? 1 : 0) + "\"\r\n"
+ " encoding=\"base64\"\r\n" + " numchildren=\"" + numC
+ "\">\r\n" + vlEncoded + "</property>\r\n");
}
private static String escapeHTML(String content) {
content = replace(content, '&', "&"); //$NON-NLS-1$
content = replace(content, '"', """); //$NON-NLS-1$
content = replace(content, '<', "<"); //$NON-NLS-1$
return replace(content, '>', ">"); //$NON-NLS-1$
}
private static String replace(String text, char c, String s) {
int previous = 0;
int current = text.indexOf(c, previous);
if (current == -1)
return text;
StringBuffer buffer = new StringBuffer();
while (current > -1) {
buffer.append(text.substring(previous, current));
buffer.append(s);
previous = current + 1;
current = text.indexOf(c, previous);
}
buffer.append(text.substring(previous));
return buffer.toString();
}
/**
* @param fullName
* @param level
* @param stringBuffer
* @param p
* @param ids
*/
private int createChilds(String fullName, int level,
StringBuffer stringBuffer, Scriptable p, HashSet duplicates) {
Object[] ids = null;
if (p instanceof LazyInitScope) {
ids = ((LazyInitScope) p).getInitializedIds();
} else if (p instanceof ScriptableObject && !(p instanceof XMLObject)
&& !(p instanceof NativeArray)) {
ids = ((ScriptableObject) p).getAllIds();
} else {
ids = p.getIds();
}
int counter = 0;
for (int a = 0; a < ids.length; a++) {
if (!duplicates.add(ids[a]))
continue;
Object pvalue = null;
try {
if (ids[a] instanceof Integer) {
pvalue = p.get(((Integer) ids[a]).intValue(), p);
} else
pvalue = p.get(ids[a].toString(), p);
} catch (Throwable e) {
// dont let the debugger crash.
e.printStackTrace();
}
if (!(pvalue instanceof Function)) // HACK because
// ShowFunctionsAction
// doesnt work because of the lazy
// behavior of plugins in Eclipse
{
counter++;
if (ids[a] instanceof Integer) {
printProperty(ids[a].toString(),
fullName + "[" + ids[a] + "]", pvalue, stringBuffer,
level + 1, false);
} else {
printProperty(ids[a].toString(), fullName + "." + ids[a],
pvalue, stringBuffer, level + 1, false);
}
}
}
return counter;
}
private String getDataType(Object value) {
String data_type = "Object";
if (value instanceof Function) {
data_type = "function";
} else if (value instanceof NativeJavaArray) {
data_type = "javaarray";
} else if (value instanceof NativeArray) {
data_type = "array";
} else if (value instanceof NativeJavaObject) {
data_type = "javaobject";
} else if (value instanceof NativeJavaClass) {
data_type = "javaclass";
} else if (value instanceof String) {
data_type = "string";
} else if (value instanceof Number) {
data_type = "number";
} else if (value instanceof Boolean) {
data_type = "boolean";
} else if (value instanceof Date) {
data_type = "date";
} else if (value instanceof Undefined || value == null) {
data_type = "undefined";
} else if (value instanceof Wrapper) {
return getDataType(((Wrapper) value).unwrap());
}
return data_type;
}
@Override
public void run() {
try {
DataInputStream ds = new DataInputStream(socket.getInputStream());
StringBuffer buf = new StringBuffer();
Context.enter();
while (ds.available() >= 0) {
int c = ds.read();
if (c < 0)
break;
if (c < 32) {
String s = buf.toString();
int indexOf = s.indexOf(' ');
if (indexOf != -1)
{
String commandId = buf.substring(0, indexOf);
Command object = (Command) strategies.get(commandId);
if (object == null) {
System.err.println(commandId);
continue;
}
HashMap options = new HashMap();
String result = buf.substring(indexOf + 1);
String[] split = result.split(" ");
try {
for (int a = 0; a < split.length; a++) {
options.put(split[a], split[++a]);
}
} catch (Exception e) {
}
object.parseAndExecute(result, options);
}
buf = new StringBuffer();
} else {
buf.append((char) c);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public DebugFrame getFrame(Context cx, DebuggableScript fnOrScript) {
return new DBGPDebugFrame(cx, fnOrScript, this);
}
@Override
public void handleCompilationDone(Context cx, DebuggableScript fnOrScript,
String source) {
}
@Override
public void update(Observable arg0, Object arg1) {
if (runTransctionId != null)
printResponse("<response command=\"run\"\r\n" + "status=\"break\""
+ " reason=\"ok\"" + " transaction_id=\"" + runTransctionId
+ "\">\r\n" + "</response>\r\n" + "");
}
public void notifyEnd() {
printResponse("<response command=\"run\"\r\n" + "status=\"stopped\""
+ " reason=\"ok\"" + " transaction_id=\"" + runTransctionId
+ "\">\r\n" + "</response>\r\n" + "");
System.exit(0);
}
@Override
public void access(String property, ScriptableObject object) {
ArrayList list = (ArrayList) stackmanager.getManager()
.getWatchPoints(property);
if (list != null) {
int size = list.size();
for (int a = 0; a < size; a++) {
BreakPoint watchPoint = (BreakPoint) list.get(a);
if (watchPoint != null) {
if (watchPoint.enabled)
if (watchPoint.isAccess) {
String wkey = watchPoint.file + watchPoint.line;
String s = (String) cache.get(object);
if ((s != null) && (s.equals(wkey))) {
stackmanager.getObserver().update(null, this);
stackmanager.waitForNotify();
}
}
}
}
}
}
WeakHashMap cache = new WeakHashMap();
@Override
public void modification(String property, ScriptableObject object) {
ArrayList list = (ArrayList) stackmanager.getManager()
.getWatchPoints(property);
if (list != null && stackmanager.getStackDepth() > 0) {
int size = list.size();
for (int a = 0; a < size; a++) {
BreakPoint watchPoint = (BreakPoint) list.get(a);
if (watchPoint != null) {
if (watchPoint.enabled) {
String sn = stackmanager.getStackFrame(0)
.getSourceName();
int ln = stackmanager.getStackFrame(0).getLineNumber();
String key = sn + ln;
String wkey = watchPoint.file + watchPoint.line;
if (key.equals(wkey)) {
cache.put(object, wkey);
}
if (watchPoint.isModification) {
Object object2 = cache.get(object);
if (object2 != null)
if (object2.equals(wkey)) {
stackmanager.getObserver().update(null,
this);
synchronized (this.stackmanager) {
try {
this.stackmanager.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}
}
}
public void setProperty(String name, String value) {
}
public void setSuspendOnExit(boolean parseBoolean) {
stackmanager.setSuspendOnExit(parseBoolean);
}
public void setSuspendOnEntry(boolean parseBoolean) {
stackmanager.setSuspendOnEntry(parseBoolean);
}
}