diff options
| -rw-r--r-- | dev-java/bsf/ChangeLog | 8 | ||||
| -rw-r--r-- | dev-java/bsf/bsf-2.3.0-r1.ebuild | 62 | ||||
| -rw-r--r-- | dev-java/bsf/files/bsf-rhino-1.5.patch | 1941 | ||||
| -rw-r--r-- | dev-java/bsf/files/digest-bsf-2.3.0-r1 | 1 |
4 files changed, 2011 insertions, 1 deletions
diff --git a/dev-java/bsf/ChangeLog b/dev-java/bsf/ChangeLog index e5244a093287..7e92c79ac337 100644 --- a/dev-java/bsf/ChangeLog +++ b/dev-java/bsf/ChangeLog @@ -1,6 +1,12 @@ # ChangeLog for dev-java/bsf # Copyright 2000-2004 Gentoo Foundation; Distributed unde the GPL v2 -# $Header: /var/cvsroot/gentoo-x86/dev-java/bsf/ChangeLog,v 1.2 2004/06/24 22:19:09 agriffis Exp $ +# $Header: /var/cvsroot/gentoo-x86/dev-java/bsf/ChangeLog,v 1.3 2004/08/01 16:18:26 karltk Exp $ + +*bsf-2.3.0-r1 01 Aug 2004 + + 01 Aug 2004; Karl Trygve Kalleberg <karltk@gentoo.org> + Added support for jython and rhino useflags. Fixes #55934, thanks to Howard B. + Golden <howard_b_golden@yahoo.com>. *bsf-2.3.0 (27 Apr 2004) diff --git a/dev-java/bsf/bsf-2.3.0-r1.ebuild b/dev-java/bsf/bsf-2.3.0-r1.ebuild new file mode 100644 index 000000000000..4b8471964c58 --- /dev/null +++ b/dev-java/bsf/bsf-2.3.0-r1.ebuild @@ -0,0 +1,62 @@ +# Copyright 1999-2004 Gentoo Foundation +# Distributed under the terms of the GNU General Public License v2 +# $Header: /var/cvsroot/gentoo-x86/dev-java/bsf/bsf-2.3.0-r1.ebuild,v 1.1 2004/08/01 16:18:26 karltk Exp $ + +inherit java-pkg eutils + +DESCRIPTION="Bean Script Framework" +HOMEPAGE="http://jakarta.apache.org/bsf/" +SRC_URI="http://cvs.apache.org/dist/jakarta/bsf/v2.3.0rc1/src/bsf-src-2.3.0.tar.gz" +LICENSE="Apache-1.1" +SLOT="2.3" +KEYWORDS="~x86" +IUSE="doc jython rhino" +# karltk: Is this really an RDEPEND, or just a CDEPEND? +RDEPEND="=net-www/tomcat-5*" +DEPEND="${REPEND} + jython? ( >=dev-java/jython-2.1 ) + rhino? ( >=dev-java/rhino-1.4 ) + >=dev-java/ant-1.5.4" + +src_unpack() { + unpack ${A} + + epatch ${FILESDIR}/bsf-rhino-1.5.patch + + cd ${S}/src/build/lib + java-pkg_jar-from rhino || die "Missing rhino" + java-pkg_jar-from jython || die "Missing jython" +} + +src_compile() { + # This ebuild is sensitive to the system classpath, so we need to start with a + # pristine one. + export CLASSPATH= + + # karltk: this is dirty. should be fixed when we overhaul tomcat + # and the entire servlet/java server pages system + local cp=/opt/tomcat/common/lib/servlet-api.jar + cp="${cp}:/opt/tomcat/common/lib/jsp-api.jar" + + + cp="${cp}:$(java-config -p rhino)" + cp="${cp}:$(java-config -p jython)" + + local antflags= + + # karltk: fix this +# use jikes && antflags="${antflags} -Dbuild.compiler=jikes" + + cd src + export CLASSPATH=${cp} + ant ${antflags} compile || die + if use doc ; then + ant ${antflags} javadocs || die + fi +} + +src_install() { + java-pkg_dojar src/build/lib/bsf.jar + + use doc && dohtml -r src/build/javadocs/* +} diff --git a/dev-java/bsf/files/bsf-rhino-1.5.patch b/dev-java/bsf/files/bsf-rhino-1.5.patch new file mode 100644 index 000000000000..3dcc41f369d2 --- /dev/null +++ b/dev-java/bsf/files/bsf-rhino-1.5.patch @@ -0,0 +1,1941 @@ +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/CompilationUnit.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/CompilationUnit.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/CompilationUnit.java 2002-11-12 23:28:54.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/CompilationUnit.java 2004-07-07 21:12:16.131818792 -0600 +@@ -74,7 +74,7 @@ + * of script is sliced into compilation units. + * For instance, the script text may contain a function + * declaration and an expression to eval. The compilation +- * will result in two compilation units: the function and ++ * will result in two compilation units: the function and + * the expression. Each compilation unit will correspond + * to a range of the lines of the original script compiled. + * All line numbers are global to the document the compiled +@@ -82,89 +82,95 @@ + * It is on compilation units that breakpoints can be set + * or removed, more exactly on the DebuggableScript attached + * to them. See Rhino for more details. +- * ++ * + * @author: Olivier Gruber. +- */ ++ */ + public class CompilationUnit { + +- FnOrScript m_fnOrScript; +- int m_firstLine; +- int m_lineCount; +- String m_fnName; +- DebuggableScript m_dbgScript; +- int m_validBrkptLines[]; +- +- /** +- * CompilationUnit constructor comment. +- */ +- public CompilationUnit(FnOrScript fnOrScript, DebuggableScript dbgScript) { +- +- int lastLine, lineno; +- +- m_fnOrScript = fnOrScript; +- m_dbgScript = dbgScript; +- +- try { +- m_validBrkptLines = dbgScript.getLineNumbers(); +- m_firstLine = 99999; +- lastLine = 0; +- for (int l = 0; l < m_validBrkptLines.length; l++) { +- lineno = m_validBrkptLines[l]; +- if (m_firstLine > lineno) +- m_firstLine = lineno; +- if (lastLine < lineno) +- lastLine = lineno; +- } +- m_lineCount = lastLine - m_firstLine + 1; +- } catch (Throwable t) { +- DebugLog.stderrPrintln("\nWarning: can't get valid line numbers for breakpoints.", DebugLog.BSF_LOG_L2); +- m_validBrkptLines = null; +- } +- +- Scriptable scriptable = dbgScript.getScriptable(); +- if (scriptable instanceof NativeFunction) { +- NativeFunction f = (NativeFunction) scriptable; +- String name = f.getFunctionName(); +- if (name.length() > 0 && !name.equals("anonymous")) { +- m_fnName = name; +- } +- } +- } +- //---------------------------------------------------------- +- boolean contains(int lineno) { +- return (m_firstLine <= lineno && lineno < m_firstLine + m_lineCount); +- } +- /** +- * Returns true if the compilation unit contains +- * the breakpoint. +- * Notice only breakpoint defined at a line number +- * are supported here. +- */ +- boolean contains(BreakPoint bp) { +- try { +- return contains(bp.getLineNo()); +- } catch (BSFException ex) { +- return false; +- } +- } +- /** +- * Propagates (i.e. set) this breakpoint to the underlying Rhino +- * engine if Rhino has provided us with the valid lines +- * information. Otherwise, Rhino crashes with a NullPointerException. +- */ +- void propagate(int lineno) { +- if (m_validBrkptLines != null) { +- m_dbgScript.placeBreakpoint(lineno); +- } +- } +- /** +- * Unpropagates (i.e. unset) this breakpoint to the underlying Rhino +- * engine if Rhino has provided us with the valid lines +- * information. Otherwise, Rhino crashes with a NullPointerException. +- */ +- void unpropagate(int lineno) { +- if (m_validBrkptLines != null) { +- m_dbgScript.removeBreakpoint(lineno); +- } +- } ++ FnOrScript m_fnOrScript; ++ int m_firstLine; ++ int m_lineCount; ++ String m_fnName; ++ DebuggableScript m_dbgScript; ++ boolean[] m_breakpoints; ++ ++ /** ++ * CompilationUnit constructor comment. ++ */ ++ public CompilationUnit(FnOrScript fnOrScript, DebuggableScript dbgScript) { ++ ++ m_fnOrScript = fnOrScript; ++ m_dbgScript = dbgScript; ++ ++ int[] lines = dbgScript.getLineNumbers(); ++ if (lines.length != 0) { ++ int lastLine; ++ m_firstLine = lines[0]; ++ lastLine = m_firstLine; ++ for (int i = 1; i != lines.length; ++i) { ++ int lineno = lines[i]; ++ if (m_firstLine > lineno) { ++ m_firstLine = lineno; ++ } else if (lastLine < lineno) { ++ lastLine = lineno; ++ } ++ } ++ m_lineCount = lastLine - m_firstLine + 1; ++ m_breakpoints = new boolean[m_lineCount]; ++ } ++ ++ String name = dbgScript.getFunctionName(); ++ if (name != null && name.length() != 0 && !name.equals("anonymous")) { ++ m_fnName = name; ++ } ++ } ++ //---------------------------------------------------------- ++ boolean contains(int lineno) { ++ return (m_firstLine <= lineno && lineno < m_firstLine + m_lineCount); ++ } ++ /** ++ * Returns true if the compilation unit contains ++ * the breakpoint. ++ * Notice only breakpoint defined at a line number ++ * are supported here. ++ */ ++ boolean contains(BreakPoint bp) { ++ try { ++ return contains(bp.getLineNo()); ++ } catch (BSFException ex) { ++ return false; ++ } ++ } ++ /** ++ * Set a breakpoint at the given line if Rhino has provided us with the ++ * valid lines information. ++ */ ++ void propagate(int lineno) { ++ if (m_breakpoints != null) { ++ int i = lineno - m_firstLine; ++ if (0 <= i && i < m_lineCount) { ++ m_breakpoints[i] = true; ++ } ++ } ++ } ++ /** ++ * Clear a breakpoint at the given line if Rhino has provided us with the ++ * valid lines information. ++ */ ++ void unpropagate(int lineno) { ++ if (m_breakpoints != null) { ++ int i = lineno - m_firstLine; ++ if (0 <= i && i < m_lineCount) { ++ m_breakpoints[i] = false; ++ } ++ } ++ } ++ ++ boolean hasBreakpoint(int lineno) { ++ if (m_breakpoints != null) { ++ int i = lineno - m_firstLine; ++ return 0 <= i && i < m_lineCount && m_breakpoints[i]; ++ } ++ return false; ++ } + } +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/FnOrScript.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/FnOrScript.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/FnOrScript.java 2002-11-12 23:28:54.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/FnOrScript.java 2004-07-07 21:12:16.132818640 -0600 +@@ -71,25 +71,25 @@ + * This class represents a function or script, that is, + * a piece of a document that is provided to the JavaScript + * engine for evaluation, execution, or simply compilation. +- * ++ * + * A FnOrScript represents a range of lines or characters +- * in its document. For now, Rhino only supports ranges ++ * in its document. For now, Rhino only supports ranges + * of lines, really, but the code for offsets is there anyway. + * + * Warning: Offsets have never been quite tested yet... +- * ++ * + * A FnOrScript has compilation units. When Rhino compiles + * a function or a script, even in interpreted mode where the + * compilation is done to JavaScript bytecode, it calls back +- * its debugger with different compilation units; see ++ * its debugger with different compilation units; see + * Debugger::handleCompilationDone method on the RhinoEngineDebugger + * class. + * + * A FnOrScript also keeps track of the known breakpoints + * in its range of lines or characters. It makes sure +- * that they are propagated to the underlying Rhino ++ * that they are propagated to the underlying Rhino + * engine (i.e. set) as well as unpropagated (i.e. unset). +- * ++ * + * @author: Olivier Gruber + */ + public class FnOrScript { +@@ -103,9 +103,11 @@ + + protected StringBuffer m_text; + +- protected Vector m_units; // of CompilationUnit. + protected Script m_script; + ++ private Vector m_units; // of CompilationUnit. ++ private Hashtable m_functionToUnit; ++ + protected Hashtable m_functionMap; + + public FnOrScript(DocumentCell cell) { +@@ -116,8 +118,9 @@ + m_lineCount = 0; + m_breakpoints = new Vector(); + m_text = new StringBuffer(); +- ++ + m_units = new Vector(); ++ m_functionToUnit = new Hashtable(); + m_functionMap = new Hashtable(); + } + +@@ -131,7 +134,7 @@ + + m_breakpoints.addElement(bp); + +- // now, look for a unit containing it and ++ // now, look for a unit containing it and + // if one is found, set the breakpoint unit + // and propagate... + Enumeration e; +@@ -147,7 +150,7 @@ + } + return bp; + } +- ++ + private BreakPoint _removeBreakpoint(int brkptId) { + Enumeration e; + BreakPoint bp; +@@ -173,13 +176,13 @@ + bp = (BreakPoint) e.nextElement(); + if (bpid == bp.getId()) { + m_breakpoints.removeElement(bp); +- bp.unpropagate(); ++ bp.unpropagate(); + return bp; + } + } + return null; + } +- ++ + boolean contains(BreakPoint bp) throws BSFException { + if (m_lineDefined) { + int line = bp.getLineNo(); +@@ -194,7 +197,7 @@ + // This protected method works as a factory + // for language-specific breakpoints. + // The default behavior is to use the provided +- // generic breakpoint. ++ // generic breakpoint. + // See javascript for an example of language-specific + // breakpoints. + +@@ -360,17 +363,18 @@ + + public void addCompilationUnit(Context cx, + DebuggableScript dbgScript, +- StringBuffer source) { ++ String source) { + + CompilationUnit unit; + + unit = new CompilationUnit(this, dbgScript); + m_units.addElement(unit); ++ m_functionToUnit.put(dbgScript, unit); + if (unit.m_fnName != null) { + m_functionMap.put(unit.m_fnName, unit); + } + +- // Associate breakpoints to this unit if ++ // Associate breakpoints to this unit if + // the unit contains them... + Enumeration e; + BreakPoint bp; +@@ -383,13 +387,17 @@ + propagateAll(); + } + ++ CompilationUnit getCompilationUnit(DebuggableScript dbgScript) { ++ return (CompilationUnit)m_functionToUnit.get(dbgScript); ++ } ++ + public void compile(Context cx, Scriptable global) + throws BSFException, IOException { + + Enumeration e; + Reader reader = new StringReader(m_text.toString()); + m_script = +- cx.compileReader(global, reader, m_cell.getName(), ++ cx.compileReader(global, reader, m_cell.getName(), + m_startLine, null); + if (m_script == null) + throw new BSFException("Compilation of the script " +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JavaScriptEngine.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JavaScriptEngine.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JavaScriptEngine.java 2002-11-12 23:28:54.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JavaScriptEngine.java 2004-07-07 21:12:16.133818488 -0600 +@@ -104,7 +104,7 @@ + public void disconnectedDebuggerNotify() { + m_rhinoDbg.disconnectedDebuggerNotify(); + } +- ++ + BSFDebugManagerImpl getDebugManager() { + return dbgmgr; + } +@@ -114,7 +114,7 @@ + m_rhinoDbg.placeBreakpointAtLine(brkptid, docname, lineno); + } + +- public void placeBreakpointAtOffset(int brkptid, String docname, ++ public void placeBreakpointAtOffset(int brkptid, String docname, + int offset) throws BSFException { + m_rhinoDbg.placeBreakpointAtOffset(brkptid, docname, offset); + } +@@ -140,7 +140,6 @@ + public Object call(Object object, String method, Object[] args) + throws BSFException { + Object theReturnValue = null; +- DebuggableEngine engine; + Context cx; + try { + +@@ -160,13 +159,12 @@ + + cx.setOptimizationLevel(-1); + +- engine = cx.getDebuggableEngine(); +- engine.setDebugger(m_rhinoDbg); ++ cx.setDebugger(m_rhinoDbg, new RhinoContextProxy(m_rhinoDbg)); + +- theReturnValue = ScriptRuntime.call(cx, fun, global, args, ++ theReturnValue = ScriptRuntime.call(cx, fun, global, args, + null); + +- } ++ } + else { + cx.setOptimizationLevel(-1); + +@@ -175,10 +173,9 @@ + + cx.setOptimizationLevel(0); + +- engine = cx.getDebuggableEngine(); +- engine.setDebugger(null); ++ cx.setDebugger(null, null); + +- theReturnValue = ScriptRuntime.call(cx, fun, global, args, ++ theReturnValue = ScriptRuntime.call(cx, fun, global, args, + null); + } + if (theReturnValue instanceof Wrapper) { +@@ -193,9 +190,15 @@ + } + + public void declareBean(BSFDeclaredBean bean) throws BSFException { +- // Must wrap non-scriptable objects before presenting to Rhino +- Scriptable wrapped = Context.toObject(bean.bean, global); +- global.put(bean.name, global, wrapped); ++ if ((bean.bean instanceof Number) || ++ (bean.bean instanceof String) || ++ (bean.bean instanceof Boolean)) { ++ global.put(bean.name, global, bean.bean); ++ } else { ++ // Must wrap non-scriptable objects before presenting to Rhino ++ Scriptable wrapped = Context.toObject(bean.bean, global); ++ global.put(bean.name, global, wrapped); ++ } + } + + /** +@@ -210,7 +213,6 @@ + DocumentCell cell; + FnOrScript fnOrScript; + Script script; +- DebuggableEngine engine; + Context cx; + + try { +@@ -231,13 +233,7 @@ + + cx.setOptimizationLevel(-1); + +- engine = cx.getDebuggableEngine(); +- engine.setDebugger(m_rhinoDbg); +- +- // Muck w/ this iff someone else hasn't already got it true +- if (!engine.getBreakNextLine()) { +- engine.setBreakNextLine(cell.getEntryExit()); +- } ++ cx.setDebugger(m_rhinoDbg, new RhinoContextProxy(m_rhinoDbg)); + + fnOrScript.compile(cx, global); + m_rhinoDbg.setCompilingFnOrScript(null); +@@ -245,7 +241,7 @@ + + if (script != null) retval = script.exec(cx, global); + else retval = null; +- } ++ } + else { + cx.setOptimizationLevel(-1); + +@@ -254,11 +250,10 @@ + + cx.setOptimizationLevel(0); + +- engine = cx.getDebuggableEngine(); +- engine.setDebugger(null); ++ cx.setDebugger(null, null); + + retval = cx.evaluateString(global, scriptText, +- source, lineNo, ++ source, lineNo, + null); + } + +@@ -296,14 +291,14 @@ + // Display its stack trace as a diagnostic + target = (Throwable) value; + } +- } +- else if (t instanceof EvaluatorException || ++ } ++ else if (t instanceof EvaluatorException || + t instanceof SecurityException) { + message = t.getLocalizedMessage(); +- } ++ } + else if (t instanceof RuntimeException) { + message = "Internal Error: " + t.toString(); +- } ++ } + else if (t instanceof StackOverflowError) { + message = "Stack Overflow"; + } +@@ -313,7 +308,7 @@ + } + + //REMIND: can we recover the line number here? I think +- // Rhino does this by looking up the stack for bytecode ++ // Rhino does this by looking up the stack for bytecode + // see Context.getSourcePositionFromStack() + // but I don't think this would work in interpreted mode + +@@ -323,7 +318,7 @@ + // corrected the situation by aborting the loop and + // a long stacktrace would end up on the user's console + throw (Error) t; +- } ++ } + else { + throw new BSFException(BSFException.REASON_OTHER_ERROR, + "JavaScript Error: " + message, +@@ -333,7 +328,7 @@ + + /** + * initialize the engine. put the manager into the context -> manager +- * map hashtable too. ++ * map hashtable too. + */ + public void initialize(BSFManager mgr, String lang, Vector declaredBeans) + throws BSFException { +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JsContextStub.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JsContextStub.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JsContextStub.java 2002-11-12 23:28:54.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JsContextStub.java 2004-07-07 21:12:16.135818184 -0600 +@@ -68,235 +68,267 @@ + * @author: Administrator + */ + +-public class JsContextStub ++public class JsContextStub + extends org.apache.bsf.debug.util.Skeleton + implements JsContext { + +- RhinoContextProxy m_rcp; +- RhinoEngineDebugger m_rhinoDbg; +- DebugFrame m_frame; +- int m_frameno; +- boolean m_atBreakpoint; +- boolean m_invalid; +- +- /** +- * JsContextStub constructor comment. +- */ +- public JsContextStub(RhinoContextProxy rcp, DebugFrame frame, int frameno) +- throws RemoteException { +- super(org.apache.bsf.debug.util.DebugConstants.JS_CONTEXT_TID); +- +- m_rhinoDbg = rcp.getRhinoEngineDebugger(); +- m_rcp = rcp; +- m_frame = frame; +- m_frameno = frameno; +- m_invalid = false; +- m_atBreakpoint = true; +- } +- //-------------------------------------------------- +- void atBreakpoint(boolean atbrkpt) { +- m_atBreakpoint = atbrkpt; +- } +- public JsObject bind(String id) throws RemoteException { +- try { +- Context.enter(); +- Scriptable obj = m_frame.getVariableObject(); +- Object prop; +- while (obj != null) { +- Scriptable m = obj; +- do { +- if (m.has(id, obj)) +- return m_rhinoDbg.marshallScriptable(obj); +- m = m.getPrototype(); +- } while (m != null); +- obj = obj.getParentScope(); +- } +- throw new JsdiException("Name not in scope."); +- } finally { +- Context.exit(); +- } +- } +- //-------------------------------------------------- +- public JsCode getCode() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get the code."); +- +- try { +- Context.enter(); +- return null; +- } finally { +- Context.exit(); +- } +- } +- public int getDepth() { +- return m_frameno; +- } +- //-------------------------------------------------- +- public JsEngine getEngine() { +- RhinoEngineDebugger redbg; +- redbg = m_rcp.getRhinoEngineDebugger(); +- return (JsEngine) redbg.getDebugInterface(); +- +- } +- //-------------------------------------------------- +- public int getLineNumber() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- return m_frame.getLineNumber(); +- } finally { +- Context.exit(); +- } +- } +- //------------------------------------------------------ +- public JsObject getScope() throws RemoteException { +- +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- Scriptable varobj = m_frame.getVariableObject(); +- JsObject scope = m_rhinoDbg.marshallScriptable(varobj); +- return scope; +- } finally { +- Context.exit(); +- } +- } +- //------------------------------------------------------ +- public String getSourceName() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- return m_frame.getSourceName(); +- } finally { +- Context.exit(); +- } +- } +- //------------------------------------------------------ +- public JsObject getThis() throws RemoteException { +- +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- JsObject thisobj = null; +- Scriptable obj = null; +- NativeCall call = null; +- Scriptable varobj = m_frame.getVariableObject(); +- if (varobj instanceof NativeCall) { +- call = (NativeCall) varobj; +- obj = call.getThisObj(); +- thisobj = m_rhinoDbg.marshallScriptable(varobj); +- } +- return thisobj; +- } finally { +- Context.exit(); +- } +- } +- //-------------------------------------------------- +- void invalidate() { +- m_invalid = true; +- } +- //------------------------------------------------------ +- public boolean isEvalContext() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- return false; +- } finally { +- Context.exit(); +- } +- } +- //------------------------------------------------------ +- public boolean isFunctionContext() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- +- try { +- Context.enter(); +- return false; +- } finally { +- Context.exit(); +- } +- } +- //------------------------------------------------------ +- public boolean isScriptContext() { +- if (m_invalid) +- throw new JsdiException("This context no longer exists."); +- if (!m_atBreakpoint) +- throw new JsdiException("Resumed context, can't get line number."); +- try { +- Context.enter(); +- return true; +- } finally { +- Context.exit(); +- } +- } +- public Object lookupName(String name) { +- +- try { +- Context.enter(); +- Scriptable obj = m_frame.getVariableObject(); +- Object prop; +- while (obj != null) { +- Scriptable m = obj; +- do { +- Object result = m.get(name, obj); +- if (result != Scriptable.NOT_FOUND) +- return result; +- m = m.getPrototype(); +- } while (m != null); +- obj = obj.getParentScope(); +- } +- throw new JsdiException("Name is not in scope."); +- } finally { +- Context.exit(); +- } +- } +- /** +- * Looks up a name in the scope chain and returns its value. +- */ +- public Object lookupName(Scriptable scopeChain, String id) { +- +- try { +- Context.enter(); +- Scriptable obj = scopeChain; +- Object prop; +- while (obj != null) { +- Scriptable m = obj; +- do { +- Object result = m.get(id, obj); +- if (result != Scriptable.NOT_FOUND) +- return result; +- m = m.getPrototype(); +- } while (m != null); +- obj = obj.getParentScope(); +- } +- return null; +- } finally { +- Context.exit(); +- } +- } ++ RhinoContextProxy m_rcp; ++ RhinoEngineDebugger m_rhinoDbg; ++ int m_frameno; ++ int m_lineno; ++ boolean m_atBreakpoint; ++ boolean m_invalid; ++ ++ CompilationUnit m_unit; ++ Scriptable m_variableObject; ++ Scriptable m_thisObj; ++ ++ /** ++ * JsContextStub constructor comment. ++ */ ++ JsContextStub(RhinoContextProxy rcp, CompilationUnit unit) ++ throws RemoteException { ++ super(org.apache.bsf.debug.util.DebugConstants.JS_CONTEXT_TID); ++ ++ m_rhinoDbg = rcp.getRhinoEngineDebugger(); ++ m_rcp = rcp; ++ m_unit = unit; ++ m_invalid = false; ++ m_atBreakpoint = true; ++ } ++ ++ DebugFrame getRhinoDebugFrame() { ++ return new RhinoDebugFrame(this); ++ } ++ ++ //-------------------------------------------------- ++ void atBreakpoint(boolean atbrkpt) { ++ m_atBreakpoint = atbrkpt; ++ } ++ public JsObject bind(String id) throws RemoteException { ++ try { ++ Context.enter(); ++ Scriptable obj = m_variableObject; ++ Object prop; ++ while (obj != null) { ++ Scriptable m = obj; ++ do { ++ if (m.has(id, obj)) ++ return m_rhinoDbg.marshallScriptable(obj); ++ m = m.getPrototype(); ++ } while (m != null); ++ obj = obj.getParentScope(); ++ } ++ throw new JsdiException("Name not in scope."); ++ } finally { ++ Context.exit(); ++ } ++ } ++ //-------------------------------------------------- ++ public JsCode getCode() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get the code."); ++ ++ try { ++ Context.enter(); ++ return null; ++ } finally { ++ Context.exit(); ++ } ++ } ++ public int getDepth() { ++ return m_frameno; ++ } ++ //-------------------------------------------------- ++ public JsEngine getEngine() { ++ RhinoEngineDebugger redbg; ++ redbg = m_rcp.getRhinoEngineDebugger(); ++ return (JsEngine) redbg.getDebugInterface(); ++ ++ } ++ //-------------------------------------------------- ++ public int getLineNumber() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ return m_lineno; ++ } ++ //------------------------------------------------------ ++ public JsObject getScope() throws RemoteException { ++ ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ try { ++ Context.enter(); ++ JsObject scope = m_rhinoDbg.marshallScriptable(m_variableObject); ++ return scope; ++ } finally { ++ Context.exit(); ++ } ++ } ++ //------------------------------------------------------ ++ public String getSourceName() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ return m_unit.m_dbgScript.getSourceName(); ++ } ++ //------------------------------------------------------ ++ public JsObject getThis() throws RemoteException { ++ ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ try { ++ Context.enter(); ++ JsObject thisobj = null; ++ Scriptable obj = null; ++ NativeCall call = null; ++ Scriptable varobj = m_variableObject; ++ if (varobj instanceof NativeCall) { ++ call = (NativeCall) varobj; ++ obj = call.getThisObj(); ++ thisobj = m_rhinoDbg.marshallScriptable(varobj); ++ } ++ return thisobj; ++ } finally { ++ Context.exit(); ++ } ++ } ++ //-------------------------------------------------- ++ void invalidate() { ++ m_invalid = true; ++ } ++ //------------------------------------------------------ ++ public boolean isEvalContext() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ try { ++ Context.enter(); ++ return false; ++ } finally { ++ Context.exit(); ++ } ++ } ++ //------------------------------------------------------ ++ public boolean isFunctionContext() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ ++ try { ++ Context.enter(); ++ return false; ++ } finally { ++ Context.exit(); ++ } ++ } ++ //------------------------------------------------------ ++ public boolean isScriptContext() { ++ if (m_invalid) ++ throw new JsdiException("This context no longer exists."); ++ if (!m_atBreakpoint) ++ throw new JsdiException("Resumed context, can't get line number."); ++ try { ++ Context.enter(); ++ return true; ++ } finally { ++ Context.exit(); ++ } ++ } ++ public Object lookupName(String name) { ++ ++ try { ++ Context.enter(); ++ Scriptable obj = m_variableObject; ++ Object prop; ++ while (obj != null) { ++ Scriptable m = obj; ++ do { ++ Object result = m.get(name, obj); ++ if (result != Scriptable.NOT_FOUND) ++ return result; ++ m = m.getPrototype(); ++ } while (m != null); ++ obj = obj.getParentScope(); ++ } ++ throw new JsdiException("Name is not in scope."); ++ } finally { ++ Context.exit(); ++ } ++ } ++ /** ++ * Looks up a name in the scope chain and returns its value. ++ */ ++ public Object lookupName(Scriptable scopeChain, String id) { ++ ++ try { ++ Context.enter(); ++ Scriptable obj = scopeChain; ++ Object prop; ++ while (obj != null) { ++ Scriptable m = obj; ++ do { ++ Object result = m.get(id, obj); ++ if (result != Scriptable.NOT_FOUND) ++ return result; ++ m = m.getPrototype(); ++ } while (m != null); ++ obj = obj.getParentScope(); ++ } ++ return null; ++ } finally { ++ Context.exit(); ++ } ++ } ++} ++ ++class RhinoDebugFrame implements DebugFrame { ++ ++ JsContextStub m_stub; ++ ++ RhinoDebugFrame(JsContextStub stub) { ++ m_stub = stub; ++ } ++ ++ public void onEnter(Context cx, Scriptable activation, ++ Scriptable thisObj, Object[] args) ++ { ++ m_stub.m_variableObject = activation; ++ m_stub.m_thisObj = thisObj; ++ m_stub.m_frameno = m_stub.m_rcp.m_frameStack.size(); ++ m_stub.m_rcp.m_frameStack.push(m_stub); ++ } ++ ++ public void onExit(Context cx, boolean byThrow, Object resultOrException) ++ { ++ m_stub.m_rcp.m_frameStack.pop(); ++ m_stub.invalidate(); ++ } ++ ++ public void onExceptionThrown(Context cx, Throwable ex) { ++ m_stub.m_rcp.m_reDbg.handleExceptionThrown(cx, m_stub.m_rcp, ex); ++ } ++ ++ public void onLineChange(Context cx, int lineNumber) { ++ m_stub.m_lineno = lineNumber; ++ if (m_stub.m_unit.hasBreakpoint(lineNumber)) { ++ m_stub.m_rcp.m_reDbg.handleBreakpointHit(cx, m_stub.m_rcp); ++ } ++ } + } +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JsEngineStub.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JsEngineStub.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/JsEngineStub.java 2002-11-12 23:28:54.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/JsEngineStub.java 2004-07-07 21:12:16.135818184 -0600 +@@ -62,38 +62,37 @@ + import org.apache.bsf.debug.jsdi.*; + import org.mozilla.javascript.Context; + import org.mozilla.javascript.Script; +-import org.mozilla.javascript.debug.DebuggableEngine; + + /** + * Insert the type's description here. + * Creation date: (9/6/2001 1:21:46 PM) + * @author: Administrator + */ +-public class JsEngineStub ++public class JsEngineStub + extends org.apache.bsf.debug.util.Skeleton + implements JsEngine { + + RhinoEngineDebugger m_rhinoDbg; + boolean m_inCallback; + boolean m_resumeExecution; +- Object m_lock; +- ++ Object m_lock; ++ + /** + * JsEngineStub constructor comment. + */ +- public JsEngineStub(RhinoEngineDebugger rhinoDbg) ++ public JsEngineStub(RhinoEngineDebugger rhinoDbg) + throws RemoteException { + super(org.apache.bsf.debug.util.DebugConstants.JS_ENGINE_TID); + m_rhinoDbg = rhinoDbg; + m_lock = new Object(); + } +- ++ + public boolean isSuspended() throws RemoteException { + return m_inCallback; + } +- ++ + public boolean poll() { return true; } +- ++ + public Object eval(String docname, String exp, int lineNo) + throws RemoteException { + +@@ -125,7 +124,7 @@ + try { + Context.enter(); + count = m_rhinoDbg.getContextCount(); +- DebugLog.stdoutPrintln(" count = "+count, ++ DebugLog.stdoutPrintln(" count = "+count, + DebugLog.BSF_LOG_L3); + return count; + } finally { +@@ -133,7 +132,7 @@ + } + + } +- ++ + public String getThread() throws RemoteException { + return m_rhinoDbg.getThread(); + } +@@ -203,7 +202,7 @@ + public void stepIn() throws RemoteException { + try { + Context.enter(); +- DebugLog.stdoutPrintln("Step In command on "+this, ++ DebugLog.stdoutPrintln("Step In command on "+this, + DebugLog.BSF_LOG_L3); + m_rhinoDbg.stepIn(this); + } catch (Exception ex) { +@@ -225,7 +224,6 @@ + } + + public void stepOver() throws RemoteException { +- RhinoContextProxy rcp; + try { + Context.enter(); + m_rhinoDbg.stepOver(this); +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/RhinoContextProxy.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/RhinoContextProxy.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/RhinoContextProxy.java 2002-11-12 23:28:53.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/RhinoContextProxy.java 2004-07-07 21:12:16.136818032 -0600 +@@ -70,133 +70,107 @@ + + import java.rmi.RemoteException; + +-public class RhinoContextProxy { ++class RhinoContextProxy { + + RhinoEngineDebugger m_reDbg; +- Context m_context; +- JsContextStub m_contextStub; + +- DebuggableEngine m_engine; +- +- boolean m_atBreakpoint; +- int m_frameCount; +- JsContextStub m_frames[]; ++ ObjArray m_frameStack = new ObjArray(); + + private static final int NO_STEP = 0, STEP_IN = 1, STEP_OVER = 2, + STEP_OUT = 3, STOP_ENGINE = 4, RUNNING = 5; + + private int m_stepCmd, m_stepDepth; + +- RhinoContextProxy(RhinoEngineDebugger reDbg, Context cx) { ++ RhinoContextProxy(RhinoEngineDebugger reDbg) { + m_reDbg = reDbg; +- m_context = cx; +- m_engine = cx.getDebuggableEngine(); + } + +- public void cancelStepping() { ++ static RhinoContextProxy getCurrent() { ++ Context cx = Context.getCurrentContext(); ++ if (cx == null) { return null; } ++ return (RhinoContextProxy)cx.getDebuggerContextData(); ++ } ++ ++ void cancelStepping() { + m_stepCmd = NO_STEP; + m_stepDepth = -1; +- m_engine.setBreakNextLine(false); + } + +- public JsContextStub getContext(int depth) { +- return m_frames[depth]; ++ int getContextCount() { ++ return m_frameStack.size(); + } + +- public int getContextCount() { +- return m_frameCount; ++ JsContextStub getContextStub(int no) { ++ if (!(0 <= no && no < m_frameStack.size())) { return null; } ++ return (JsContextStub)m_frameStack.get(no); + } + +- public JsContextStub getFrame(int no) { +- if (no < 0 || no > m_frameCount) +- return null; +- if (no == m_frameCount) +- return m_contextStub; +- else +- return m_frames[no]; ++ JsContextStub getTopContextStub() { ++ return getContextStub(m_frameStack.size() - 1); + } + +- public int getLineNumber() { +- DebugFrame frame = m_engine.getFrame(0); +- +- return frame.getLineNumber(); ++ int getLineNumber() { ++ JsContextStub stub = getTopContextStub(); ++ return stub.m_lineno; + } + +- public RhinoEngineDebugger getRhinoEngineDebugger() { ++ RhinoEngineDebugger getRhinoEngineDebugger() { + return m_reDbg; + } + + String getSourceName() { +- DebugFrame frame = m_engine.getFrame(0); +- +- return frame.getSourceName(); ++ JsContextStub stub = getTopContextStub(); ++ return stub.m_unit.m_dbgScript.getSourceName(); + } + +- + // We hit a known breakpoint. + // We need to update the stack. + // Also, cancel any pending stepping operation. +- public JsContextStub hitBreakpoint() throws RemoteException { ++ JsContextStub hitBreakpoint() throws RemoteException { + cancelStepping(); +- updateStack(); +- return m_frames[0]; ++ return getTopContextStub(); + } + +- +- public JsContextStub exceptionThrown() throws RemoteException { ++ JsContextStub exceptionThrown() throws RemoteException { + cancelStepping(); +- updateStack(); +- return m_frames[0]; ++ return getTopContextStub(); + } + +- public void resumed() { +- JsContextStub stub; +- DebugFrame frame; +- +- m_atBreakpoint = false; +- +- for (int f = 0; f < m_frameCount; f++) { +- stub = m_frames[f]; +- stub.atBreakpoint(false); ++ void resumed() { ++ for (int f = 0, N = getContextCount(); f != N; ++f) { ++ getContextStub(f).atBreakpoint(false); + } + } + +- public void run() { +- m_engine.setBreakNextLine(false); ++ void run() { + m_stepCmd = RUNNING; + m_stepDepth = -1; +- + } + +- public void stepIn() { +- m_engine.setBreakNextLine(true); ++ void stepIn() { + m_stepCmd = STEP_IN; +- m_stepDepth = m_frameCount; ++ m_stepDepth = getContextCount(); + } + +- public void stepOut() { +- m_engine.setBreakNextLine(true); ++ void stepOut() { + m_stepCmd = STEP_OUT; +- m_stepDepth = m_frameCount; +- ++ m_stepDepth = getContextCount(); + } + +- public void stepOver() { +- m_engine.setBreakNextLine(true); ++ void stepOver() { + m_stepCmd = STEP_OVER; +- m_stepDepth = m_frameCount; ++ m_stepDepth = getContextCount(); + } + +- public JsContextStub entry_exit_mode() throws RemoteException { ++ JsContextStub entry_exit_mode() throws RemoteException { + cancelStepping(); +- updateStack(); +- return m_frames[0]; ++ return getTopContextStub(); + } + +- public JsContextStub stepping() { ++ JsContextStub stepping() { + // Did we hit a known breakpoint? + +- int frameCount = m_engine.getFrameCount(); ++ int frameCount = getContextCount(); + + try { + switch (m_stepCmd) { +@@ -204,39 +178,31 @@ + cancelStepping(); + break; + case STOP_ENGINE : +- updateStack(); + cancelStepping(); +- return m_frames[0]; ++ return getTopContextStub(); + case STEP_IN : +- // OG if ((frameCount == m_stepDepth + 1) || ++ // OG if ((frameCount == m_stepDepth + 1) || + // (frameCount == m_stepDepth)) { + // step if we are in the same frame (nothing to step in... :-) + // if we are in a called frame... + // but also if we stepped out of the current frame... +- if ((frameCount >= m_stepDepth) +- || (frameCount < m_stepDepth)) { +- updateStack(); + cancelStepping(); +- return m_frames[0]; +- } +- break; ++ return getTopContextStub(); + case STEP_OVER : + // OG if (frameCount == m_stepDepth) { + // step if we are in the same frame or above... +- // this basically avoids any children frame but ++ // this basically avoids any children frame but + // covers the return of the current frame. + if (frameCount <= m_stepDepth) { +- updateStack(); + cancelStepping(); +- return m_frames[0]; ++ return getTopContextStub(); + } + break; + case STEP_OUT : + // OG if (frameCount == m_stepDepth - 1) { + if (frameCount < m_stepDepth) { +- updateStack(); + cancelStepping(); +- return m_frames[0]; ++ return getTopContextStub(); + } + break; + default : +@@ -249,55 +215,8 @@ + return null; + } + +- public void stopEngine() { +- m_engine.setBreakNextLine(true); ++ void stopEngine() { + m_stepCmd = STOP_ENGINE; + m_stepDepth = -1; + } +- +- public void updateStack() throws RemoteException { +- JsContextStub frames[]; +- JsContextStub stub; +- DebugFrame frame; +- int nf, of, frameCount; +- +- m_atBreakpoint = true; +- +- frameCount = m_engine.getFrameCount(); +- frames = new JsContextStub[frameCount]; +- +- // scan the stacks from the outer frame down +- // to the inner one of the shortest of the old +- // and the new known stack. +- // The goal is to recognize the DebugFrame objects +- // that are the sames so that we can reuse the +- // stubs for those. +- // As soon as a DebugFrame object is found different, +- // the rest of the stack is different, all the old +- // stubs can be dropped and invalidated, new ones +- // must be created. +- +- for (nf = frameCount - 1, of = m_frameCount - 1; +- nf >= 0 && of >= 0; +- nf--, of--) { +- frame = m_engine.getFrame(nf); +- if (frame == m_frames[of].m_frame) { +- frames[nf] = m_frames[of]; +- } else +- break; +- } +- // now drop all old frames that diverged. +- // Also invalidate the frame stubs so to +- // tracked that they are no longer valid. +- for (; of >= 0; of--) { +- m_reDbg.dropStub(m_frames[of].m_frame); +- m_frames[of].invalidate(); +- } +- for (; nf >= 0; nf--) { +- frame = m_engine.getFrame(nf); +- frames[nf] = new JsContextStub(this, frame, nf); +- } +- m_frames = frames; +- m_frameCount = frameCount; +- } + } +diff -urN bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/RhinoEngineDebugger.java bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/RhinoEngineDebugger.java +--- bsf-2.3.0/src/bsf/src/org/apache/bsf/engines/javascript/RhinoEngineDebugger.java 2002-11-12 23:28:55.000000000 -0700 ++++ bsf-2.3.0.patched/src/bsf/src/org/apache/bsf/engines/javascript/RhinoEngineDebugger.java 2004-07-07 21:12:16.138817728 -0600 +@@ -74,24 +74,23 @@ + import org.apache.bsf.debug.*; + import org.apache.bsf.debug.jsdi.*; + +-public class RhinoEngineDebugger implements Debugger { ++class RhinoEngineDebugger implements Debugger { + + /** The global script object, where all embedded functions are defined, + * as well as the standard ECMA "core" objects. +- */ ++ */ + private Scriptable global; + private JsObject globalstub; + +- private RhinoContextProxy m_rcp; + private Scriptable undefined; + private JsObject undefinedStub; + +- /** ++ /** + * Hashtable allowing to find the stub for an object in the JavaScript + * environment if one exists. + * Typically: Scriptable, Function, Script, etc. + * This is not used for Context and DebugFrame. +- * They typically contains JsObject associated to ++ * They typically contains JsObject associated to + * org.mozilla.javascript.ScriptableObject + */ + private Hashtable stubs; +@@ -102,16 +101,13 @@ + private FnOrScript m_compilingFnOrScript; + private JavaScriptEngine m_eng; + +- private Thread m_thread; +- + private Hashtable m_documents; + + BSFDebugManagerImpl dbgmgr; + +- public RhinoEngineDebugger(JavaScriptEngine eng) ++ RhinoEngineDebugger(JavaScriptEngine eng) + throws RemoteException { + super(); +- m_thread = Thread.currentThread(); + m_eng = eng; + dbgmgr = eng.getDebugManager(); + +@@ -127,45 +123,37 @@ + /** + * Called when our debugger has been disconnected. + */ +- public void disconnectedDebuggerNotify() { ++ void disconnectedDebuggerNotify() { + m_callbacks = null; + } + +- void addStub(Context cx, RhinoContextProxy jscx) { +- stubs.put(cx, jscx); +- } +- +- void addStub(DebugFrame frame, JsContextStub stub) { +- stubs.put(frame, stub); +- } +- + void addStub(Scriptable sobj, JsObject jsobj) { + stubs.put(sobj, jsobj); + } + +- void dropStub(Object key) { ++ void dropStub(Scriptable key) { + stubs.remove(key); + } + +- public synchronized DocumentCell getDocumentCell(String name) { ++ synchronized DocumentCell getDocumentCell(String name) { + return (DocumentCell) m_documents.get(name); + } + + // Called upon creation of a BSFManager. +- public synchronized DocumentCell loadDocumentNotify(String name) { ++ synchronized DocumentCell loadDocumentNotify(String name) { + DocumentCell cell; + + cell = (DocumentCell) m_documents.get(name); + if (cell == null) { + cell = new DocumentCell(this, name); + m_documents.put(name, cell); +- if (dbgmgr!=null) ++ if (dbgmgr!=null) + dbgmgr.loadDocumentNotify(m_eng, name); + } + return cell; + } + +- public synchronized void placeBreakpointAtLine(int brkptid, ++ synchronized void placeBreakpointAtLine(int brkptid, + String docname, + int lineno) { + +@@ -174,7 +162,7 @@ + cell.addBreakpointAtLine(brkptid, lineno); + } + +- public synchronized void placeBreakpointAtOffset(int brkptid, ++ synchronized void placeBreakpointAtOffset(int brkptid, + String docname, + int offset) { + +@@ -183,7 +171,7 @@ + cell.addBreakpointAtOffset(brkptid, offset); + } + +- public void removeBreakpoint(String docname, int brkptid) ++ void removeBreakpoint(String docname, int brkptid) + throws BSFException { + + DocumentCell cell; +@@ -191,7 +179,7 @@ + cell.removeBreakpoint(brkptid); + } + +- public void setEntryExit(String docname, boolean on) ++ void setEntryExit(String docname, boolean on) + throws BSFException { + + DocumentCell cell; +@@ -199,7 +187,7 @@ + cell.setEntryExit(on); + } + +- public Object eval(String docname, String fnOrScript, int lineno) ++ Object eval(String docname, String fnOrScript, int lineno) + throws RemoteException { + Object retval; + try { +@@ -210,13 +198,15 @@ + } + } + +- public JsContext getContext(int depth) { +- if (m_rcp != null) return m_rcp.getContext(depth); ++ JsContext getContext(int depth) { ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ if (rcp != null) return rcp.getContextStub(depth); + return null; + } + +- public int getContextCount() { +- if (m_rcp != null) return m_rcp.getContextCount(); ++ int getContextCount() { ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ if (rcp != null) return rcp.getContextCount(); + return -1; + } + +@@ -224,24 +214,20 @@ + * Return the current debugger. + * @return the debugger, or null if none is attached. + */ +- public JsCallbacks getDebugger() { ++ JsCallbacks getDebugger() { + return m_callbacks; + } + +- public Object getDebugInterface() { ++ Object getDebugInterface() { + return engineStub; + } + +- public JsObject getGlobalObject() { ++ JsObject getGlobalObject() { + return globalstub; + } + +- public RhinoContextProxy getRhinoContextProxy() { +- return m_rcp; +- } +- + RhinoContextProxy getStub(Context cx) { +- return (RhinoContextProxy) stubs.get(cx); ++ return (RhinoContextProxy)cx.getDebuggerContextData(); + } + + JsContextStub getStub(DebugFrame frame) { +@@ -252,19 +238,20 @@ + return (JsObject) stubs.get(sobj); + } + +- public JsObject getUndefinedValue() { ++ JsObject getUndefinedValue() { + return undefinedStub; + } + +- public String getThread() { ++ String getThread() { ++ Context cx = Context.getCurrentContext(); + String resultstr = ""; + +- if (m_thread != null) { ++ if (cx != null) { + try { + final String resultstrf = (String) + AccessController.doPrivileged(new PrivilegedExceptionAction() { + public Object run() throws Exception { +- return m_thread.getName(); ++ return Thread.currentThread().getName(); + } + }); + resultstr = resultstrf; +@@ -277,15 +264,17 @@ + return resultstr; + } + +- public String getThreadGroup() { ++ String getThreadGroup() { ++ Context cx = Context.getCurrentContext(); + String resultstr = ""; + +- if (m_thread != null) { ++ if (cx != null) { + try { + final String resultstrf = (String) + AccessController.doPrivileged(new PrivilegedExceptionAction() { + public Object run() throws Exception { +- return m_thread.getThreadGroup().getName(); ++ return Thread.currentThread().getThreadGroup(). ++ getName(); + } + }); + resultstr = resultstrf; +@@ -305,7 +294,7 @@ + // to implement STEP_IN, STEP_OUT, and STEP_OVER. + //--------------------------------------------------------- + +- public void handleBreakpointHit(Context cx) { ++ void handleBreakpointHit(Context cx, RhinoContextProxy rcp) { + JsCallbacks debugger; + BreakPoint bp; + Enumeration e; +@@ -313,48 +302,41 @@ + boolean breakpointFound=false; + String name; + int lineno; +- boolean suspend=false; +- +- m_thread = Thread.currentThread(); +- DebugLog.stdoutPrintln("**** Handling a breakpoint hit...", ++ ++ DebugLog.stdoutPrintln("**** Handling a breakpoint hit...", + DebugLog.BSF_LOG_L3); +- m_rcp = getStub(cx); +- if (m_rcp == null) { +- m_rcp = new RhinoContextProxy(this, cx); +- addStub(cx, m_rcp); +- } +- // if we have no callbacks... then just ++ // if we have no callbacks... then just + // ignore the breakpoint hit, do a run + // so that execution resumes... + if (m_callbacks==null) { +- DebugLog.stdoutPrintln(" No callbacks, resuming...", DebugLog.BSF_LOG_L3); +- m_rcp.run(); ++ DebugLog.stdoutPrintln(" No callbacks, resuming...", DebugLog.BSF_LOG_L3); ++ rcp.run(); + + } else { + // First, check that we didn't hit a known breakpoint. + // First, search if we have breakpoints for the current documents + +- name = m_rcp.getSourceName(); +- lineno = m_rcp.getLineNumber(); ++ name = rcp.getSourceName(); ++ lineno = rcp.getLineNumber(); + +- DebugLog.stdoutPrintln(" in "+name+" at "+lineno, DebugLog.BSF_LOG_L3); ++ DebugLog.stdoutPrintln(" in "+name+" at "+lineno, DebugLog.BSF_LOG_L3); + + cell = getDocumentCell(name); +- if (cell != null) +- _handleBreakpointHit(cell,lineno); +- } +- m_rcp = null; ++ if (cell != null) ++ _handleBreakpointHit(rcp,cell,lineno); ++ } + } + +- public void _handleBreakpointHit(DocumentCell cell, int lineno) { +- ++ void _handleBreakpointHit(RhinoContextProxy rcp, ++ DocumentCell cell, int lineno) ++ { + JsCallbacks debugger; + BreakPoint bp; + Enumeration e; + JsContext stub=null; + boolean breakpointFound=false; + boolean suspend=false; +- ++ + try { + bp = cell.findBreakpointAtLine(lineno); + } catch (BSFException bsfex) { +@@ -363,19 +345,19 @@ + if (bp != null) { + breakpointFound = true; + try { +- stub = m_rcp.hitBreakpoint(); +- DebugLog.stdoutPrintln(" breakpoint callback...", DebugLog.BSF_LOG_L3); +- m_callbacks.createFuture(m_rcp); ++ stub = rcp.hitBreakpoint(); ++ DebugLog.stdoutPrintln(" breakpoint callback...", DebugLog.BSF_LOG_L3); ++ m_callbacks.createFuture(rcp); + m_callbacks.handleBreakpointHit(stub); + suspend = true; + } catch (RemoteException rex) { +- DebugLog.stderrPrintln(" EXCEPTION OCCURED DURING BREAKPOINT CALLBACK", DebugLog.BSF_LOG_L0); ++ DebugLog.stderrPrintln(" EXCEPTION OCCURED DURING BREAKPOINT CALLBACK", DebugLog.BSF_LOG_L0); + DebugLog.stderrPrintln(rex.getMessage(), DebugLog.BSF_LOG_L0); + rex.printStackTrace(); + suspend = false; + } + } else { +- DebugLog.stdoutPrintln(" didn't find a breakpoint...", DebugLog.BSF_LOG_L3); ++ DebugLog.stdoutPrintln(" didn't find a breakpoint...", DebugLog.BSF_LOG_L3); + breakpointFound = false; + } + +@@ -384,87 +366,107 @@ + // line in the current document, we must be stepping + // or in entry/exit mode + try { +- stub = m_rcp.stepping(); ++ stub = rcp.stepping(); + FnOrScript current = cell.findFnOrScriptContaining(lineno); + if (stub != null) { + cell.setLastFnOrScript(current); +- DebugLog.stdoutPrintln(" stepping-done callback...", ++ DebugLog.stdoutPrintln(" stepping-done callback...", + DebugLog.BSF_LOG_L3); +- m_callbacks.createFuture(m_rcp); ++ m_callbacks.createFuture(rcp); + m_callbacks.handleSteppingDone(stub); + suspend = true; +- } ++ } + else if (cell.getEntryExit() && + (current != cell.getLastFnOrScript()) && +- (m_rcp.getContextCount() == 0)) { ++ (rcp.getContextCount() == 0)) { + cell.setLastFnOrScript(current); +- stub = m_rcp.entry_exit_mode(); +- DebugLog.stdoutPrintln(" entry/exit mode...", ++ stub = rcp.entry_exit_mode(); ++ DebugLog.stdoutPrintln(" entry/exit mode...", + DebugLog.BSF_LOG_L3); +- m_callbacks.createFuture(m_rcp); ++ m_callbacks.createFuture(rcp); + m_callbacks.handleSteppingDone(stub); + suspend = true; + } + else { +- DebugLog.stdoutPrintln(" No reason to suspend execution.", DebugLog.BSF_LOG_L3); ++ DebugLog.stdoutPrintln(" No reason to suspend execution.", DebugLog.BSF_LOG_L3); + suspend = false; + } + } catch (RemoteException rex) { +- DebugLog.stderrPrintln(" EXCEPTION OCCURED DURING STEPPING-DONE CALLBACK", DebugLog.BSF_LOG_L0); ++ DebugLog.stderrPrintln(" EXCEPTION OCCURED DURING STEPPING-DONE CALLBACK", DebugLog.BSF_LOG_L0); + DebugLog.stderrPrintln(rex.getMessage(), DebugLog.BSF_LOG_L0); + rex.printStackTrace(); + suspend = false; + } + } + if (suspend) { +- // now, suspend this thread... until ++ // now, suspend this thread... until + // we restart. + try { +- m_callbacks.suspendFuture(m_rcp); ++ m_callbacks.suspendFuture(rcp); + } catch (Exception ex) { + DebugLog.stdoutPrintln("Future creation failed... releasing the engine", DebugLog.BSF_LOG_L3); +- m_rcp.run(); ++ rcp.run(); + } +- } ++ } + } + +- public void run(JsEngineStub eng) throws Exception { ++ void run(JsEngineStub eng) throws Exception { + DebugLog.stdoutPrintln("RhinoEngineDebugger::run()...", + DebugLog.BSF_LOG_L3); +- m_rcp.run(); +- m_callbacks.completeFuture(m_rcp); ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ rcp.run(); ++ m_callbacks.completeFuture(rcp); + } + +- public void stepIn(JsEngineStub eng) throws Exception { ++ void stepIn(JsEngineStub eng) throws Exception { + DebugLog.stdoutPrintln("RhinoEngineDebugger::stepIn()...", + DebugLog.BSF_LOG_L3); +- m_rcp.stepIn(); +- m_callbacks.completeFuture(m_rcp); ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ rcp.stepIn(); ++ m_callbacks.completeFuture(rcp); + } + +- public void stepOut(JsEngineStub eng) throws Exception { ++ void stepOut(JsEngineStub eng) throws Exception { + DebugLog.stdoutPrintln("RhinoEngineDebugger::stepOut()...", + DebugLog.BSF_LOG_L3); +- m_rcp.stepOut(); +- m_callbacks.completeFuture(m_rcp); ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ rcp.stepOut(); ++ m_callbacks.completeFuture(rcp); + } +- public void stepOver(JsEngineStub eng) throws Exception { ++ void stepOver(JsEngineStub eng) throws Exception { + + DebugLog.stdoutPrintln("RhinoEngineDebugger::stepOver()...", + DebugLog.BSF_LOG_L3); +- m_rcp.stepOver(); +- m_callbacks.completeFuture(m_rcp); ++ RhinoContextProxy rcp = RhinoContextProxy.getCurrent(); ++ rcp.stepOver(); ++ m_callbacks.completeFuture(rcp); + } +- ++ + public void handleCompilationDone(Context cx, + DebuggableScript fnOrScript, +- StringBuffer source) { ++ String source) { + +- m_thread = Thread.currentThread(); + m_compilingFnOrScript.addCompilationUnit(cx, fnOrScript, source); + } + +- public void handleExceptionThrown(Context cx, Object exceptionThrown) { ++ public DebugFrame getFrame(Context cx, DebuggableScript fnOrScript) { ++ CompilationUnit unit; ++ unit = m_compilingFnOrScript.getCompilationUnit(fnOrScript); ++ RhinoContextProxy rcp = getStub(cx); ++ try { ++ JsContextStub stub = new JsContextStub(rcp, unit); ++ return stub.getRhinoDebugFrame(); ++ } catch (RemoteException rex) { ++ DebugLog.stderrPrintln(" EXCEPTION OCCURED DURING FRAME INITIALIZATION", DebugLog.BSF_LOG_L0); ++ DebugLog.stderrPrintln(rex.getMessage(), DebugLog.BSF_LOG_L0); ++ rex.printStackTrace(); ++ return null; ++ } ++ } ++ ++ void handleExceptionThrown(Context cx, RhinoContextProxy rcp, ++ Throwable exceptionThrown) ++ { + JsContext stub; + JsCallbacks debugger; + BreakPoint bp; +@@ -473,53 +475,40 @@ + String name,msg; + Exception ex; + int lineno; +- NativeError error; +- +- m_thread = Thread.currentThread(); +- m_rcp = getStub(cx); +- if (m_rcp == null) { +- m_rcp = new RhinoContextProxy(this, cx); +- addStub(cx, m_rcp); ++ ++ // if we have no callbacks... then just ++ // ignore the breakpoint hit, do a run ++ // so that execution resumes... ++ if (m_callbacks==null) { ++ rcp.run(); ++ return; + } +- try { +- // if we have no callbacks... then just +- // ignore the breakpoint hit, do a run +- // so that execution resumes... +- if (m_callbacks==null) { +- m_rcp.run(); +- return; +- } + +- // First, check that we didn't hit a known breakpoint. +- // First, search if we have breakpoints for the current documents +- name = m_rcp.getSourceName(); +- lineno = m_rcp.getLineNumber(); +- try { +- error = (NativeError)exceptionThrown; +- msg = error.getName() + ": " + error.getMessage(); +- } catch (ClassCastException ccex) { +- msg = "Unknown JavaScript Exception"; +- } +- ex = new Exception(msg); ++ // First, check that we didn't hit a known breakpoint. ++ // First, search if we have breakpoints for the current documents ++ name = rcp.getSourceName(); ++ lineno = rcp.getLineNumber(); ++ if (exceptionThrown instanceof EcmaError) { ++ msg = ((EcmaError)exceptionThrown).getErrorObject().toString(); ++ } else { ++ msg = exceptionThrown.toString(); ++ } ++ ex = new Exception(msg); + +- cell = getDocumentCell(name); +- if (cell == null) return; ++ cell = getDocumentCell(name); ++ if (cell == null) return; + +- try { +- stub = m_rcp.exceptionThrown(); +- m_callbacks.createFuture(m_rcp); +- m_callbacks.handleExceptionThrown(stub,ex); +- +- // now, suspend this thread... until +- // we restart. +- m_callbacks.suspendFuture(m_rcp); +- +- } catch (Exception ex2) { +- m_rcp.run(); +- +- } +- } finally { +- m_rcp = null; ++ try { ++ stub = rcp.exceptionThrown(); ++ m_callbacks.createFuture(rcp); ++ m_callbacks.handleExceptionThrown(stub,ex); ++ ++ // now, suspend this thread... until ++ // we restart. ++ m_callbacks.suspendFuture(rcp); ++ ++ } catch (Exception ex2) { ++ rcp.run(); + } + } + +@@ -568,10 +557,10 @@ + * The engine will call the attached debugger's handleBreakpointHit + * method on the next line it executes if isLineStep is true. + * May be used from another thread to interrupt execution. +- * ++ * + * @param isLineStep if true, break next line + */ +- public void setBreakNextLine(JsContext context, boolean isLineStep) { ++ void setBreakNextLine(JsContext context, boolean isLineStep) { + } + + void setCompilingFnOrScript(FnOrScript fnOrScript) { +@@ -583,7 +572,7 @@ + * @param debugger the debugger to be used on callbacks from + * the engine. + */ +- public void setDebugger(JsCallbacks debugger) { ++ void setDebugger(JsCallbacks debugger) { + m_callbacks = debugger; + } + } diff --git a/dev-java/bsf/files/digest-bsf-2.3.0-r1 b/dev-java/bsf/files/digest-bsf-2.3.0-r1 new file mode 100644 index 000000000000..08400115fb0b --- /dev/null +++ b/dev-java/bsf/files/digest-bsf-2.3.0-r1 @@ -0,0 +1 @@ +MD5 78bae3747ca5734bb7554eed6868b7da bsf-src-2.3.0.tar.gz 1035181 |