Attachment #34975: Same patch as in previous message, only for the actual package, not CVS for bug #55934

 * will result in two compilation units: the function and 

 * will result in two compilation units: the function and

 * 

 *

 */ 

 */

	FnOrScript m_fnOrScript;

    FnOrScript m_fnOrScript;

	int m_firstLine;

    int m_firstLine;

	int m_lineCount;

    int m_lineCount;

	String m_fnName;

    String m_fnName;

	DebuggableScript m_dbgScript;

    DebuggableScript m_dbgScript;

	int m_validBrkptLines[];

    boolean[] m_breakpoints;

	/**

    /**

	 * CompilationUnit constructor comment.

     * CompilationUnit constructor comment.

	 */

     */

	public CompilationUnit(FnOrScript fnOrScript, DebuggableScript dbgScript) {

    public CompilationUnit(FnOrScript fnOrScript, DebuggableScript dbgScript) {

		int lastLine, lineno;

        m_fnOrScript = fnOrScript;

        m_dbgScript = dbgScript;

		m_fnOrScript = fnOrScript;

		m_dbgScript = dbgScript;

        int[] lines = dbgScript.getLineNumbers();

        if (lines.length != 0) {

		try {

            int lastLine;

			m_validBrkptLines = dbgScript.getLineNumbers();

            m_firstLine = lines[0];

			m_firstLine = 99999;

            lastLine = m_firstLine;

			lastLine = 0;

            for (int i = 1; i != lines.length; ++i) {

			for (int l = 0; l < m_validBrkptLines.length; l++) {

                int lineno = lines[i];

				lineno = m_validBrkptLines[l];

                if (m_firstLine > lineno) {

				if (m_firstLine > lineno)

                    m_firstLine = lineno;

					m_firstLine = lineno;

                } else if (lastLine < lineno) {

				if (lastLine < lineno)

                    lastLine = lineno;

					lastLine = lineno;

                }

			}

            }

			m_lineCount = lastLine - m_firstLine + 1;

            m_lineCount = lastLine - m_firstLine + 1;

		} catch (Throwable t) {

            m_breakpoints = new boolean[m_lineCount];

			DebugLog.stderrPrintln("\nWarning: can't get valid line numbers for breakpoints.", DebugLog.BSF_LOG_L2);

        }

			m_validBrkptLines = null;

		}

        String name = dbgScript.getFunctionName();

        if (name != null && name.length() != 0 && !name.equals("anonymous")) {

		Scriptable scriptable = dbgScript.getScriptable();

            m_fnName = name;

		if (scriptable instanceof NativeFunction) {

        }

			NativeFunction f = (NativeFunction) scriptable;

    }

			String name = f.getFunctionName();

    //----------------------------------------------------------

			if (name.length() > 0 && !name.equals("anonymous")) {

    boolean contains(int lineno) {

				m_fnName = name;

        return (m_firstLine <= lineno && lineno < m_firstLine + m_lineCount);

			}

    }

		}

    /**

	}

     * Returns true if the compilation unit contains

	//----------------------------------------------------------

     * the breakpoint.

	boolean contains(int lineno) {

     * Notice only breakpoint defined at a line number

		return (m_firstLine <= lineno && lineno < m_firstLine + m_lineCount);

     * are supported here.

	}

     */

	/**

    boolean contains(BreakPoint bp) {

	 * Returns true if the compilation unit contains

        try {

	 * the breakpoint. 

            return contains(bp.getLineNo());

	 * Notice only breakpoint defined at a line number

        } catch (BSFException ex) {

	 * are supported here.

            return false;

	 */

        }

	boolean contains(BreakPoint bp) {

    }

		try {

    /**

			return contains(bp.getLineNo());

     * Set a breakpoint at the given line if Rhino has provided us with the

		} catch (BSFException ex) {

     * valid lines information.

			return false;

     */

		}

    void propagate(int lineno) {

	}

        if (m_breakpoints != null) {

	/**

            int i = lineno - m_firstLine;

	 * Propagates (i.e. set) this breakpoint to the underlying Rhino

            if (0 <= i && i < m_lineCount) {

	 * engine if Rhino has provided us with the valid lines

                m_breakpoints[i] = true;

	 * information. Otherwise, Rhino crashes with a NullPointerException.

            }

	 */

        }

	void propagate(int lineno) {

    }

		if (m_validBrkptLines != null) {

    /**

			m_dbgScript.placeBreakpoint(lineno);

     * Clear a breakpoint at the given line if Rhino has provided us with the

		}

     * valid lines information.

	}

     */

	/**

    void unpropagate(int lineno) {

	 * Unpropagates (i.e. unset) this breakpoint to the underlying Rhino

        if (m_breakpoints != null) {

	 * engine if Rhino has provided us with the valid lines

            int i = lineno - m_firstLine;

	 * information. Otherwise, Rhino crashes with a NullPointerException.

            if (0 <= i && i < m_lineCount) {

	 */

                m_breakpoints[i] = false;

	void unpropagate(int lineno) {

            }

		if (m_validBrkptLines != null) {

        }

			m_dbgScript.removeBreakpoint(lineno);

    }

		}

	}

    boolean hasBreakpoint(int lineno) {

        if (m_breakpoints != null) {

            int i = lineno - m_firstLine;

            return 0 <= i && i < m_lineCount && m_breakpoints[i];

        }

        return false;

    }

 * 

 *

 * in its document. For now, Rhino only supports ranges 

 * in its document. For now, Rhino only supports ranges

 * 

 *

 * its debugger with different compilation units; see 

 * its debugger with different compilation units; see

 * that they are propagated to the underlying Rhino 

 * that they are propagated to the underlying Rhino

 *  

 *

        // now, look for a unit containing it and 

        // now, look for a unit containing it and

                bp.unpropagate();	

                bp.unpropagate();

    // generic breakpoint. 

    // generic breakpoint.

                                   StringBuffer source) {

                                   String source) {

        // Associate breakpoints to this unit if 

        // Associate breakpoints to this unit if

            cx.compileReader(global, reader, m_cell.getName(), 

            cx.compileReader(global, reader, m_cell.getName(),

    public void placeBreakpointAtOffset(int brkptid, String docname, 

    public void placeBreakpointAtOffset(int brkptid, String docname,

                engine = cx.getDebuggableEngine();

                cx.setDebugger(m_rhinoDbg, new RhinoContextProxy(m_rhinoDbg));

                engine.setDebugger(m_rhinoDbg);

                theReturnValue = ScriptRuntime.call(cx, fun, global, args, 

                theReturnValue = ScriptRuntime.call(cx, fun, global, args,

            } 

            }

                engine = cx.getDebuggableEngine();

                cx.setDebugger(null, null);

                engine.setDebugger(null);

                theReturnValue = ScriptRuntime.call(cx, fun, global, args, 

                theReturnValue = ScriptRuntime.call(cx, fun, global, args,

        // Must wrap non-scriptable objects before presenting to Rhino

        if ((bean.bean instanceof Number) ||

        Scriptable wrapped = Context.toObject(bean.bean, global);

            (bean.bean instanceof String) ||

        global.put(bean.name, global, wrapped);

            (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);

        }

                engine = cx.getDebuggableEngine();

                cx.setDebugger(m_rhinoDbg, new RhinoContextProxy(m_rhinoDbg));

                engine.setDebugger(m_rhinoDbg);

                // Muck w/ this iff someone else hasn't already got it true

                if (!engine.getBreakNextLine()) {

                    engine.setBreakNextLine(cell.getEntryExit());

                }

            } 

            }

                engine = cx.getDebuggableEngine();

                cx.setDebugger(null, null);

                engine.setDebugger(null);

                                           source, lineNo, 

                                           source, lineNo,

        } 

        }

        else if (t instanceof EvaluatorException || 

        else if (t instanceof EvaluatorException ||

        } 

        }

        } 

        }

        // Rhino does this by looking up the stack for bytecode 

        // Rhino does this by looking up the stack for bytecode

        } 

        }

     * map hashtable too. 

     * map hashtable too.

public class JsContextStub 

public class JsContextStub

	RhinoContextProxy m_rcp;

    RhinoContextProxy m_rcp;

	RhinoEngineDebugger m_rhinoDbg;

    RhinoEngineDebugger m_rhinoDbg;

	DebugFrame m_frame;

    int m_frameno;

	int m_frameno;

    int m_lineno;

	boolean m_atBreakpoint;

    boolean m_atBreakpoint;

	boolean m_invalid;

    boolean m_invalid;

	/**

    CompilationUnit m_unit;

	 * JsContextStub constructor comment.

    Scriptable m_variableObject;

	 */

    Scriptable m_thisObj;

	public JsContextStub(RhinoContextProxy rcp, DebugFrame frame, int frameno)

	throws RemoteException {

    /**

			super(org.apache.bsf.debug.util.DebugConstants.JS_CONTEXT_TID);

     * JsContextStub constructor comment.

     */

		m_rhinoDbg = rcp.getRhinoEngineDebugger();

    JsContextStub(RhinoContextProxy rcp, CompilationUnit unit)

		m_rcp = rcp;

    throws RemoteException {

		m_frame = frame;

        super(org.apache.bsf.debug.util.DebugConstants.JS_CONTEXT_TID);

		m_frameno = frameno;

		m_invalid = false;

        m_rhinoDbg = rcp.getRhinoEngineDebugger();

		m_atBreakpoint = true;

        m_rcp = rcp;

	}

        m_unit = unit;

	//--------------------------------------------------

        m_invalid = false;

	void atBreakpoint(boolean atbrkpt) {

        m_atBreakpoint = true;

		m_atBreakpoint = atbrkpt;

    }

	}

	public JsObject bind(String id) throws RemoteException {

    DebugFrame getRhinoDebugFrame() {

		try {

        return new RhinoDebugFrame(this);

			Context.enter();

    }

			Scriptable obj = m_frame.getVariableObject();

			Object prop;

    //--------------------------------------------------

			while (obj != null) {

    void atBreakpoint(boolean atbrkpt) {

				Scriptable m = obj;

        m_atBreakpoint = atbrkpt;

				do {

    }

					if (m.has(id, obj))

    public JsObject bind(String id) throws RemoteException {

						return m_rhinoDbg.marshallScriptable(obj);

        try {

					m = m.getPrototype();

            Context.enter();

				} while (m != null);

            Scriptable obj = m_variableObject;

				obj = obj.getParentScope();

            Object prop;

			}

            while (obj != null) {

			throw new JsdiException("Name not in scope.");

                Scriptable m = obj;

		} finally {

                do {

			Context.exit();

                    if (m.has(id, obj))

		}

                        return m_rhinoDbg.marshallScriptable(obj);

	}

                    m = m.getPrototype();

	//--------------------------------------------------

                } while (m != null);

	public JsCode getCode() {

                obj = obj.getParentScope();

		if (m_invalid)

            }

			throw new JsdiException("This context no longer exists.");

            throw new JsdiException("Name not in scope.");

		if (!m_atBreakpoint)

        } finally {

			throw new JsdiException("Resumed context, can't get the code.");

            Context.exit();

        }

		try {

    }

			Context.enter();

    //--------------------------------------------------

			return null;

    public JsCode getCode() {

		} finally {

        if (m_invalid)

			Context.exit();

            throw new JsdiException("This context no longer exists.");

		}

        if (!m_atBreakpoint)

	}

            throw new JsdiException("Resumed context, can't get the code.");

	public int getDepth() {

		return m_frameno;

        try {

	}

            Context.enter();

	//--------------------------------------------------

            return null;

	public JsEngine getEngine() {

        } finally {

		RhinoEngineDebugger redbg;

            Context.exit();

		redbg = m_rcp.getRhinoEngineDebugger();

        }

		return (JsEngine) redbg.getDebugInterface(); 

    }

    public int getDepth() {

	}

        return m_frameno;

	//--------------------------------------------------

    }

	public int getLineNumber() {

    //--------------------------------------------------

		if (m_invalid)

    public JsEngine getEngine() {

			throw new JsdiException("This context no longer exists.");

        RhinoEngineDebugger redbg;

		if (!m_atBreakpoint)

        redbg = m_rcp.getRhinoEngineDebugger();

			throw new JsdiException("Resumed context, can't get line number.");

        return (JsEngine) redbg.getDebugInterface();

		try {

    }

			Context.enter();

    //--------------------------------------------------

			return m_frame.getLineNumber();

    public int getLineNumber() {

		} finally {

        if (m_invalid)

			Context.exit();

            throw new JsdiException("This context no longer exists.");

		}

        if (!m_atBreakpoint)

	}

            throw new JsdiException("Resumed context, can't get line number.");

	//------------------------------------------------------  

	public JsObject getScope() throws RemoteException {

        return m_lineno;

    }

		if (m_invalid)

    //------------------------------------------------------

			throw new JsdiException("This context no longer exists.");

    public JsObject getScope() throws RemoteException {

		if (!m_atBreakpoint)

			throw new JsdiException("Resumed context, can't get line number.");

        if (m_invalid)

            throw new JsdiException("This context no longer exists.");

		try {

        if (!m_atBreakpoint)

			Context.enter();

            throw new JsdiException("Resumed context, can't get line number.");

			Scriptable varobj = m_frame.getVariableObject();

			JsObject scope = m_rhinoDbg.marshallScriptable(varobj);

        try {

			return scope;

            Context.enter();

		} finally {

            JsObject scope = m_rhinoDbg.marshallScriptable(m_variableObject);

			Context.exit();

            return scope;

		}

        } finally {

	}

            Context.exit();

	//------------------------------------------------------  

        }

	public String getSourceName() {

    }

		if (m_invalid)

    //------------------------------------------------------

			throw new JsdiException("This context no longer exists.");

    public String getSourceName() {

		if (!m_atBreakpoint)

        if (m_invalid)

			throw new JsdiException("Resumed context, can't get line number.");

            throw new JsdiException("This context no longer exists.");

        if (!m_atBreakpoint)

		try {

            throw new JsdiException("Resumed context, can't get line number.");

			Context.enter();

			return m_frame.getSourceName();

        return m_unit.m_dbgScript.getSourceName();

		} finally {

    }

			Context.exit();

    //------------------------------------------------------

		}

    public JsObject getThis() throws RemoteException {

	}

	//------------------------------------------------------  

        if (m_invalid)

	public JsObject getThis() throws RemoteException {

            throw new JsdiException("This context no longer exists.");

        if (!m_atBreakpoint)

		if (m_invalid)

            throw new JsdiException("Resumed context, can't get line number.");

			throw new JsdiException("This context no longer exists.");

		if (!m_atBreakpoint)

        try {

			throw new JsdiException("Resumed context, can't get line number.");

            Context.enter();

            JsObject thisobj = null;

		try {

            Scriptable obj = null;

			Context.enter();

            NativeCall call = null;

			JsObject thisobj = null;

            Scriptable varobj = m_variableObject;

			Scriptable obj = null;

            if (varobj instanceof NativeCall) {

			NativeCall call = null;

                call = (NativeCall) varobj;

			Scriptable varobj = m_frame.getVariableObject();

                obj = call.getThisObj();

			if (varobj instanceof NativeCall) {

                thisobj = m_rhinoDbg.marshallScriptable(varobj);

				call = (NativeCall) varobj;

            }

				obj = call.getThisObj();

            return thisobj;

				thisobj = m_rhinoDbg.marshallScriptable(varobj);

        } finally {

			}

            Context.exit();

			return thisobj;

        }

		} finally {

    }

			Context.exit();

    //--------------------------------------------------

		}

    void invalidate() {

	}

        m_invalid = true;

	//--------------------------------------------------

    }

	void invalidate() {

    //------------------------------------------------------

		m_invalid = true;

    public boolean isEvalContext() {

	}

        if (m_invalid)

	//------------------------------------------------------  

            throw new JsdiException("This context no longer exists.");

	public boolean isEvalContext() {

        if (!m_atBreakpoint)

		if (m_invalid)

            throw new JsdiException("Resumed context, can't get line number.");

			throw new JsdiException("This context no longer exists.");

		if (!m_atBreakpoint)

        try {

			throw new JsdiException("Resumed context, can't get line number.");

            Context.enter();

            return false;

		try {

        } finally {

			Context.enter();

            Context.exit();

			return false;

        }

		} finally {

    }

			Context.exit();

    //------------------------------------------------------

		}

    public boolean isFunctionContext() {

	}

        if (m_invalid)

	//------------------------------------------------------  

            throw new JsdiException("This context no longer exists.");

	public boolean isFunctionContext() {

        if (!m_atBreakpoint)

		if (m_invalid)

            throw new JsdiException("Resumed context, can't get line number.");

			throw new JsdiException("This context no longer exists.");

		if (!m_atBreakpoint)

        try {

			throw new JsdiException("Resumed context, can't get line number.");

            Context.enter();

            return false;

		try {

        } finally {

			Context.enter();

            Context.exit();

			return false;

        }

		} finally {

    }

			Context.exit();

    //------------------------------------------------------

		}

    public boolean isScriptContext() {

	}

        if (m_invalid)

	//------------------------------------------------------  

            throw new JsdiException("This context no longer exists.");

	public boolean isScriptContext() {

        if (!m_atBreakpoint)

		if (m_invalid)

            throw new JsdiException("Resumed context, can't get line number.");

			throw new JsdiException("This context no longer exists.");

        try {

		if (!m_atBreakpoint)

            Context.enter();

			throw new JsdiException("Resumed context, can't get line number.");

            return true;

		try {

        } finally {

			Context.enter();

            Context.exit();

			return true;

        }

		} finally {

    }

			Context.exit();

    public Object lookupName(String name) {

		}

	}

        try {

	public Object lookupName(String name) {

            Context.enter();

            Scriptable obj = m_variableObject;

		try {

            Object prop;

			Context.enter();

            while (obj != null) {

			Scriptable obj = m_frame.getVariableObject();

                Scriptable m = obj;

			Object prop;

                do {

			while (obj != null) {

                    Object result = m.get(name, obj);

				Scriptable m = obj;

                    if (result != Scriptable.NOT_FOUND)

				do {

                        return result;

					Object result = m.get(name, obj);

                    m = m.getPrototype();

					if (result != Scriptable.NOT_FOUND)

                } while (m != null);

						return result;

                obj = obj.getParentScope();

					m = m.getPrototype();

            }

				} while (m != null);

            throw new JsdiException("Name is not in scope.");

				obj = obj.getParentScope();

        } finally {

			}

            Context.exit();

			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) {

	 * Looks up a name in the scope chain and returns its value.

	 */

        try {

	public Object lookupName(Scriptable scopeChain, String id) {

            Context.enter();

            Scriptable obj = scopeChain;

		try {

            Object prop;

			Context.enter();

            while (obj != null) {

			Scriptable obj = scopeChain;

                Scriptable m = obj;

			Object prop;

                do {

			while (obj != null) {

                    Object result = m.get(id, obj);

				Scriptable m = obj;

                    if (result != Scriptable.NOT_FOUND)

				do {

                        return result;

					Object result = m.get(id, obj);

                    m = m.getPrototype();

					if (result != Scriptable.NOT_FOUND)

                } while (m != null);

						return result;

                obj = obj.getParentScope();

					m = m.getPrototype();

            }

				} while (m != null);

            return null;

				obj = obj.getParentScope();

        } finally {

			}

            Context.exit();

			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);

        }

    }

public class JsEngineStub 

public class JsEngineStub

    Object  m_lock;	

    Object  m_lock;

    public JsEngineStub(RhinoEngineDebugger rhinoDbg) 

    public JsEngineStub(RhinoEngineDebugger rhinoDbg)

            DebugLog.stdoutPrintln("	count = "+count, 

            DebugLog.stdoutPrintln("    count = "+count,

            DebugLog.stdoutPrintln("Step In command on "+this, 

            DebugLog.stdoutPrintln("Step In command on "+this,

public class RhinoContextProxy {

class RhinoContextProxy {

    DebuggableEngine m_engine;

    ObjArray m_frameStack = new ObjArray();

    boolean m_atBreakpoint;

    int m_frameCount;

    JsContextStub m_frames[];

    RhinoContextProxy(RhinoEngineDebugger reDbg, Context cx) {

    RhinoContextProxy(RhinoEngineDebugger reDbg) {

    public void cancelStepping() {

    static RhinoContextProxy getCurrent() {

        Context cx = Context.getCurrentContext();

        if (cx == null) { return null; }

        return (RhinoContextProxy)cx.getDebuggerContextData();

    }

    void cancelStepping() {

    public JsContextStub getContext(int depth) {

    int getContextCount() {

        return m_frames[depth];

        return m_frameStack.size();

    public int getContextCount() {

    JsContextStub getContextStub(int no) {

        return m_frameCount;

        if (!(0 <= no && no < m_frameStack.size())) { return null; }

        return (JsContextStub)m_frameStack.get(no);

    public JsContextStub getFrame(int no) {

    JsContextStub getTopContextStub() {

        if (no < 0 || no > m_frameCount)

        return getContextStub(m_frameStack.size() - 1);

            return null;

        if (no == m_frameCount)

            return m_contextStub;

        else

            return m_frames[no];

    public int getLineNumber() {

    int getLineNumber() {

        DebugFrame frame = m_engine.getFrame(0);

        JsContextStub stub = getTopContextStub();

        return stub.m_lineno;

        return frame.getLineNumber();

    public RhinoEngineDebugger getRhinoEngineDebugger() {

    RhinoEngineDebugger getRhinoEngineDebugger() {

        DebugFrame frame = m_engine.getFrame(0);

        JsContextStub stub = getTopContextStub();

        return stub.m_unit.m_dbgScript.getSourceName();

        return frame.getSourceName();

    public JsContextStub hitBreakpoint() throws RemoteException {

    JsContextStub hitBreakpoint() throws RemoteException {

        updateStack();

        return getTopContextStub();

        return m_frames[0];

    JsContextStub exceptionThrown() throws RemoteException {

    public JsContextStub exceptionThrown() throws RemoteException {

        updateStack();

        return getTopContextStub();

        return m_frames[0];

    public void resumed() {

    void resumed() {

        JsContextStub stub;

        for (int f = 0, N = getContextCount(); f != N; ++f) {

        DebugFrame frame;

            getContextStub(f).atBreakpoint(false);

        m_atBreakpoint = false;

        for (int f = 0; f < m_frameCount; f++) {

            stub = m_frames[f];

            stub.atBreakpoint(false);

    public void run() {

    void run() {

        m_engine.setBreakNextLine(false);

    public void stepIn() {

    void stepIn() {

        m_engine.setBreakNextLine(true);

        m_stepDepth = m_frameCount;

        m_stepDepth = getContextCount();

    public void stepOut() {

    void stepOut() {

        m_engine.setBreakNextLine(true);

        m_stepDepth = m_frameCount;

        m_stepDepth = getContextCount();

    public void stepOver() {

    void stepOver() {

        m_engine.setBreakNextLine(true);

        m_stepDepth = m_frameCount;

        m_stepDepth = getContextCount();

    public JsContextStub entry_exit_mode() throws RemoteException {

    JsContextStub entry_exit_mode() throws RemoteException {

        updateStack();

        return getTopContextStub();

        return m_frames[0];

    public JsContextStub stepping() {

    JsContextStub stepping() {

        int frameCount = m_engine.getFrameCount();

        int frameCount = getContextCount();

                return m_frames[0];

                return getTopContextStub();

                // OG if ((frameCount == m_stepDepth + 1) || 

                // OG if ((frameCount == m_stepDepth + 1) ||

                    return m_frames[0];

                    return getTopContextStub();

                }

                break;

                // this basically avoids any children frame but 

                // this basically avoids any children frame but

                    return m_frames[0];

                    return getTopContextStub();

                    return m_frames[0];

                    return getTopContextStub();

    public void stopEngine() {

    void stopEngine() {

        m_engine.setBreakNextLine(true);

public class RhinoEngineDebugger implements Debugger {

class RhinoEngineDebugger implements Debugger {

     */	

     */

    /** 

    /**

     *  They typically contains JsObject associated to 

     *  They typically contains JsObject associated to

    public RhinoEngineDebugger(JavaScriptEngine eng) 

    RhinoEngineDebugger(JavaScriptEngine eng)

    public void disconnectedDebuggerNotify() {

    void disconnectedDebuggerNotify() {

    void dropStub(Object key) {

    void dropStub(Scriptable key) {

    public synchronized DocumentCell getDocumentCell(String name) {

    synchronized DocumentCell getDocumentCell(String name) {

    public synchronized DocumentCell loadDocumentNotify(String name) {

    synchronized DocumentCell loadDocumentNotify(String name) {

            if (dbgmgr!=null) 

            if (dbgmgr!=null)

    public synchronized void placeBreakpointAtLine(int brkptid,

    synchronized void placeBreakpointAtLine(int brkptid,

    public synchronized void placeBreakpointAtOffset(int brkptid,

    synchronized void placeBreakpointAtOffset(int brkptid,

    public void removeBreakpoint(String docname, int brkptid)

    void removeBreakpoint(String docname, int brkptid)

    public void setEntryExit(String docname, boolean on)

    void setEntryExit(String docname, boolean on)

    public Object eval(String docname, String fnOrScript, int lineno)

    Object eval(String docname, String fnOrScript, int lineno)

    public JsContext getContext(int depth) {

    JsContext getContext(int depth) {

        if (m_rcp != null) return m_rcp.getContext(depth);

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        if (rcp != null) return rcp.getContextStub(depth);

    public int getContextCount() {

    int getContextCount() {

        if (m_rcp != null) return m_rcp.getContextCount();

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        if (rcp != null) return rcp.getContextCount();

    public JsCallbacks getDebugger() {

    JsCallbacks getDebugger() {

    public Object getDebugInterface() {

    Object getDebugInterface() {

    public JsObject getGlobalObject() {

    JsObject getGlobalObject() {

        return (RhinoContextProxy) stubs.get(cx);

        return (RhinoContextProxy)cx.getDebuggerContextData();

    public JsObject getUndefinedValue() {

    JsObject getUndefinedValue() {

    public String getThread() {

    String getThread() {

        Context cx = Context.getCurrentContext();

        if (m_thread != null) {

        if (cx != null) {

                            return m_thread.getName();

                            return Thread.currentThread().getName();

    public String getThreadGroup() {

    String getThreadGroup() {

        Context cx = Context.getCurrentContext();

        if (m_thread != null) {

        if (cx != null) {

                            return m_thread.getThreadGroup().getName();

                            return Thread.currentThread().getThreadGroup().

                                        getName();

    public void handleBreakpointHit(Context cx) {

    void handleBreakpointHit(Context cx, RhinoContextProxy rcp) {

        boolean suspend=false;

        DebugLog.stdoutPrintln("**** Handling a breakpoint hit...",

        m_thread = Thread.currentThread();

        DebugLog.stdoutPrintln("**** Handling a breakpoint hit...", 

        m_rcp = getStub(cx);

        // if we have no callbacks... then just

        if (m_rcp == null) {

            m_rcp = new RhinoContextProxy(this, cx);

            addStub(cx, m_rcp);

        }

        // if we have no callbacks... then just 

            DebugLog.stdoutPrintln("	No callbacks, resuming...", DebugLog.BSF_LOG_L3);

            DebugLog.stdoutPrintln("    No callbacks, resuming...", DebugLog.BSF_LOG_L3);

            m_rcp.run();

            rcp.run();

            name = m_rcp.getSourceName();

            name = rcp.getSourceName();

            lineno = m_rcp.getLineNumber();

            lineno = rcp.getLineNumber();

            DebugLog.stdoutPrintln("	in "+name+" at "+lineno, DebugLog.BSF_LOG_L3);

            DebugLog.stdoutPrintln("    in "+name+" at "+lineno, DebugLog.BSF_LOG_L3);

            if (cell != null) 

            if (cell != null)

                _handleBreakpointHit(cell,lineno);

                _handleBreakpointHit(rcp,cell,lineno);

        } 

        }

        m_rcp = null;

    public void _handleBreakpointHit(DocumentCell cell, int lineno) {

    void _handleBreakpointHit(RhinoContextProxy rcp,

                              DocumentCell cell, int lineno)

    {

                stub = m_rcp.hitBreakpoint();

                stub = rcp.hitBreakpoint();

                DebugLog.stdoutPrintln("	breakpoint callback...", DebugLog.BSF_LOG_L3);

                DebugLog.stdoutPrintln("    breakpoint callback...", DebugLog.BSF_LOG_L3);

             	m_callbacks.createFuture(m_rcp);

                 m_callbacks.createFuture(rcp);

                DebugLog.stderrPrintln("	EXCEPTION OCCURED DURING BREAKPOINT CALLBACK", DebugLog.BSF_LOG_L0);				

                DebugLog.stderrPrintln("    EXCEPTION OCCURED DURING BREAKPOINT CALLBACK", DebugLog.BSF_LOG_L0);

            DebugLog.stdoutPrintln("	didn't find a breakpoint...", DebugLog.BSF_LOG_L3);

            DebugLog.stdoutPrintln("    didn't find a breakpoint...", DebugLog.BSF_LOG_L3);

                stub = m_rcp.stepping();

                stub = rcp.stepping();

                    DebugLog.stdoutPrintln("	stepping-done callback...", 

                    DebugLog.stdoutPrintln("    stepping-done callback...",

                	m_callbacks.createFuture(m_rcp);

                    m_callbacks.createFuture(rcp);

                } 

                }

                         (m_rcp.getContextCount() == 0)) {

                         (rcp.getContextCount() == 0)) {

                    stub = m_rcp.entry_exit_mode();

                    stub = rcp.entry_exit_mode();

                    DebugLog.stdoutPrintln("    entry/exit mode...", 

                    DebugLog.stdoutPrintln("    entry/exit mode...",

                	m_callbacks.createFuture(m_rcp);

                    m_callbacks.createFuture(rcp);

                    DebugLog.stdoutPrintln("	No reason to suspend execution.", DebugLog.BSF_LOG_L3);				

                    DebugLog.stdoutPrintln("    No reason to suspend execution.", DebugLog.BSF_LOG_L3);

                DebugLog.stderrPrintln("	EXCEPTION OCCURED DURING STEPPING-DONE CALLBACK", DebugLog.BSF_LOG_L0);				

                DebugLog.stderrPrintln("    EXCEPTION OCCURED DURING STEPPING-DONE CALLBACK", DebugLog.BSF_LOG_L0);

            // now, suspend this thread... until 

            // now, suspend this thread... until

                m_callbacks.suspendFuture(m_rcp);

                m_callbacks.suspendFuture(rcp);

                m_rcp.run();

                rcp.run();

        }			

        }

    public void run(JsEngineStub eng) throws Exception {

    void run(JsEngineStub eng) throws Exception {

        m_rcp.run(); 

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        m_callbacks.completeFuture(m_rcp);

        rcp.run();

        m_callbacks.completeFuture(rcp);

    public void stepIn(JsEngineStub eng) throws Exception {

    void stepIn(JsEngineStub eng) throws Exception {

        m_rcp.stepIn();

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        m_callbacks.completeFuture(m_rcp);

        rcp.stepIn();

        m_callbacks.completeFuture(rcp);

    public void stepOut(JsEngineStub eng) throws Exception {

    void stepOut(JsEngineStub eng) throws Exception {

        m_rcp.stepOut();

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        m_callbacks.completeFuture(m_rcp);

        rcp.stepOut();

        m_callbacks.completeFuture(rcp);

    public void stepOver(JsEngineStub eng) throws Exception {

    void stepOver(JsEngineStub eng) throws Exception {

        m_rcp.stepOver();

        RhinoContextProxy rcp = RhinoContextProxy.getCurrent();

        m_callbacks.completeFuture(m_rcp);

        rcp.stepOver();

        m_callbacks.completeFuture(rcp);

                                      StringBuffer source) {

                                      String 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)

    {

        NativeError error;

        // if we have no callbacks... then just

        m_thread = Thread.currentThread();

        // ignore the breakpoint hit, do a run

        m_rcp = getStub(cx);

        // so that execution resumes...

        if (m_rcp == null) {

        if (m_callbacks==null) {

            m_rcp = new RhinoContextProxy(this, cx);

            rcp.run();

            addStub(cx, m_rcp);

            return;

            // First, check that we didn't hit a known breakpoint.

        // First, check that we didn't hit a known breakpoint.

            // First, search if we have breakpoints for the current documents

        // First, search if we have breakpoints for the current documents

            name = m_rcp.getSourceName();

        name = rcp.getSourceName();

            lineno = m_rcp.getLineNumber();

        lineno = rcp.getLineNumber();

            try {

        if (exceptionThrown instanceof EcmaError) {

                error = (NativeError)exceptionThrown;

            msg = ((EcmaError)exceptionThrown).getErrorObject().toString();

                msg = error.getName() + ": " + error.getMessage();

        } else {

            } catch (ClassCastException ccex) {

            msg = exceptionThrown.toString();

                msg = "Unknown JavaScript Exception";

        }

            }

        ex = new Exception(msg);

            ex = new Exception(msg);

            cell = getDocumentCell(name);

        cell = getDocumentCell(name);

            if (cell == null) return;

        if (cell == null) return;

            try {

        try {

                stub = m_rcp.exceptionThrown();	

            stub = rcp.exceptionThrown();

                m_callbacks.createFuture(m_rcp);

            m_callbacks.createFuture(rcp);

                m_callbacks.handleExceptionThrown(stub,ex);

            m_callbacks.handleExceptionThrown(stub,ex);

                // now, suspend this thread... until 

            // now, suspend this thread... until

                // we restart.

            // we restart.

                m_callbacks.suspendFuture(m_rcp);

            m_callbacks.suspendFuture(rcp);

            } catch (Exception ex2) {

        } catch (Exception ex2) {

                m_rcp.run();

            rcp.run();

            }

        } finally {

            m_rcp = null;

     * 

     *

    public void setBreakNextLine(JsContext context, boolean isLineStep) {

    void setBreakNextLine(JsContext context, boolean isLineStep) {

    public void setDebugger(JsCallbacks debugger) {

    void setDebugger(JsCallbacks debugger) {