fix CHECK_BRANCH fencepost

git-svn-id: svn://10.0.0.236/branches/SpiderMonkeyDev_BRANCH@31697 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/js/jsd/MANIFEST

@@ -0,0 +1,5 @@
+#
+# This is a list of local files which get copied to the mozilla:dist directory
+#
+
+jsdebug.h

mozilla/js/jsd/Makefile

@@ -0,0 +1,73 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../..
+
+MODULE		= jsdebug
+LIBRARY_NAME	= jsd
+
+# Switching on MOZ_JAVA is a short-term hack. This is really for no Java/IFC
+ifdef MOZ_JAVA
+JAVA_OR_OJI = 1
+endif
+ifdef MOZ_OJI
+JAVA_OR_OJI = 1
+endif
+
+ifdef JAVA_OR_OJI
+DIRS		= classes
+endif
+
+REQUIRES	= java js nspr 
+
+EXPORTS		= jsdebug.h
+
+CSRCS		= \
+		  jsdebug.c \
+		  jsd_high.c \
+		  jsd_hook.c \
+		  jsd_scpt.c \
+		  jsd_stak.c \
+		  jsd_text.c \
+		  jsd_lock.c \
+		  $(NULL)
+
+ifndef MOZ_JSD
+CSRCS		+= jsdstubs.c jsd_java.c
+
+JDK_GEN		= \
+		  netscape.jsdebug.Script \
+		  netscape.jsdebug.DebugController \
+		  netscape.jsdebug.JSThreadState \
+		  netscape.jsdebug.JSStackFrameInfo \
+		  netscape.jsdebug.JSPC \
+		  netscape.jsdebug.JSSourceTextProvider \
+		  netscape.jsdebug.JSErrorReporter \
+		  $(NULL)
+endif
+
+include $(DEPTH)/config/rules.mk
+
+$(OBJDIR)\jsdstubs.o: \
+	$(JDK_STUB_DIR)\netscape_jsdebug_Script.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_DebugController.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSThreadState.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSStackFrameInfo.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSPC.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSSourceTextProvider.c	

mozilla/js/jsd/Makefile.in

@@ -0,0 +1,78 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../..
+topsrcdir	= @top_srcdir@
+VPATH		= @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= jsdebug
+LIBRARY_NAME	= jsd
+
+# Switching on MOZ_JAVA is a short-term hack. This is really for no Java/IFC
+ifdef MOZ_JAVA
+JAVA_OR_OJI = 1
+endif
+ifdef MOZ_OJI
+JAVA_OR_OJI = 1
+endif
+
+ifdef JAVA_OR_OJI
+DIRS		= classes
+endif
+
+REQUIRES	= java js
+
+EXPORTS		= $(srcdir)/jsdebug.h
+
+CSRCS		= \
+		  jsdebug.c \
+		  jsd_high.c \
+		  jsd_hook.c \
+		  jsd_scpt.c \
+		  jsd_stak.c \
+		  jsd_text.c \
+		  jsd_lock.c \
+		  $(NULL)
+
+ifndef MOZ_JSD
+CSRCS		+= jsdstubs.c jsd_java.c
+
+JDK_GEN		= \
+		  netscape.jsdebug.Script \
+		  netscape.jsdebug.DebugController \
+		  netscape.jsdebug.JSThreadState \
+		  netscape.jsdebug.JSStackFrameInfo \
+		  netscape.jsdebug.JSPC \
+		  netscape.jsdebug.JSSourceTextProvider \
+		  netscape.jsdebug.JSErrorReporter \
+		  $(NULL)
+endif
+
+include $(topsrcdir)/config/rules.mk
+
+$(OBJDIR)\jsdstubs.o: \
+	$(JDK_STUB_DIR)\netscape_jsdebug_Script.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_DebugController.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSThreadState.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSStackFrameInfo.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSPC.c \
+	$(JDK_STUB_DIR)\netscape_jsdebug_JSSourceTextProvider.c	

mozilla/js/jsd/README

@@ -0,0 +1,18 @@
+/* jband - 10/26/98 -  */
+
+js/jsd contains code for debugging support for the C-based JavaScript engine 
+in js/src.
+
+Currently the makefiles are for Win32 only (using MS nmake.exe from MSDEV 4.2).
+jsd.mak will build a standalone dll. jsdshell.mak will build the dll and also
+a version of the js/src/js.c shell which will launch a Java VM and run the 
+JavaSript Debugger (built in js/jsdj). This version assumes that you have a 
+JRE compatible JVM installed. Only Windows is supported for this Java-based 
+debugging.
+
+Though only Windows makefiles are supplied, the basic code in js/jsd should 
+compile for other platforms -- it is a newer version of code that builds and 
+ships with Communicator 4.x on many platforms.
+
+js/jsd/jsdb is a console debugger using only native code (see README in that 
+directory)

mozilla/js/jsd/classes/Makefile

@@ -0,0 +1,59 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../..
+
+MODULE		= java
+
+JJSD		= netscape/jsdebug
+
+#
+# JDIRS is dependant on JAVA_DESTPATH in config/rules.m[a]k. 
+# Be sure to touch that directory if you add a new directory to
+# JDIRS, or else it will not build. XXX
+#
+JDIRS		= $(JJSD)
+
+JAR_JSD		= jsd10.jar
+JAR_JSD_CLASSES	= $(JJSD)
+
+#
+# jars to build at install time
+#
+JARS		= $(JAR_JSD)
+
+include $(DEPTH)/config/rules.mk
+
+JAVA_SOURCEPATH = $(DEPTH)/js/jsd/classes
+
+doc::
+	$(JAVADOC) -d $(DIST)/doc netscape.jsdebug
+
+natives_list:: FORCE
+	rm -rf $@
+	find . -name "*.class" -print | sed 's@\./\(.*\)\.class$$@\1@' | \
+		sed 's@/@.@g' | xargs $(JVH) -natives | sort > $@
+
+check_natives:: natives_list
+	rm -f found_natives
+	nm -B	../$(OBJDIR)/*.o \
+	    | egrep "Java.*_stub" | awk '{ print $$3; }' | sort > found_natives
+	diff found_natives natives_list
+
+FORCE:

mozilla/js/jsd/classes/Makefile.in

@@ -0,0 +1,64 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+VPATH		= @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= java
+
+JJSD		= netscape/jsdebug
+
+#
+# JDIRS is dependant on JAVA_DESTPATH in config/rules.m[a]k. 
+# Be sure to touch that directory if you add a new directory to
+# JDIRS, or else it will not build. XXX
+#
+JDIRS		= $(JJSD)
+
+JAR_JSD		= jsd10.jar
+JAR_JSD_CLASSES	= $(JJSD)
+
+#
+# jars to build at install time
+#
+JARS		= $(JAR_JSD)
+
+include $(topsrcdir)/config/rules.mk
+
+JAVA_SOURCEPATH = $(DEPTH)/js/jsd/classes
+
+doc::
+	$(JAVADOC) -d $(DIST)/doc netscape.jsdebug
+
+natives_list:: FORCE
+	rm -rf $@
+	find . -name "*.class" -print | sed 's@\./\(.*\)\.class$$@\1@' | \
+		sed 's@/@.@g' | xargs $(JVH) -natives | sort > $@
+
+check_natives:: natives_list
+	rm -f found_natives
+	nm -B	../$(OBJDIR)/*.o \
+	    | egrep "Java.*_stub" | awk '{ print $$3; }' | sort > found_natives
+	diff found_natives natives_list
+
+FORCE:

mozilla/js/jsd/classes/makefile.win

@@ -0,0 +1,64 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+IGNORE_MANIFEST=1
+# 
+#//------------------------------------------------------------------------
+#//
+#// Makefile to build the JavaScriptDebug tree
+#//
+#//------------------------------------------------------------------------
+
+DEPTH = ..\..\..
+JAVA_SOURCEPATH=$(DEPTH)\js\jsd\classes
+
+#//------------------------------------------------------------------------
+#// 
+#// Define the files necessary to build the target (ie. OBJS)
+#//
+#//------------------------------------------------------------------------
+include <$(DEPTH)\config\config.mak>
+
+all::
+
+MODULE=java 
+JJSD=netscape/jsdebug 
+JDIRS=$(JJSD) 
+JAR_JSD=jsd10.jar 
+JAR_JSD_CLASSES=$(JJSD) 
+JARS=$(JAR_JSD) 
+
+include <$(DEPTH)\config\rules.mak>
+
+!if "$(MOZ_BITS)" == "32"
+$(JAR_JSD):
+	cd $(JAVA_DESTPATH)
+	@echo +++ building/updating $@
+	$(ZIP_PROG) -$(COMP_LEVEL)qu $@ META-INF\build
+	-for %i in ($(JAR_JSD_CLASSES:/=\)) do @$(ZIP_PROG) -$(COMP_LEVEL)qu $@ %i\*.class
+	cd $(MAKEDIR)
+!endif
+
+jars:	$(JARS)
+
+install:: jars
+
+
+javadoc:
+	-mkdir $(XPDIST)\javadoc 2> NUL
+	echo $(JAVADOC) -sourcepath . -d $(XPDIST)\javadoc $(JDIRS:/=.)
+	$(JAVADOC) -sourcepath . -d $(XPDIST)\javadoc $(JDIRS:/=.)

mozilla/js/jsd/classes/netscape/jsdebug/DebugBreakHook.java

@@ -0,0 +1,41 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* DebugBreakHook must be subclassed to respond when a debug break is 
+* requested
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public class DebugBreakHook extends Hook {
+
+    /**
+     * Override this method to respond just before a thread
+     * reaches a particular instruction.
+     * <p>
+     * @param debug ThreadState representing the current state
+     * @param pc the location of the instruction about to be executed
+     */
+    public void aboutToExecute(ThreadStateBase debug, PC pc) {
+        // defaults to no action
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/DebugController.java

@@ -0,0 +1,374 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+import netscape.util.Hashtable;
+import netscape.security.PrivilegeManager;
+import netscape.security.ForbiddenTargetException;
+
+/**
+* This is the master control panel for observing events in the VM.
+* Each method setXHook() must be passed an object that extends
+* the class XHook.  When an event of the specified type
+* occurs, a well-known method on XHook will be called (see the
+* various XHook classes for details).  The method call takes place
+* on the same thread that triggered the event in the first place,
+* so that any monitors held by the thread which triggered the hook
+* will still be owned in the hook method.
+* <p>
+* This class is meant to be a singleton and has a private constructor.
+* Call the static <code>getDebugController()</code> to get this object.
+* <p>
+* Note that all functions use netscape.security.PrivilegeManager to verify 
+* that the caller has the "Debugger" privilege. The exception 
+* netscape.security.ForbiddenTargetException will be throw if this is 
+* not enabled.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+* @see netscape.security.PrivilegeManager
+* @see netscape.security.ForbiddenTargetException
+*/
+public final class DebugController {
+
+    private static final int majorVersion = 1;
+    private static final int minorVersion = 0;
+
+    private static DebugController controller;
+    private ScriptHook scriptHook;
+    private Hashtable instructionHookTable;
+    private InterruptHook interruptHook;
+    private DebugBreakHook debugBreakHook;
+    private JSErrorReporter errorReporter;
+
+    /**
+     * Get the DebugController object for the current VM.
+     * <p>
+     * @return the singleton DebugController
+     */
+    public static synchronized DebugController getDebugController() 
+        throws ForbiddenTargetException
+    {
+        try {
+            PrivilegeManager.checkPrivilegeEnabled("Debugger");
+            if (controller == null)
+                controller = new DebugController();
+            return controller;
+    	} catch (ForbiddenTargetException e) {
+            System.out.println("failed in check Priv in DebugController.getDebugController()");
+            e.printStackTrace(System.out);
+            throw e;
+    	}
+    }
+
+    private DebugController()
+    {
+        scriptTable = new Hashtable();
+        _setController(true);
+    }
+
+
+
+    /**
+     * Request notification of Script loading events.
+     * <p>
+     * Whenever a Script is loaded into or unloaded from the VM 
+     * the appropriate method of  the ScriptHook argument will be called. 
+     * Callers are responsible for chaining hooks if chaining is required.
+     *
+     * @param h new script hook
+     * @return the previous hook object (null if none)
+     */
+    public synchronized ScriptHook setScriptHook(ScriptHook h)
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        ScriptHook oldHook = scriptHook;
+        scriptHook = h;
+        return oldHook;
+    }
+
+    /**
+     * Get the current observer of Script events.
+     * <p>
+     * @return the current script hook (null if none)
+     */
+    public ScriptHook getScriptHook()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return scriptHook;
+    }
+
+    /**
+     * Set a hook at the given program counter value.  
+     * <p>
+     * When a thread reaches that instruction, a ThreadState 
+     * object will be created and the appropriate method 
+     * of the hook object will be called. Callers are responsible
+     * for chaining hooks if chaining is required.
+     * 
+     * @param pc pc at which hook should be set
+     * @param h new hook for this pc
+     * @return the previous hook object (null if none)
+     */
+    public synchronized InstructionHook setInstructionHook(
+        PC pc,
+        InstructionHook h) 
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        InstructionHook oldHook;
+        if (instructionHookTable == null) {
+            instructionHookTable = new Hashtable();
+        }
+        oldHook = (InstructionHook) instructionHookTable.get(pc);
+        instructionHookTable.put(pc, h);
+        setInstructionHook0(pc);
+        return oldHook;
+    }
+
+    private native void setInstructionHook0(PC pc);
+
+    /**
+     * Get the hook at the given program counter value.
+     * <p>
+     * @param pc pc for which hook should be found
+     * @return the hook (null if none)
+     */
+    public InstructionHook getInstructionHook(PC pc)
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return getInstructionHook0(pc);
+    }
+
+    // called by native function
+    private InstructionHook getInstructionHook0(PC pc)
+    {
+        if (instructionHookTable == null)
+            return null;
+        else
+            return (InstructionHook) instructionHookTable.get(pc);
+    }
+
+    /**************************************************************/
+
+    /**
+     * Set the hook at to be called when interrupts occur.
+     * <p>
+     * The next instruction which starts to execute after 
+     * <code>sendInterrupt()</code> has been called will 
+     * trigger a call to this hook. A ThreadState 
+     * object will be created and the appropriate method 
+     * of the hook object will be called. Callers are responsible
+     * for chaining hooks if chaining is required.
+     * 
+     * @param h new hook
+     * @return the previous hook object (null if none)
+     * @see netscape.jsdebug.DebugController#sendInterrupt
+     */
+    public synchronized InterruptHook setInterruptHook( InterruptHook h )
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        InterruptHook oldHook = interruptHook;
+        interruptHook = h;
+        return oldHook;
+    }
+
+    /**
+     * Get the current hook to be called on interrupt
+     * <p>
+     * @return the hook (null if none)
+     */
+    public InterruptHook getInterruptHook()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return interruptHook;
+    }
+
+    /**
+     * Cause the interrupt hook to be called when the next 
+     * JavaScript instruction starts to execute.
+     * <p>
+     * The interrupt is self clearing
+     * @see netscape.jsdebug.DebugController#setInterruptHook
+     */
+    public void sendInterrupt()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        sendInterrupt0();
+    }
+
+    private native void sendInterrupt0();
+
+
+    /**************************************************************/
+
+    /**
+     * Set the hook at to be called when a <i>debug break</i> is requested
+     * <p>
+     * Set the hook to be called when <i>JSErrorReporter.DEBUG</i> is returned
+     * by the <i>error reporter</i> hook. When that happens a ThreadState 
+     * object will be created and the appropriate method 
+     * of the hook object will be called. Callers are responsible
+     * for chaining hooks if chaining is required.
+     * 
+     * @param h new hook
+     * @return the previous hook object (null if none)
+     * @see netscape.jsdebug.DebugController#setErrorReporter
+     * @see netscape.jsdebug.JSErrorReporter
+     */
+    public synchronized DebugBreakHook setDebugBreakHook( DebugBreakHook h )
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        DebugBreakHook oldHook = debugBreakHook;
+        debugBreakHook = h;
+        return oldHook;
+    }
+
+    /**
+     * Get the current hook to be called on debug break
+     * <p>
+     * @return the hook (null if none)
+     */
+    public DebugBreakHook getDebugBreakHook()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return debugBreakHook;
+    }
+
+
+    /**************************************************************/
+    /**
+     * Get the 'handle' which cooresponds to the native code representing the
+     * instance of the underlying JavaScript Debugger context.
+     * <p>
+     * This would not normally be useful in java. Some of the other classes
+     * in this package need this. It remains public mostly for historical 
+     * reasons. It serves as a check to see that the native classes have been
+     * loaded and the built-in native JavaScript Debugger support has been 
+     * initialized. This DebugController is not valid (or useful) when it is
+     * in a state where this native context equals 0.
+     *
+     * @return the native context (0 if none)
+     */
+    public int getNativeContext() 
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+//        System.out.println( "nativecontext = " + _nativeContext + "\n" );
+        return _nativeContext;
+    }
+
+    private native void _setController( boolean set );
+    private Hashtable scriptTable;
+    private int _nativeContext;
+
+    /**
+     * Execute a string as a JavaScript script within a stack frame
+     * <p>
+     * This method can be used to execute arbitrary sets of statements on a 
+     * stopped thread. It is useful for inspecting and modifying data.
+     * <p>
+     * This method can only be called while the JavaScript thread is stopped 
+     * - i.e. as part of the code responding to a hook. Thgis method 
+     * <b>must</b> be called on the same thread as was executing when the 
+     * hook was called.
+     * <p>
+     * If an error occurs while execuing this code, then the error 
+     * reporter hook will be called if present.
+     * 
+     * @param frame the frame context in which to evaluate this script
+     * @param text the script text
+     * @param filename where to tell the JavaScript engine this code came 
+     * from (it is usually best to make this the same as the filename of
+     * code represented by the frame)
+     * @param lineno the line number to pass to JS ( >=1 )
+     * @return The result of the script execution converted to a string.
+     * (null if the result was null or void)
+     */
+    public String executeScriptInStackFrame( JSStackFrameInfo frame,
+                                             String text,
+                                             String filename,
+                                             int lineno )
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return executeScriptInStackFrame0( frame, text, filename, lineno );
+    }
+
+    private native String executeScriptInStackFrame0( JSStackFrameInfo frame,
+                                                     String text,
+                                                     String filename,
+                                                     int lineno );
+
+
+    /**
+     * Set the hook at to be called when a JavaScript error occurs
+     * <p>
+     * @param er new error reporter hook
+     * @return the previous hook object (null if none)
+     * @see netscape.jsdebug.JSErrorReporter
+     */
+    public JSErrorReporter setErrorReporter(JSErrorReporter er)
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        JSErrorReporter old = errorReporter;
+        errorReporter = er;
+        return old;
+    }
+
+    /**
+     * Get the hook at to be called when a JavaScript error occurs
+     * <p>
+     * @return the hook object (null if none)
+     * @see netscape.jsdebug.JSErrorReporter
+     */
+    public JSErrorReporter getErrorReporter()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return errorReporter;
+    }
+
+    /**
+     * Get the major version number of this module
+     * <p>
+     * @return the version number
+     */
+    public static int getMajorVersion() {return majorVersion;}
+    /**
+     * Get the minor version number of this module
+     * <p>
+     * @return the version number
+     */
+    public static int getMinorVersion() {return minorVersion;}
+
+    private static native int getNativeMajorVersion();
+    private static native int getNativeMinorVersion();
+}

mozilla/js/jsd/classes/netscape/jsdebug/Hook.java

@@ -0,0 +1,32 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+
+/**
+* An instance of this class is returned for each hook set by
+* the debugger as a handle for removing the hook later.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public abstract class Hook {
+}

mozilla/js/jsd/classes/netscape/jsdebug/InstructionHook.java

@@ -0,0 +1,55 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* InstructionHook must be subclassed to respond to hooks
+* at a particular program instruction.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public class InstructionHook extends Hook {
+    private PC pc;
+
+    /**
+     * Create an InstructionHook at the given PC value.
+     */
+    public InstructionHook(PC pc) {
+        this.pc = pc;
+    }
+
+    /**
+     * Get the instruction that the hook is set at.
+     */
+    public PC getPC() {
+        return pc;
+    }
+
+    /**
+     * Override this method to respond just before a thread
+     * reaches a particular instruction.
+     */
+    /* jband - 03/31/97 - I made this public to allow chaining */
+    public void aboutToExecute(ThreadStateBase debug) {
+        // defaults to no action
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/InterruptHook.java

@@ -0,0 +1,39 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* InterruptHook must be subclassed to respond when interrupts occur
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public class InterruptHook extends Hook {
+
+    /**
+     * Override this method to respond when interrupts occur
+     * @param debug the state of this thread
+     * @param pc the pc of the instruction about to execute
+     */
+    public void aboutToExecute(ThreadStateBase debug, PC pc) {
+        // defaults to no action
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/InvalidInfoException.java

@@ -0,0 +1,46 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* Exception to indicate bad thread state etc...
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public class InvalidInfoException extends Exception {
+    /**
+     * Constructs a InvalidInfoException without a detail message.
+     * A detail message is a String that describes this particular exception.
+     */
+    public InvalidInfoException() {
+	super();
+    }
+
+    /**
+     * Constructs a InvalidInfoException with a detail message.
+     * A detail message is a String that describes this particular exception.
+     * @param s the detail message
+     */
+    public InvalidInfoException(String s) {
+	super(s);
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/JSErrorReporter.java

@@ -0,0 +1,70 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This is a special kind of hook to respond to JavaScript errors
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public interface JSErrorReporter
+{
+    /* keep these in sync with the numbers in jsdebug.h */
+
+    /**
+    * returned by <code>reportError()</code> to indicate that the error
+    * should be passed along to the error reporter that would have been 
+    * called had the debugger not been running
+    */
+    public static final int PASS_ALONG = 0;
+    /**
+    * returned by <code>reportError()</code> to indicate that the 
+    * normal error reporter should not be called and that the JavaScript
+    * engine should do whatever it would normally do after calling the
+    * error reporter.
+    */
+    public static final int RETURN     = 1;
+    /**
+    * returned by <code>reportError()</code> to indicate that the 
+    * 'debug break' hook should be called to allow the debugger to 
+    * investigate the state of the process when the error occured
+    */
+    public static final int DEBUG      = 2;
+
+    /**
+    * This hook is called when a JavaScript error (compile or runtime) occurs
+    * <p> 
+    * One of the codes above should be returned to tell the engine how to 
+    * proceed.
+    * @param msg error message passed through from the JavaScript engine
+    * @param filename filename (or url) of the code with the error
+    * @param lineno line number where error was detected
+    * @param linebuf a copy of the line where the error was detected
+    * @param tokenOffset the offset into <i>linebuf</i> where the error 
+    * was detected
+    * @returns one of the codes above
+    */
+    public int reportError( String msg,
+                            String filename,
+                            int    lineno,
+                            String linebuf,
+                            int    tokenOffset );
+}    

mozilla/js/jsd/classes/netscape/jsdebug/JSPC.java

@@ -0,0 +1,76 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This subclass of PC provides JavaScript-specific information.
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public final class JSPC extends PC {
+    private Script script;
+    private int pc;
+
+    public JSPC(Script script, int pc) {
+        this.script = script;
+        this.pc = pc;
+    }
+
+    public Script getScript() {
+        return script;
+    }
+
+    public int getPC() {
+        return pc;
+    }
+
+    public boolean isValid()
+    {
+        return script.isValid();
+    }
+
+
+    /**
+     * Get the SourceLocation associated with this PC value.
+     * returns null if the source location is unavailable.
+     */
+    public native SourceLocation getSourceLocation();
+
+    /**
+     * Ask whether two program counter values are equal.
+     */
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (!(obj instanceof JSPC))
+            return false;
+        JSPC jspc = (JSPC) obj;
+        return (jspc.script == script && jspc.pc == pc);
+    }
+
+    public int hashCode() {
+        return script.hashCode() + pc;
+    }
+
+    public String toString() {
+        return "<PC "+script+"+"+pc+">";
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/JSSourceLocation.java

@@ -0,0 +1,63 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* JAvaScript specific SourceLocation
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public class JSSourceLocation extends SourceLocation
+{
+    public JSSourceLocation( JSPC pc, int line )
+    {
+        _pc   = pc;
+        _line = line;
+        _url  = pc.getScript().getURL();
+    }
+
+    /**
+     * Gets the first line number associated with this SourceLocation.
+     * This is the lowest common denominator information that will be
+     * available: some implementations may choose to include more
+     * specific location information in a subclass of SourceLocation.
+     */
+    public int getLine() {return _line;}
+
+    public String getURL() {return _url;}
+
+    /**
+     * Get the first PC associated with a given SourceLocation.
+     * This is the place to set  a breakpoint at that location.
+     * returns null if there is no code corresponding to that source
+     * location.
+     */
+    public PC getPC() {return _pc;}
+
+    public String toString()
+    {
+        return "<SourceLocation "+_url+"#"+_line+">";
+    }
+
+    private JSPC    _pc;
+    private int     _line;
+    private String  _url;
+}

mozilla/js/jsd/classes/netscape/jsdebug/JSSourceTextProvider.java

@@ -0,0 +1,130 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+import netscape.util.Vector;
+import netscape.security.PrivilegeManager;
+import netscape.security.ForbiddenTargetException;
+
+/**
+* This class provides access to SourceText items.
+* <p>
+* This class is meant to be a singleton and has a private constructor.
+* Call the static <code>getSourceTextProvider()</code> to get this object.
+* <p>
+* Note that all functions use netscape.security.PrivilegeManager to verify 
+* that the caller has the "Debugger" privilege. The exception 
+* netscape.security.ForbiddenTargetException will be throw if this is 
+* not enabled.
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+* @see netscape.security.PrivilegeManager
+* @see netscape.security.ForbiddenTargetException
+*/
+public final class JSSourceTextProvider extends SourceTextProvider
+{
+    private JSSourceTextProvider( long nativeContext )
+    {
+        _sourceTextVector = new Vector();
+        _nativeContext    = nativeContext;
+    }
+    
+
+    /**
+     * Get the SourceTextProvider object for the current VM.
+     * <p>
+     * @return the singleton SourceTextProvider
+     */
+    public static synchronized SourceTextProvider getSourceTextProvider()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        if( null == _sourceTextProvider )
+        {
+            long nativeContext = DebugController.getDebugController().getNativeContext();
+            if( 0 != nativeContext )
+                _sourceTextProvider = new JSSourceTextProvider(nativeContext);
+        }
+        return _sourceTextProvider;
+    }
+
+    /**
+    * Get the SourceText item for the given URL
+    */
+    public SourceTextItem findSourceTextItem( String url )
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return findSourceTextItem0(url);
+    }
+
+    // also called from native code...
+    private SourceTextItem findSourceTextItem0( String url )
+    {
+        synchronized( _sourceTextVector )
+        {
+            for (int i = 0; i < _sourceTextVector.size(); i++)
+            {
+                SourceTextItem src = (SourceTextItem) _sourceTextVector.elementAt(i);
+            
+                if( src.getURL().equals(url) )
+                    return src;
+            }
+            return null;
+        }
+    }
+
+    /**
+    * Return the vector of SourceTextItems. 
+    * <p>
+    * This is NOT a copy. nor is it necessarily current
+    */
+    public Vector getSourceTextVector()
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return _sourceTextVector;
+    }
+
+    /**
+    * Load the SourceText item for the given URL
+    * <p>
+    * <B>This is not guaranteed to be implemented</B>
+    */
+    public synchronized SourceTextItem   loadSourceTextItem( String url )
+        throws ForbiddenTargetException
+    {
+        PrivilegeManager.checkPrivilegeEnabled("Debugger");
+        return loadSourceTextItem0( url );
+    }
+
+    private native SourceTextItem   loadSourceTextItem0( String url );
+
+    /**
+    * Refresh the vector to reflect any changes made in the 
+    * underlying native system
+    */
+    public synchronized native void refreshSourceTextVector();
+
+    private static SourceTextProvider   _sourceTextProvider = null;
+    private Vector                      _sourceTextVector;
+    private long                        _nativeContext;
+}    

mozilla/js/jsd/classes/netscape/jsdebug/JSStackFrameInfo.java

@@ -0,0 +1,51 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This interface provides access to the execution stack of a thread.
+* It has several subclasses to distinguish between different kinds of
+* stack frames: these currently include activations of Java methods
+* or JavaScript functions.
+* It is possible that synchronize blocks and try blocks deserve their own
+* stack frames - to allow for later extensions a debugger should skip over
+* stack frames it doesn't understand.
+* Note that this appears very Java-specific.  However, multiple threads and
+* exceptions are relevant to JavaScript as well because of its
+* interoperation with Java.
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public final class JSStackFrameInfo extends StackFrameInfo
+{
+    public JSStackFrameInfo(JSThreadState threadState) {
+        super(threadState);
+    }
+
+    protected native StackFrameInfo getCaller0()
+        throws InvalidInfoException;
+
+    public native PC getPC()
+        throws InvalidInfoException;
+
+    private int     _nativePtr;     // used internally
+}
+

mozilla/js/jsd/classes/netscape/jsdebug/JSThreadState.java

@@ -0,0 +1,80 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This is the JavaScript specific implementation of the thread state
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public final class JSThreadState extends ThreadStateBase
+{
+    /**
+     * <B><font color="red">Not Implemented.</font></B> 
+     * Always throws <code>InternalError("unimplemented")</code>
+     */
+    public static ThreadStateBase getThreadState(Thread t)
+        throws InvalidInfoException
+    {
+        throw new InternalError("unimplemented");
+    }
+
+    /**
+     * get the count of frames
+     */
+    public native int countStackFrames()
+        throws InvalidInfoException;
+
+    /**
+     * get the 'top' frame
+     */
+    public native StackFrameInfo getCurrentFrame()
+        throws InvalidInfoException;
+
+    /**
+     * <B><font color="red">Not Implemented.</font></B> 
+     * Always throws <code>InternalError("unimplemented")</code>
+     */
+    public Thread getThread()
+    {
+        throw new InternalError("unimplemented");
+    }
+
+    /**
+     * <B><font color="red">Not Implemented.</font></B> 
+     * Always throws <code>InternalError("unimplemented")</code>
+     */
+    public void leaveSuspended()
+    {
+        throw new InternalError("unimplemented");
+    }
+
+    /**
+     * <B><font color="red">Not Implemented.</font></B> 
+     * Always throws <code>InternalError("unimplemented")</code>
+     */
+    protected void resume0()
+    {
+        throw new InternalError("unimplemented");
+    }
+
+    protected int nativeThreadState;  /* used internally */
+}

mozilla/js/jsd/classes/netscape/jsdebug/PC.java

@@ -0,0 +1,42 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* The PC class is an opaque representation of a program counter.  It
+* may have different implementations for interpreted Java methods,
+* methods compiled by the JIT, JavaScript methods, etc.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public abstract class PC {
+    /**
+     * Get the SourceLocation associated with this PC value.
+     * returns null if the source location is unavailable.
+     */
+    public abstract SourceLocation getSourceLocation();
+
+    /**
+     * Ask whether two program counter values are equal.
+     */
+    public abstract boolean equals(Object obj);
+}

mozilla/js/jsd/classes/netscape/jsdebug/Script.java

@@ -0,0 +1,82 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This instances of this class represent the JavaScript string object. This
+* class is intended to only be constructed by the underlying native code.
+* The DebugController will construct an instance of this class when scripts
+* are created and that instance will always be used to reference the underlying
+* script throughout the lifetime of that script.
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public final class Script
+{
+    public String   getURL()            {return _url;           }
+    public String   getFunction()       {return _function;      }
+    public int      getBaseLineNumber() {return _baseLineNumber;}
+    public int      getLineExtent()     {return _lineExtent;    }
+    public boolean  isValid()           {return 0 != _nativePtr;}
+
+    /**
+    * Get the PC of the first executable code on or after the given 
+    * line in this script. returns null if none
+    */
+    public native JSPC      getClosestPC(int line);
+
+    public String toString()
+    {
+        int end = _baseLineNumber+_lineExtent-1;
+        if( null == _function )
+            return "<Script "+_url+"["+_baseLineNumber+","+end+"]>";
+        else
+            return "<Script "+_url+"#"+_function+"()["+_baseLineNumber+","+end+"]>";
+    }
+
+    public int hashCode()
+    {
+        return _nativePtr;
+    }
+
+    public boolean equals(Object obj)
+    {
+        if( obj == this )
+            return true;
+
+        // In our system the native code is the only code that generates
+        // these objects. They are never duplicated
+        return false;
+/*
+        if( !(obj instanceof Script) )
+            return false;
+        return 0 != _nativePtr && _nativePtr == ((Script)obj)._nativePtr;
+*/
+    }
+
+    private synchronized void _setInvalid() {_nativePtr = 0;}
+
+    private String  _url;
+    private String  _function;
+    private int     _baseLineNumber;
+    private int     _lineExtent;
+    private int     _nativePtr;     // used internally
+}    

mozilla/js/jsd/classes/netscape/jsdebug/ScriptHook.java

@@ -0,0 +1,57 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* ScriptHook must be subclassed to respond to loading and 
+* unloading of scripts
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public class ScriptHook extends Hook 
+{
+    /**
+     * Create a ScriptHook for current the current VM.
+     */
+    public ScriptHook() {}
+
+    /**
+     * Override this method to respond when a new script is
+     * loaded into the VM.
+     *
+     * @param script a script object created by the controller to 
+     * represent this script. This exact same object will be used
+     * in all further references to the script.
+     */
+    public void justLoadedScript(Script script) {
+        // defaults to no action
+    }
+
+    /**
+     * Override this method to respond when a class is
+     * about to be unloaded from the VM.
+     *
+     * @param script which will be unloaded
+     */
+    public void aboutToUnloadScript(Script script) {
+        // defaults to no action
+    }
+}

mozilla/js/jsd/classes/netscape/jsdebug/SourceLocation.java

@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* An implementation of the SourceLocation interface is used to represent
+* a location in a source file.  Java classfiles only make source locations
+* available at the line-by-line granularity, but other languages may
+* include finer-grain information.  At this time only line number
+* information is included.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+/* XXX must source locations be contiguous? */
+public abstract class SourceLocation {
+    /**
+     * Gets the first line number associated with this SourceLocation.
+     * This is the lowest common denominator information that will be
+     * available: some implementations may choose to include more
+     * specific location information in a subclass of SourceLocation.
+     *
+     * @returns source line number cooresponding to this location
+     */
+    public abstract int getLine();
+
+    /**
+     * Get the first PC associated with a given SourceLocation.
+     * This is the place to set a breakpoint at that location.
+     *
+     * @returns pc object or null if there is no code corresponding 
+     * to this source location.
+     */
+    public abstract PC getPC();
+}

mozilla/js/jsd/classes/netscape/jsdebug/SourceTextItem.java

@@ -0,0 +1,107 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This class is used to represent a file or url which contains 
+* JavaScript source text. The actual JavaScript source may be intermixed
+* with other text (as in an html file) or raw. The debugger uses this 
+* interface to access the source. The file of the actual source need 
+* not physially exist anywhere; i.e. the underlying engine might synthesize
+* it as needed.
+* <p>
+* The <i>url</i> of this class is immutable -- it represents a key in 
+* collections of these objects
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public class SourceTextItem
+{
+    /* these coorespond to jsdebug.h values - change in both places if anywhere */
+
+    /**
+    * This object is initialized, but contains no text
+    */
+    public static final int INITED  = 0;
+    /**
+    * This object contains the full text
+    */
+    public static final int FULL    = 1;
+    /**
+    * This object contains the partial text (valid , but more may come later)
+    */
+    public static final int PARTIAL = 2;
+    /**
+    * This object may contain partial text, but loading was aborted (by user?)
+    */
+    public static final int ABORTED = 3;
+    /**
+    * This object may contain partial text, but loading failed (or the 
+    * underlying debugger support was unable to capture it; e.g. 
+    * not enough memory...)
+    */
+    public static final int FAILED  = 4;
+    /**
+    * This object contains no text because the debugger has signaled that 
+    * the text is no longer needed
+    */
+    public static final int CLEARED = 5;
+
+    /**
+    * Constuct for url (which is immutable during the lifetime of the object)
+    * <p>
+    * Presumably, text will be added later
+    * @param url url or filename by which this object will be known
+    */
+    public SourceTextItem( String url )
+    {
+        this( url, (String)null, INITED );
+    }
+
+    /**
+    * Constuct for url with text and status
+    * <p>
+    * @param url url or filename by which this object will be known
+    * @param text source text this object should start with
+    * @param status status this object should start with
+    */
+    public SourceTextItem( String url, String text, int status )
+    {
+        _url    = url;
+        _text   = text;
+        _status = status;
+        _dirty  = true;
+    }
+    
+    public String   getURL()    {return _url;   }
+    public String   getText()   {return _text;  }
+    public int      getStatus() {return _status;}
+    public boolean  getDirty()  {return _dirty; }
+    
+    public void     setText(String text)    {_text = text;}
+    public void     setStatus(int status)   {_status = status;}
+    public void     setDirty(boolean b)     {_dirty = b; }
+
+    private String  _url;
+    private String  _text;
+    private int     _status;
+    private boolean _dirty;
+}    

mozilla/js/jsd/classes/netscape/jsdebug/SourceTextProvider.java

@@ -0,0 +1,58 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+import netscape.util.Vector;
+import netscape.security.ForbiddenTargetException;
+
+/**
+* Abstract class to represent entity capable of providing access to source text
+*
+* @author  John Bandhauer
+* @version 1.0
+* @since   1.0
+*/
+public abstract class SourceTextProvider
+{
+    public static SourceTextProvider getSourceTextProvider()  throws Exception 
+    {
+        return null;
+    }
+    /**
+    * Return the vector of SourceTextItems. 
+    * <p>
+    * This is not liekly to be a copy. nor is it necessarily current
+    */
+    public abstract Vector           getSourceTextVector() throws ForbiddenTargetException;
+    /**
+    * Refresh the vector by whatever means to reflect any changes made in the 
+    * underlying native system
+    */
+    public abstract void             refreshSourceTextVector();
+    /**
+    * Get the SourceText item for the given URL
+    */
+    public abstract SourceTextItem   findSourceTextItem( String url ) throws ForbiddenTargetException;
+    /**
+    * Load the SourceText item for the given URL
+    * <p>
+    * <B>This is not guaranteed to be implemented</B>
+    */
+    public abstract SourceTextItem   loadSourceTextItem( String url ) throws ForbiddenTargetException;
+}    

mozilla/js/jsd/classes/netscape/jsdebug/StackFrameInfo.java

@@ -0,0 +1,94 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/**
+* This interface provides access to the execution stack of a thread.
+* It has several subclasses to distinguish between different kinds of
+* stack frames: these currently include activations of Java methods
+* or JavaScript functions.
+* It is possible that synchronize blocks and try blocks deserve their own
+* stack frames - to allow for later extensions a debugger should skip over
+* stack frames it doesn't understand.
+* Note that this appears very Java-specific.  However, multiple threads and
+* exceptions are relevant to JavaScript as well because of its
+* interoperation with Java.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public abstract class StackFrameInfo {
+    ThreadStateBase threadState;
+    StackFrameInfo caller;
+
+    protected StackFrameInfo(ThreadStateBase threadState) {
+        this.threadState = threadState;
+    }
+
+    /**
+     * Return true if this stack frame is still valid.  Stack frames
+     * may become invalid when the thread is resumed (this is more
+     * conservative than invalidating the frame only when it actually
+     * returns).
+     */
+    public boolean isValid() {
+        return threadState.isValid();
+    }
+
+    /**
+     * Get the stack frame where this one was built, or null for the
+     * start of the stack.
+     */
+    public synchronized StackFrameInfo getCaller()
+        throws InvalidInfoException {
+        if (caller == null)
+            caller = getCaller0();
+        if (!isValid())
+            throw new InvalidInfoException("invalid StackFrameInfo");
+        return caller;
+    }
+
+    protected abstract StackFrameInfo getCaller0()
+        throws InvalidInfoException;
+
+    /**
+     * Get the thread that this stack frame is a part of.
+     */
+    public Thread getThread() {
+        return threadState.getThread();
+    }
+
+    /**
+     * Get the 'enclosing' thread state
+     */
+    public ThreadStateBase getThreadState() {
+        return threadState;
+    }
+
+
+    /**
+     * Get the current program counter value.  Note that the
+     * class JavaPC supports the getMethod() operation.
+     */
+    public abstract PC getPC()
+        throws InvalidInfoException;
+}
+

mozilla/js/jsd/classes/netscape/jsdebug/ThreadStateBase.java

@@ -0,0 +1,241 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+package netscape.jsdebug;
+
+/*  
+*  jband - 03/19/97
+*
+*  This is an 'abstracted version of netscape.debug.ThreadState 
+*
+*  The methods that were 'native' there are 'abstract' here.
+*  Changed 'private' data to 'protected' (though native access is immune)
+*  Changed 'private' resume0() to 'protected'
+*  Removed ThreadHook referneces
+*
+*/
+
+/**
+* When a hook is hit, the debugger records the state of the
+* thread before the hook in a ThreadState object.  This object
+* is then passed to any hook methods that are called, and can
+* be used to change the state of the thread when it resumes from the
+* hook.
+*
+* @author  John Bandhauer
+* @author  Nick Thompson
+* @version 1.0
+* @since   1.0
+*/
+public abstract class ThreadStateBase {
+    protected Thread thread;
+    protected boolean valid;
+    protected boolean runningHook;
+    protected boolean resumeWhenDone;
+    protected int status;
+    protected int continueState;
+    protected StackFrameInfo[] stack; /* jband - 03/19/97 - had no access modifier */
+    protected Object returnValue;
+    protected Throwable currentException;
+    protected int currentFramePtr;  /* used internally */
+    protected ThreadStateBase previous;
+
+    /**
+     * <B><font color="red">Not Implemented.</font></B> 
+     * Always throws <code>InternalError("unimplemented")</code>
+     */
+    public static ThreadStateBase getThreadState(Thread t)
+        throws InvalidInfoException
+    {
+        throw new InternalError("unimplemented");
+    }
+
+    /**
+     * Get the Thread that this ThreadState came from.
+     */
+    public Thread getThread() {
+        return thread;
+    }
+
+    /**
+     * Return true if the Thread hasn't been resumed since this ThreadState
+     * was made.
+     */
+    public boolean isValid() {
+        return valid;
+    }
+
+    /**
+     * Return true if the thread is currently running a hook
+     * for this ThreadState
+     */
+    public boolean isRunningHook() {
+        return runningHook;
+    }
+
+    /**
+     * partial list of thread states from sun.debug.ThreadInfo.
+     * XXX some of these don't apply.
+     */
+    public final static int THR_STATUS_UNKNOWN		= 0x01;
+    public final static int THR_STATUS_ZOMBIE		= 0x02;
+    public final static int THR_STATUS_RUNNING		= 0x03;
+    public final static int THR_STATUS_SLEEPING		= 0x04;
+    public final static int THR_STATUS_MONWAIT		= 0x05;
+    public final static int THR_STATUS_CONDWAIT		= 0x06;
+    public final static int THR_STATUS_SUSPENDED	= 0x07;
+    public final static int THR_STATUS_BREAK		= 0x08;
+
+    /** 
+     * Get the state of the thread at the time it entered debug mode.
+     * This can't be modified directly.
+     */
+    public int getStatus() {
+        return status;
+    }
+
+    /** 
+     * Get the count of the stackframes
+     */
+    public abstract int countStackFrames()
+        throws InvalidInfoException;
+    /** 
+     * Get the 'top' stackframe; i.e. the one with the current instruction
+     */
+    public abstract StackFrameInfo getCurrentFrame()
+        throws InvalidInfoException;
+
+    /**
+     * Get the thread's stack as an array.  stack[stack.length-1] is the
+     * current frame, and stack[0] is the beginning of the stack.
+     */
+    public synchronized StackFrameInfo[] getStack()
+        throws InvalidInfoException {
+        // XXX check valid?
+        if (stack == null) {
+            stack = new StackFrameInfo[countStackFrames()];
+        }
+
+        if (stack.length == 0)
+            return stack;
+
+        StackFrameInfo frame = getCurrentFrame();
+        stack[stack.length - 1] = frame;
+        for (int i = stack.length - 2; i >= 0; i--) {
+            frame = frame.getCaller();
+            stack[i] = frame;
+        }
+
+        // should really be read-only for safety
+        return stack;
+    }
+
+    /**
+     * Leave the thread in a suspended state when the hook method(s)
+     * finish.  This can be undone by calling resume().  This is the
+     * default only if the break was the result of
+     * DebugController.sendInterrupt().
+     */
+    public void leaveSuspended() {
+        resumeWhenDone = false;
+    }
+
+    /**
+     * Resume the thread.  This is the default unless the break was the result
+     * of DebugController.sendInterrupt(). This method may be called from a
+     * hook method, in which case the thread will resume when the
+     * method returns.
+     * Alternatively, if there is no active hook method and
+     * the thread is suspended around in the DebugFrame, this resumes it
+     * immediately.
+     */
+    public synchronized void resume() {
+        if (runningHook)
+            resumeWhenDone = true;
+        else
+            resume0();
+    }
+
+    protected abstract void resume0();
+
+    /**
+     * if the continueState is DEAD, the thread cannot
+     * be restarted.
+     */
+    public final static int DEBUG_STATE_DEAD		= 0x01;
+
+    /**
+     * if the continueState is RUN, the thread will
+     * proceed to the next program counter value when it resumes.
+     */
+    public final static int DEBUG_STATE_RUN		= 0x02;
+
+    /**
+     * if the continueState is RETURN, the thread will
+     * return from the current method with the value in getReturnValue()
+     * when it resumes.
+     */
+    public final static int DEBUG_STATE_RETURN		= 0x03;
+
+    /**
+     * if the continueState is THROW, the thread will
+     * throw an exception (accessible with getException()) when it
+     * resumes.
+     */
+    public final static int DEBUG_STATE_THROW		= 0x04;
+
+    /**
+     * This gets the current continue state of the debug frame, which
+     * will be one of the DEBUG_STATE_* values above.
+     */
+    public int getContinueState() {
+        return continueState;
+    }
+
+    public int setContinueState(int state) {
+        int old = continueState;
+        continueState = state;
+        return old;
+    }
+
+    /**
+     * If the thread was stopped while in the process of returning
+     * a value, this call returns an object representing that value.
+     * non-Object values are wrapped as in the java.lang.reflect api.
+     * This is only relevant if the continue state is RETURN, and the
+     * method throws an IllegalStateException otherwise.
+     */
+    public Object getReturnValue() throws IllegalStateException {
+        if (continueState != DEBUG_STATE_RETURN)
+            throw new IllegalStateException("no value being returned");
+        return returnValue;
+    }
+
+    /** 
+     * If the thread was stopped while in the process of throwing an
+     * exception, this call returns that exception.  
+     * This is only relevant if the continue state is THROW, and it
+     * throws an IllegalStateException otherwise.
+     */
+    public Throwable getException() throws IllegalStateException {
+        if (continueState != DEBUG_STATE_THROW)
+            throw new IllegalStateException("no exception throw in progress");
+        return currentException;
+    }
+}
+

mozilla/js/jsd/corba/idl/ifaces.idl

@@ -0,0 +1,190 @@
+struct Thing {
+  string s;
+  long i;
+};
+interface StringReciever {
+  void recieveString(
+    in string arg0
+  );
+  void bounce(
+    in long arg0
+  );
+};
+interface TestInterface {
+  string getFirstAppInList();
+  void getAppNames(
+    in ::StringReciever arg0
+  );
+  typedef sequence<::Thing> sequence_of_Thing;
+  ::TestInterface::sequence_of_Thing getThings();
+  void callBounce(
+    in ::StringReciever arg0,
+    in long arg1
+  );
+};
+interface ISourceTextProvider {
+  typedef sequence<string> sequence_of_string;
+  ::ISourceTextProvider::sequence_of_string getAllPages();
+  void refreshAllPages();
+  boolean hasPage(
+    in string arg0
+  );
+  boolean loadPage(
+    in string arg0
+  );
+  void refreshPage(
+    in string arg0
+  );
+  string getPageText(
+    in string arg0
+  );
+  long getPageStatus(
+    in string arg0
+  );
+  long getPageAlterCount(
+    in string arg0
+  );
+};
+struct IScriptSection {
+  long base;
+  long extent;
+};
+typedef sequence<::IScriptSection> sequence_of_IScriptSection;
+struct IScript {
+  string url;
+  string funname;
+  long base;
+  long extent;
+  long jsdscript;
+  ::sequence_of_IScriptSection sections;
+};
+struct IJSPC {
+  ::IScript script;
+  long offset;
+};
+struct IJSSourceLocation {
+  long line;
+  ::IJSPC pc;
+};
+interface IJSErrorReporter {
+  long reportError(
+    in string arg0,
+    in string arg1,
+    in long arg2,
+    in string arg3,
+    in long arg4
+  );
+};
+interface IScriptHook {
+  void justLoadedScript(
+    in ::IScript arg0
+  );
+  void aboutToUnloadScript(
+    in ::IScript arg0
+  );
+};
+struct IJSStackFrameInfo {
+  ::IJSPC pc;
+  long jsdframe;
+};
+typedef sequence<::IJSStackFrameInfo> sequence_of_IJSStackFrameInfo;
+struct IJSThreadState {
+  ::sequence_of_IJSStackFrameInfo stack;
+  long continueState;
+  string returnValue;
+  long status;
+  long jsdthreadstate;
+  long id;
+};
+interface IJSExecutionHook {
+  void aboutToExecute(
+    in ::IJSThreadState arg0,
+    in ::IJSPC arg1
+  );
+};
+struct IExecResult {
+  string result;
+  boolean errorOccured;
+  string errorMessage;
+  string errorFilename;
+  long errorLineNumber;
+  string errorLineBuffer;
+  long errorTokenOffset;
+};
+interface IDebugController {
+  long getMajorVersion();
+  long getMinorVersion();
+  ::IJSErrorReporter setErrorReporter(
+    in ::IJSErrorReporter arg0
+  );
+  ::IJSErrorReporter getErrorReporter();
+  ::IScriptHook setScriptHook(
+    in ::IScriptHook arg0
+  );
+  ::IScriptHook getScriptHook();
+  ::IJSPC getClosestPC(
+    in ::IScript arg0,
+    in long arg1
+  );
+  ::IJSSourceLocation getSourceLocation(
+    in ::IJSPC arg0
+  );
+  ::IJSExecutionHook setInterruptHook(
+    in ::IJSExecutionHook arg0
+  );
+  ::IJSExecutionHook getInterruptHook();
+  ::IJSExecutionHook setDebugBreakHook(
+    in ::IJSExecutionHook arg0
+  );
+  ::IJSExecutionHook getDebugBreakHook();
+  ::IJSExecutionHook setInstructionHook(
+    in ::IJSExecutionHook arg0,
+    in ::IJSPC arg1
+  );
+  ::IJSExecutionHook getInstructionHook(
+    in ::IJSPC arg0
+  );
+  void setThreadContinueState(
+    in long arg0,
+    in long arg1
+  );
+  void setThreadReturnValue(
+    in long arg0,
+    in string arg1
+  );
+  void sendInterrupt();
+  void sendInterruptStepInto(
+    in long arg0
+  );
+  void sendInterruptStepOver(
+    in long arg0
+  );
+  void sendInterruptStepOut(
+    in long arg0
+  );
+  void reinstateStepper(
+    in long arg0
+  );
+  ::IExecResult executeScriptInStackFrame(
+    in long arg0,
+    in ::IJSStackFrameInfo arg1,
+    in string arg2,
+    in string arg3,
+    in long arg4
+  );
+  boolean isRunningHook(
+    in long arg0
+  );
+  boolean isWaitingForResume(
+    in long arg0
+  );
+  void leaveThreadSuspended(
+    in long arg0
+  );
+  void resumeThread(
+    in long arg0
+  );
+  void iterateScripts(
+    in ::IScriptHook arg0
+  );
+};

mozilla/js/jsd/corba/ifaces_s.hh

@@ -0,0 +1,777 @@
+#ifndef _ifaces_s_hh
+#define _ifaces_s_hh
+
+#include "ifaces_c.hh"
+
+/************************************************************************/
+/*                                                                      */
+/* This file is automatically generated by ORBeline IDL compiler        */
+/* Do not modify this file.                                             */
+/*                                                                      */
+/* ORBeline (c) is copyrighted by PostModern Computing, Inc.            */
+/*                                                                      */
+/* The generated code conforms to OMG's IDL C++ mapping as              */
+/* specified in OMG Document Number: 94-9-14.                           */
+/*                                                                      */
+/************************************************************************/
+
+class _sk_StringReciever : public StringReciever
+{
+    protected:
+	_sk_StringReciever(const char *object_name = (const char *)NULL);
+	_sk_StringReciever(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_StringReciever() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual void recieveString(const char * arg0) = 0;
+	virtual void bounce(CORBA::Long arg0) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _recieveString(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _bounce(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_StringReciever : public StringReciever
+{
+    public:
+	_tie_StringReciever(T& t, const char *obj_name=(char*)NULL) : 
+			StringReciever(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_StringReciever(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_StringReciever() {}
+	void recieveString(const char * arg0) {
+		_ref.recieveString(
+		arg0);
+	}
+	void bounce(CORBA::Long arg0) {
+		_ref.bounce(
+		arg0);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_TestInterface : public TestInterface
+{
+    protected:
+	_sk_TestInterface(const char *object_name = (const char *)NULL);
+	_sk_TestInterface(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_TestInterface() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual char * getFirstAppInList() = 0;
+	virtual void getAppNames(StringReciever_ptr arg0) = 0;
+	virtual TestInterface::sequence_of_Thing * getThings() = 0;
+	virtual void callBounce(StringReciever_ptr arg0,
+			CORBA::Long arg1) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _getFirstAppInList(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getAppNames(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getThings(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _callBounce(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_TestInterface : public TestInterface
+{
+    public:
+	_tie_TestInterface(T& t, const char *obj_name=(char*)NULL) : 
+			TestInterface(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_TestInterface(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_TestInterface() {}
+	char * getFirstAppInList() {
+		return _ref.getFirstAppInList();
+	}
+	void getAppNames(StringReciever_ptr arg0) {
+		_ref.getAppNames(
+		arg0);
+	}
+	TestInterface::sequence_of_Thing * getThings() {
+		return _ref.getThings();
+	}
+	void callBounce(StringReciever_ptr arg0,
+		CORBA::Long arg1) {
+		_ref.callBounce(
+		arg0,
+		arg1);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_ISourceTextProvider : public ISourceTextProvider
+{
+    protected:
+	_sk_ISourceTextProvider(const char *object_name = (const char *)NULL);
+	_sk_ISourceTextProvider(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_ISourceTextProvider() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual ISourceTextProvider::sequence_of_string * getAllPages() = 0;
+	virtual void refreshAllPages() = 0;
+	virtual CORBA::Boolean hasPage(const char * arg0) = 0;
+	virtual CORBA::Boolean loadPage(const char * arg0) = 0;
+	virtual void refreshPage(const char * arg0) = 0;
+	virtual char * getPageText(const char * arg0) = 0;
+	virtual CORBA::Long getPageStatus(const char * arg0) = 0;
+	virtual CORBA::Long getPageAlterCount(const char * arg0) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _getAllPages(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _refreshAllPages(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _hasPage(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _loadPage(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _refreshPage(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getPageText(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getPageStatus(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getPageAlterCount(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_ISourceTextProvider : public ISourceTextProvider
+{
+    public:
+	_tie_ISourceTextProvider(T& t, const char *obj_name=(char*)NULL) : 
+			ISourceTextProvider(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_ISourceTextProvider(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_ISourceTextProvider() {}
+	ISourceTextProvider::sequence_of_string * getAllPages() {
+		return _ref.getAllPages();
+	}
+	void refreshAllPages() {
+		_ref.refreshAllPages();
+	}
+	CORBA::Boolean hasPage(const char * arg0) {
+		return _ref.hasPage(
+		arg0);
+	}
+	CORBA::Boolean loadPage(const char * arg0) {
+		return _ref.loadPage(
+		arg0);
+	}
+	void refreshPage(const char * arg0) {
+		_ref.refreshPage(
+		arg0);
+	}
+	char * getPageText(const char * arg0) {
+		return _ref.getPageText(
+		arg0);
+	}
+	CORBA::Long getPageStatus(const char * arg0) {
+		return _ref.getPageStatus(
+		arg0);
+	}
+	CORBA::Long getPageAlterCount(const char * arg0) {
+		return _ref.getPageAlterCount(
+		arg0);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_IJSErrorReporter : public IJSErrorReporter
+{
+    protected:
+	_sk_IJSErrorReporter(const char *object_name = (const char *)NULL);
+	_sk_IJSErrorReporter(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_IJSErrorReporter() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual CORBA::Long reportError(const char * arg0,
+			const char * arg1,
+			CORBA::Long arg2,
+			const char * arg3,
+			CORBA::Long arg4) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _reportError(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_IJSErrorReporter : public IJSErrorReporter
+{
+    public:
+	_tie_IJSErrorReporter(T& t, const char *obj_name=(char*)NULL) : 
+			IJSErrorReporter(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_IJSErrorReporter(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_IJSErrorReporter() {}
+	CORBA::Long reportError(const char * arg0,
+		const char * arg1,
+		CORBA::Long arg2,
+		const char * arg3,
+		CORBA::Long arg4) {
+		return _ref.reportError(
+		arg0,
+		arg1,
+		arg2,
+		arg3,
+		arg4);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_IScriptHook : public IScriptHook
+{
+    protected:
+	_sk_IScriptHook(const char *object_name = (const char *)NULL);
+	_sk_IScriptHook(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_IScriptHook() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual void justLoadedScript(const IScript& arg0) = 0;
+	virtual void aboutToUnloadScript(const IScript& arg0) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _justLoadedScript(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _aboutToUnloadScript(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_IScriptHook : public IScriptHook
+{
+    public:
+	_tie_IScriptHook(T& t, const char *obj_name=(char*)NULL) : 
+			IScriptHook(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_IScriptHook(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_IScriptHook() {}
+	void justLoadedScript(const IScript& arg0) {
+		_ref.justLoadedScript(
+		arg0);
+	}
+	void aboutToUnloadScript(const IScript& arg0) {
+		_ref.aboutToUnloadScript(
+		arg0);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_IJSExecutionHook : public IJSExecutionHook
+{
+    protected:
+	_sk_IJSExecutionHook(const char *object_name = (const char *)NULL);
+	_sk_IJSExecutionHook(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_IJSExecutionHook() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual void aboutToExecute(const IJSThreadState& arg0,
+			const IJSPC& arg1) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _aboutToExecute(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_IJSExecutionHook : public IJSExecutionHook
+{
+    public:
+	_tie_IJSExecutionHook(T& t, const char *obj_name=(char*)NULL) : 
+			IJSExecutionHook(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_IJSExecutionHook(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_IJSExecutionHook() {}
+	void aboutToExecute(const IJSThreadState& arg0,
+		const IJSPC& arg1) {
+		_ref.aboutToExecute(
+		arg0,
+		arg1);
+	}
+
+    private:
+	T& _ref;
+};
+class _sk_IDebugController : public IDebugController
+{
+    protected:
+	_sk_IDebugController(const char *object_name = (const char *)NULL);
+	_sk_IDebugController(const char *service_name, const CORBA::ReferenceData& data);
+	virtual ~_sk_IDebugController() {}
+    public:
+	static const CORBA::TypeInfo _skel_info;
+
+	// The following operations need to be implemented by the server.
+	virtual CORBA::Long getMajorVersion() = 0;
+	virtual CORBA::Long getMinorVersion() = 0;
+	virtual IJSErrorReporter_ptr setErrorReporter(IJSErrorReporter_ptr arg0) = 0;
+	virtual IJSErrorReporter_ptr getErrorReporter() = 0;
+	virtual IScriptHook_ptr setScriptHook(IScriptHook_ptr arg0) = 0;
+	virtual IScriptHook_ptr getScriptHook() = 0;
+	virtual IJSPC * getClosestPC(const IScript& arg0,
+			CORBA::Long arg1) = 0;
+	virtual IJSSourceLocation * getSourceLocation(const IJSPC& arg0) = 0;
+	virtual IJSExecutionHook_ptr setInterruptHook(IJSExecutionHook_ptr arg0) = 0;
+	virtual IJSExecutionHook_ptr getInterruptHook() = 0;
+	virtual IJSExecutionHook_ptr setDebugBreakHook(IJSExecutionHook_ptr arg0) = 0;
+	virtual IJSExecutionHook_ptr getDebugBreakHook() = 0;
+	virtual IJSExecutionHook_ptr setInstructionHook(IJSExecutionHook_ptr arg0,
+			const IJSPC& arg1) = 0;
+	virtual IJSExecutionHook_ptr getInstructionHook(const IJSPC& arg0) = 0;
+	virtual void setThreadContinueState(CORBA::Long arg0,
+			CORBA::Long arg1) = 0;
+	virtual void setThreadReturnValue(CORBA::Long arg0,
+			const char * arg1) = 0;
+	virtual void sendInterrupt() = 0;
+	virtual void sendInterruptStepInto(CORBA::Long arg0) = 0;
+	virtual void sendInterruptStepOver(CORBA::Long arg0) = 0;
+	virtual void sendInterruptStepOut(CORBA::Long arg0) = 0;
+	virtual void reinstateStepper(CORBA::Long arg0) = 0;
+	virtual IExecResult * executeScriptInStackFrame(CORBA::Long arg0,
+			const IJSStackFrameInfo& arg1,
+			const char * arg2,
+			const char * arg3,
+			CORBA::Long arg4) = 0;
+	virtual CORBA::Boolean isRunningHook(CORBA::Long arg0) = 0;
+	virtual CORBA::Boolean isWaitingForResume(CORBA::Long arg0) = 0;
+	virtual void leaveThreadSuspended(CORBA::Long arg0) = 0;
+	virtual void resumeThread(CORBA::Long arg0) = 0;
+	virtual void iterateScripts(IScriptHook_ptr arg0) = 0;
+	
+	// Skeleton Operations implemented automatically
+	
+	static void _getMajorVersion(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getMinorVersion(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setErrorReporter(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getErrorReporter(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setScriptHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getScriptHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getClosestPC(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getSourceLocation(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setInterruptHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getInterruptHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setDebugBreakHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getDebugBreakHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setInstructionHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _getInstructionHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setThreadContinueState(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _setThreadReturnValue(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _sendInterrupt(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _sendInterruptStepInto(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _sendInterruptStepOver(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _sendInterruptStepOut(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _reinstateStepper(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _executeScriptInStackFrame(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _isRunningHook(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _isWaitingForResume(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _leaveThreadSuspended(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _resumeThread(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+	static void _iterateScripts(void *obj,
+			CORBA::MarshalStream &strm,
+			CORBA::Principal_ptr principal,
+			const char *oper,
+			void *priv_data);
+	
+};
+template <class T>
+class _tie_IDebugController : public IDebugController
+{
+    public:
+	_tie_IDebugController(T& t, const char *obj_name=(char*)NULL) : 
+			IDebugController(obj_name), 
+			_ref(t) {
+		_object_name(obj_name);
+	}
+	_tie_IDebugController(T& t, const char *service_name,
+			const CORBA::ReferenceData& id)
+			:_ref(t) {
+		_service(service_name, id);
+	}
+	~_tie_IDebugController() {}
+	CORBA::Long getMajorVersion() {
+		return _ref.getMajorVersion();
+	}
+	CORBA::Long getMinorVersion() {
+		return _ref.getMinorVersion();
+	}
+	IJSErrorReporter_ptr setErrorReporter(IJSErrorReporter_ptr arg0) {
+		return _ref.setErrorReporter(
+		arg0);
+	}
+	IJSErrorReporter_ptr getErrorReporter() {
+		return _ref.getErrorReporter();
+	}
+	IScriptHook_ptr setScriptHook(IScriptHook_ptr arg0) {
+		return _ref.setScriptHook(
+		arg0);
+	}
+	IScriptHook_ptr getScriptHook() {
+		return _ref.getScriptHook();
+	}
+	IJSPC * getClosestPC(const IScript& arg0,
+		CORBA::Long arg1) {
+		return _ref.getClosestPC(
+		arg0,
+		arg1);
+	}
+	IJSSourceLocation * getSourceLocation(const IJSPC& arg0) {
+		return _ref.getSourceLocation(
+		arg0);
+	}
+	IJSExecutionHook_ptr setInterruptHook(IJSExecutionHook_ptr arg0) {
+		return _ref.setInterruptHook(
+		arg0);
+	}
+	IJSExecutionHook_ptr getInterruptHook() {
+		return _ref.getInterruptHook();
+	}
+	IJSExecutionHook_ptr setDebugBreakHook(IJSExecutionHook_ptr arg0) {
+		return _ref.setDebugBreakHook(
+		arg0);
+	}
+	IJSExecutionHook_ptr getDebugBreakHook() {
+		return _ref.getDebugBreakHook();
+	}
+	IJSExecutionHook_ptr setInstructionHook(IJSExecutionHook_ptr arg0,
+		const IJSPC& arg1) {
+		return _ref.setInstructionHook(
+		arg0,
+		arg1);
+	}
+	IJSExecutionHook_ptr getInstructionHook(const IJSPC& arg0) {
+		return _ref.getInstructionHook(
+		arg0);
+	}
+	void setThreadContinueState(CORBA::Long arg0,
+		CORBA::Long arg1) {
+		_ref.setThreadContinueState(
+		arg0,
+		arg1);
+	}
+	void setThreadReturnValue(CORBA::Long arg0,
+		const char * arg1) {
+		_ref.setThreadReturnValue(
+		arg0,
+		arg1);
+	}
+	void sendInterrupt() {
+		_ref.sendInterrupt();
+	}
+	void sendInterruptStepInto(CORBA::Long arg0) {
+		_ref.sendInterruptStepInto(
+		arg0);
+	}
+	void sendInterruptStepOver(CORBA::Long arg0) {
+		_ref.sendInterruptStepOver(
+		arg0);
+	}
+	void sendInterruptStepOut(CORBA::Long arg0) {
+		_ref.sendInterruptStepOut(
+		arg0);
+	}
+	void reinstateStepper(CORBA::Long arg0) {
+		_ref.reinstateStepper(
+		arg0);
+	}
+	IExecResult * executeScriptInStackFrame(CORBA::Long arg0,
+		const IJSStackFrameInfo& arg1,
+		const char * arg2,
+		const char * arg3,
+		CORBA::Long arg4) {
+		return _ref.executeScriptInStackFrame(
+		arg0,
+		arg1,
+		arg2,
+		arg3,
+		arg4);
+	}
+	CORBA::Boolean isRunningHook(CORBA::Long arg0) {
+		return _ref.isRunningHook(
+		arg0);
+	}
+	CORBA::Boolean isWaitingForResume(CORBA::Long arg0) {
+		return _ref.isWaitingForResume(
+		arg0);
+	}
+	void leaveThreadSuspended(CORBA::Long arg0) {
+		_ref.leaveThreadSuspended(
+		arg0);
+	}
+	void resumeThread(CORBA::Long arg0) {
+		_ref.resumeThread(
+		arg0);
+	}
+	void iterateScripts(IScriptHook_ptr arg0) {
+		_ref.iterateScripts(
+		arg0);
+	}
+
+    private:
+	T& _ref;
+};
+
+#endif
+

mozilla/js/jsd/corba/src/IDebugController.java

@@ -0,0 +1,68 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface IDebugController extends org.omg.CORBA.Object
+{
+    public int getMajorVersion();
+    public int getMinorVersion();
+
+    public IJSErrorReporter setErrorReporter(IJSErrorReporter er);
+    public IJSErrorReporter getErrorReporter();
+
+    public IScriptHook      setScriptHook(IScriptHook h);
+    public IScriptHook      getScriptHook();
+    
+    public IJSPC            getClosestPC(IScript script, int line);
+
+    public IJSSourceLocation getSourceLocation(IJSPC pc);
+
+    public IJSExecutionHook setInterruptHook(IJSExecutionHook hook);
+    public IJSExecutionHook getInterruptHook();
+
+    public IJSExecutionHook setDebugBreakHook(IJSExecutionHook hook);
+    public IJSExecutionHook getDebugBreakHook();
+
+    public IJSExecutionHook setInstructionHook(IJSExecutionHook hook, IJSPC pc);
+    public IJSExecutionHook getInstructionHook(IJSPC pc);
+
+    public void setThreadContinueState(int threadID, int state);
+    public void setThreadReturnValue(int threadID, String value);
+
+    public void sendInterrupt();
+
+    public void sendInterruptStepInto(int threadID);
+    public void sendInterruptStepOver(int threadID);
+    public void sendInterruptStepOut(int threadID);
+
+    public void reinstateStepper(int threadID);
+
+
+    public IExecResult executeScriptInStackFrame(int threadID,
+                                                 IJSStackFrameInfo frame,
+                                                 String text,
+                                                 String filename,
+                                                 int lineno);
+
+    public boolean isRunningHook(int threadID);
+    public boolean isWaitingForResume(int threadID);
+    public void leaveThreadSuspended(int threadID);
+    public void resumeThread(int threadID);
+
+    public void iterateScripts(IScriptHook h);
+}    
+

mozilla/js/jsd/corba/src/IExecResult.java

@@ -0,0 +1,29 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IExecResult
+{
+    public String   result;
+    public boolean  errorOccured;
+    public String   errorMessage;
+    public String   errorFilename;
+    public int      errorLineNumber;
+    public String   errorLineBuffer;
+    public int      errorTokenOffset;
+}    
+

mozilla/js/jsd/corba/src/IJSErrorReporter.java

@@ -0,0 +1,32 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface IJSErrorReporter extends org.omg.CORBA.Object
+{
+    /* keep these in sync with the numbers in jsdebug.h */
+    public static final int PASS_ALONG = 0;
+    public static final int RETURN     = 1;
+    public static final int DEBUG      = 2;
+
+    public int reportError( String msg,
+                            String filename,
+                            int    lineno,
+                            String linebuf,
+                            int    tokenOffset );
+}    
+

mozilla/js/jsd/corba/src/IJSExecutionHook.java

@@ -0,0 +1,22 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface IJSExecutionHook extends org.omg.CORBA.Object
+{
+    public void aboutToExecute(IJSThreadState debug, IJSPC pc);
+}    

mozilla/js/jsd/corba/src/IJSPC.java

@@ -0,0 +1,24 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IJSPC
+{
+    public IScript script;
+    public int     offset;
+}
+

mozilla/js/jsd/corba/src/IJSSourceLocation.java

@@ -0,0 +1,23 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IJSSourceLocation
+{
+    public int      line;
+    public IJSPC    pc;
+}

mozilla/js/jsd/corba/src/IJSStackFrameInfo.java

@@ -0,0 +1,23 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IJSStackFrameInfo
+{
+    public IJSPC pc;
+    public int   jsdframe;
+}    

mozilla/js/jsd/corba/src/IJSThreadState.java

@@ -0,0 +1,65 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IJSThreadState
+{
+    /**
+     * partial list of thread states from sun.debug.ThreadInfo.
+     * XXX some of these don't apply.
+     */
+    public final static int THR_STATUS_UNKNOWN		= 0x01;
+    public final static int THR_STATUS_ZOMBIE		= 0x02;
+    public final static int THR_STATUS_RUNNING		= 0x03;
+    public final static int THR_STATUS_SLEEPING		= 0x04;
+    public final static int THR_STATUS_MONWAIT		= 0x05;
+    public final static int THR_STATUS_CONDWAIT		= 0x06;
+    public final static int THR_STATUS_SUSPENDED	= 0x07;
+    public final static int THR_STATUS_BREAK		= 0x08;
+
+
+    public final static int DEBUG_STATE_DEAD		= 0x01;
+
+    /**
+     * if the continueState is RUN, the thread will
+     * proceed to the next program counter value when it resumes.
+     */
+    public final static int DEBUG_STATE_RUN		= 0x02;
+
+    /**
+     * if the continueState is RETURN, the thread will
+     * return from the current method with the value in getReturnValue()
+     * when it resumes.
+     */
+    public final static int DEBUG_STATE_RETURN		= 0x03;
+
+    /**
+     * if the continueState is THROW, the thread will
+     * throw an exception (accessible with getException()) when it
+     * resumes.
+     */
+    public final static int DEBUG_STATE_THROW		= 0x04;
+
+
+    public IJSStackFrameInfo[]  stack;
+    public int                  continueState;
+    public String               returnValue;
+    public int                  status;
+    public int                  jsdthreadstate;
+    public int                  id;  // used for referencing this object
+}    
+

mozilla/js/jsd/corba/src/IScript.java

@@ -0,0 +1,28 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IScript
+{
+    public String url;
+    public String funname;
+    public int    base;
+    public int    extent;
+    public int    jsdscript;
+    public IScriptSection[] sections;
+}
+

mozilla/js/jsd/corba/src/IScriptHook.java

@@ -0,0 +1,24 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface IScriptHook extends org.omg.CORBA.Object
+{
+    public void justLoadedScript(IScript script);
+    public void aboutToUnloadScript(IScript script);
+}    
+

mozilla/js/jsd/corba/src/IScriptSection.java

@@ -0,0 +1,23 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class IScriptSection
+{
+    public int base;
+    public int extent;
+}    

mozilla/js/jsd/corba/src/ISourceTextProvider.java

@@ -0,0 +1,37 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface ISourceTextProvider extends org.omg.CORBA.Object
+{
+    /* these coorespond to jsdebug.h values - change in both places if anywhere */
+    public static final int INITED  = 0;
+    public static final int FULL    = 1;
+    public static final int PARTIAL = 2;
+    public static final int ABORTED = 3;
+    public static final int FAILED  = 4;
+    public static final int CLEARED = 5;
+
+    public String[] getAllPages();
+    public void     refreshAllPages();
+    public boolean  hasPage(String url);
+    public boolean  loadPage(String url);
+    public void     refreshPage(String url);
+    public String   getPageText(String url);
+    public int      getPageStatus(String url);
+    public int      getPageAlterCount(String url);
+}    

mozilla/js/jsd/corba/src/README

@@ -0,0 +1,25 @@
+/* jband - 09/09/97 - readme for the dreaded js/jsd/corba system */
+
+This stuff in js/jsd/corba/src is used to generate corba source in IDL, Java,
+and C++. The raw source is all Java. The 'makefile' is mk.bat which is currently
+expected to run only on jband's NT box. All of the important output of this
+process should be checked in to cvs. mk.bat is only needed to regenerate new
+sources as the interfaces change. Those new sources should then be committed to
+cvs.
+
+The main scheme here is to use the Java code in js/jsd/corba/src as idl.
+mk.bat uses java2idl, orbeline, and idl2java to generate IDL and stubs and
+skeletons in C++ and Java. There are a few hacks to deal with limitations of
+these tools.
+
+The C++ output is copied to js/jsd/corba.
+The Java output is copied to 
+js/jsdj/classes/com/netscape/jsdebugging/remote/corba.
+
+Note that the files:
+
+    StringReciever.java  
+    TestInterface.java  
+    Thing.java
+
+are used only in test programs and are not part of the product

mozilla/js/jsd/corba/src/StringReciever.java

@@ -0,0 +1,24 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface StringReciever extends org.omg.CORBA.Object
+{
+    public void recieveString(String s);
+    public void bounce(int count);
+}
+ 

mozilla/js/jsd/corba/src/TestInterface.java

@@ -0,0 +1,26 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public interface TestInterface extends org.omg.CORBA.Object
+{
+    public String getFirstAppInList();
+    public void   getAppNames( StringReciever sr );
+    public Thing[] getThings();
+    public void   callBounce( StringReciever sr, int count );
+}
+ 

mozilla/js/jsd/corba/src/Thing.java

@@ -0,0 +1,24 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+public final class Thing
+{
+    public String s;
+    public int    i;
+}
+ 

mozilla/js/jsd/corba/src/bogus0.java

@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//
+// This class only exist to force a forward declaration in the outputed
+// idl file.
+//
+// It should be handed to java2idl after IScriptSection.class but before
+// IScript.class
+//
+
+public final class bogus0
+{
+    public IScriptSection[] bogus;
+}    
+

mozilla/js/jsd/corba/src/bogus1.java

@@ -0,0 +1,31 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//
+// This class only exist to force a forward declaration in the outputed
+// idl file.
+//
+// It should be handed to java2idl after IJSStackFrameInfo.class but before
+// IJSThreadState.class
+//
+
+public final class bogus1
+{
+    public IJSStackFrameInfo[] bogus;
+}    
+

mozilla/js/jsd/corba/src/cutlines.awk

@@ -0,0 +1,43 @@
+# -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+#
+# see usage...
+#
+
+BEGIN {
+    skiplines_left = 0
+    if( 0 == lines || 0 == pat )
+    {
+# show usage...        
+        print "\n"
+        print "strips some lines when first line contains pattern\n"
+        print "\tusage -v pat=\"pattern\" -v lines=3"
+    }
+}
+
+{
+    if( skiplines_left )
+        skiplines_left--;
+    else
+    {
+        if( match($0, pat) != 0 )
+            skiplines_left = lines-1;
+        else
+            print $0;
+    }
+}

mozilla/js/jsd/corba/src/mk.bat

@@ -0,0 +1,143 @@
+@echo off
+REM
+REM This needs to be run from the src dir. It generates sibling dirs and their
+REM contents.
+REM
+
+set base_package=com.netscape.jsdebugging.remote.corba
+set base_packslash=com\netscape\jsdebugging\remote\corba
+set jsdj_classes_dir=..\..\..\jsdj\classes
+set DELAY=6
+
+rem -------------------------------------------------------------------------
+rem -- show settings
+echo.
+echo commandline: %0 %1 %2 %3 %4 %5 %6 %7 %8 %9
+echo.
+echo ES3_ROOT           = %ES3_ROOT%
+echo base_package       = %base_package% // set in this file
+echo jsdj_classes_dir   = %jsdj_classes_dir% // set in this file
+echo.
+rem -------------------------------------------------------------------------
+
+rem -- check for environment settings
+if "%ES3_ROOT%"         == "" goto usage
+
+set jc=sj.exe
+set cp=.;%ES3_ROOT%\wai\java\nisb.zip;%ES3_ROOT%\wai\java\WAI.zip;%ES3_ROOT%\plugins\Java\classes\serv3_0.zip
+set old_classpath=%CLASSPATH%
+set CLASSPATH=%CLASSPATH%;%ES3_ROOT%\wai\java\nisb.zip;%ES3_ROOT%\wai\java\WAI.zip
+echo.
+echo creating output dirs
+if not exist ..\class\NUL mkdir ..\class
+if not exist ..\idl\NUL   mkdir ..\idl
+if not exist ..\java\NUL  mkdir ..\java
+if not exist ..\cpp\NUL   mkdir ..\cpp
+
+echo.
+echo compiling raw Java interfaces
+%jc% -classpath %cp% *.java -d ..\class
+
+
+..\src\wait %DELAY%
+cd ..\class
+echo.
+echo.
+echo generating idl
+echo.
+REM
+REM THESE ARE HAND ORDERED TO DEAL WITH DEPENDENCIES
+REM
+%ES3_ROOT%\wai\bin\java2idl Thing.class StringReciever.class TestInterface.class ISourceTextProvider.class IScriptSection.class bogus0.class IScript.class IJSPC.class IJSSourceLocation.class IJSErrorReporter.class IScriptHook.class IJSStackFrameInfo.class bogus1.class IJSThreadState.class IJSExecutionHook.class IExecResult.class IDebugController.class > ..\idl\ifaces.idl
+
+
+..\src\wait %DELAY%
+cd ..\idl
+echo.
+echo.
+echo stripping lines from idl which were added to correctly order declarations
+echo.
+copy ifaces.idl ifaces_original.idl
+REM
+REM since we currenly have 2 of these, we can avoid the copy 
+REM
+gawk -v pat="struct bogus0" -v lines=3 -f ..\src\cutlines.awk < ifaces.idl > temp.idl
+gawk -v pat="struct bogus1" -v lines=3 -f ..\src\cutlines.awk < temp.idl > ifaces.idl
+REM copy temp.idl ifaces.idl
+
+REM ..\src\wait %DELAY%
+cd ..\cpp
+echo.
+echo.
+echo generating cpp
+echo.
+%ES3_ROOT%\wai\bin\orbeline ..\idl\ifaces.idl
+
+
+..\src\wait %DELAY%
+cd ..\java
+echo.
+echo.
+echo generating java
+echo.
+%ES3_ROOT%\wai\bin\idl2java ..\idl\ifaces.idl -package %base_package% -no_examples -no_tie -no_comments
+
+
+..\src\wait %DELAY%
+cd ..\src
+echo.
+echo. copying generated files
+echo.
+REM
+REM preserve generated java, but put ours in the outdir
+REM
+xcopy /Q ..\java\%base_packslash%\*.java ..\java\%base_packslash%\_unused\*.jav
+REM
+REM *****CUSTOMIZE HERE AS NEW INTERFACES WITH static ints ARE ADDED*****
+REM
+copy ..\src\package_header.h+..\src\ISourceTextProvider.java ..\java\%base_packslash%\ISourceTextProvider.java
+copy ..\src\package_header.h+..\src\IJSErrorReporter.java ..\java\%base_packslash%\IJSErrorReporter.java
+copy ..\src\package_header.h+..\src\IJSThreadState.java ..\java\%base_packslash%\IJSThreadState.java
+copy ..\src\package_header.h+..\src\IDebugController.java ..\java\%base_packslash%\IDebugController.java
+REM
+REM
+xcopy /Q ..\cpp\ifaces_c.hh ..\
+xcopy /Q ..\cpp\ifaces_s.hh ..\
+xcopy /Q ..\cpp\ifaces_c.cc ..\ifaces_c.cpp
+xcopy /Q ..\cpp\ifaces_s.cc ..\ifaces_s.cpp
+
+if "%jsdj_classes_dir%" == "" goto done
+if not exist %jsdj_classes_dir%\NUL  goto done
+xcopy /Q /S ..\java\*.java %jsdj_classes_dir%
+
+goto done
+
+:usage
+echo.
+echo usage:
+echo  mk
+echo.
+echo See "readme.txt" for details...
+echo.
+echo Rules:
+echo.
+echo These must be defined in environment:
+echo  ES3_ROOT      // location of Enterprise Server (e.g. e:\Netscape\SuiteSpot)
+echo.
+
+:done
+..\src\wait %DELAY%
+cd ..\src
+
+set base_package=
+set base_packslash=
+set jsdj_classes_dir=
+set cp=
+set jc=
+set DELAY=
+set CLASSPATH=%old_classpath%
+set old_classpath=
+echo.
+echo.
+echo done
+echo.

mozilla/js/jsd/corba/src/package_header.h

@@ -0,0 +1,3 @@
+
+package com.netscape.jsdebugging.remote.corba;
+ 

mozilla/js/jsd/java/jni_stubs.c

@@ -0,0 +1,35 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*                                                                          
+* This supplies non-functional stubs for a couple of JNI functions we need  
+* in order to link LiveConnect                                              
+*/                                                                          
+
+#include "jni.h"
+
+jint JNICALL JNI_GetDefaultJavaVMInitArgs(void * ignored)
+{
+    return 0;
+}    
+
+jint JNICALL JNI_CreateJavaVM(JavaVM ** vm, JNIEnv ** env, void * ignored)
+{
+    return 0;
+}    
+

mozilla/js/jsd/java/jniheadr.mak

@@ -0,0 +1,33 @@
+
+JSDJNI = .
+#CLASS_DIR_BASE = $(JSDJNI)\..\..\..\jsdj\dist\classes
+# until jsdj moves to mozilla...
+CLASS_DIR_BASE = $(JSDJNI)\..\..\..\..\..\ns\js\jsdj\dist\classes
+GEN = $(JSDJNI)\_jni
+HEADER_FILE = $(GEN)\jsdjnih.h
+
+PACKAGE_SLASH = netscape\jsdebug
+PACKAGE_DOT =   netscape.jsdebug
+
+STD_CLASSPATH = -classpath $(CLASS_DIR_BASE);$(CLASSPATH)
+
+CLASSES_WITH_NATIVES = \
+    $(PACKAGE_DOT).DebugController \
+    $(PACKAGE_DOT).JSPC \
+    $(PACKAGE_DOT).JSSourceTextProvider \
+    $(PACKAGE_DOT).JSStackFrameInfo \
+    $(PACKAGE_DOT).JSThreadState \
+    $(PACKAGE_DOT).Script \
+    $(PACKAGE_DOT).SourceTextProvider \
+    $(PACKAGE_DOT).ThreadStateBase \
+    $(PACKAGE_DOT).Value
+
+all: $(GEN)
+    @echo generating JNI headers
+    @javah -jni -o "$(HEADER_FILE)" $(STD_CLASSPATH) $(CLASSES_WITH_NATIVES)
+
+$(GEN) :
+    @mkdir $(GEN)
+
+clean: 
+    @if exist $(HEADER_FILE) @del $(HEADER_FILE) > NUL

mozilla/js/jsd/java/jre/jre.c

@@ -0,0 +1,134 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Sun Microsystems, Inc.
+ * Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
+ * modify and redistribute this software in source and binary code form,
+ * provided that i) this copyright notice and license appear on all copies of
+ * the software; and ii) Licensee does not utilize the software in a manner
+ * which is disparaging to Sun.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * This software is not designed or intended for use in on-line control of
+ * aircraft, air traffic, aircraft navigation or aircraft communications; or in
+ * the design, construction, operation or maintenance of any nuclear
+ * facility. Licensee represents and warrants that it will not use or
+ * redistribute the Software for such purposes.
+ */
+
+/*
+ * Portable JRE support functions - pared this down to minimal set I need
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <jni.h>
+#include "jre.h"
+
+/*
+ * Exits the runtime with the specified error message.
+ */
+void
+JRE_FatalError(JNIEnv *env, const char *msg)
+{
+    if ((*env)->ExceptionOccurred(env)) {
+	(*env)->ExceptionDescribe(env);
+    }
+    (*env)->FatalError(env, msg);
+}
+
+/*
+ * Parses a runtime version string. Returns 0 if the successful, otherwise
+ * returns -1 if the format of the version string was invalid.
+ */
+jint
+JRE_ParseVersion(const char *ver, char **majorp, char **minorp, char **microp)
+{
+    int n1 = 0, n2 = 0, n3 = 0;
+
+    sscanf(ver, "%*[0-9]%n.%*[0-9]%n.%*[0-9a-zA-Z]%n", &n1, &n2, &n3);
+    if (n1 == 0 || n2 == 0) {
+	return -1;
+    }
+    if (n3 != 0) {
+	if (n3 != (int)strlen(ver)) {
+	    return -1;
+	}
+    } else if (n2 != (int)strlen(ver)) {
+	return -1;
+    }
+    *majorp = JRE_Malloc(n1 + 1);
+    strncpy(*majorp, ver, n1);
+    (*majorp)[n1] = 0;
+    *minorp = JRE_Malloc(n2 - n1);
+    strncpy(*minorp, ver + n1 + 1, n2 - n1 - 1);
+    (*minorp)[n2 - n1 - 1] = 0;
+    if (n3 != 0) {
+	*microp = JRE_Malloc(n3 - n2);
+	strncpy(*microp, ver + n2 + 1, n3 - n2 - 1);
+	(*microp)[n3 - n2 - 1] = 0;
+    }
+    return 0;
+}
+
+/*
+ * Creates a version number string from the specified major, minor, and
+ * micro version numbers.
+ */
+char *
+JRE_MakeVersion(const char *major, const char *minor, const char *micro)
+{
+    char *ver = 0;
+
+    if (major != 0 && minor != 0) {
+	int len = strlen(major) + strlen(minor);
+	if (micro != 0) {
+	    ver = JRE_Malloc(len + strlen(micro) + 3);
+	    sprintf(ver, "%s.%s.%s", major, minor, micro);
+	} else {
+	    ver = JRE_Malloc(len + 2);
+	    sprintf(ver, "%s.%s", major, minor);
+	}
+    }
+    return ver;
+}
+
+/*
+ * Allocate memory or die.
+ */
+void *
+JRE_Malloc(size_t size)
+{
+    void *p = malloc(size);
+    if (p == 0) {
+	perror("malloc");
+	exit(1);
+    }
+    return p;
+}

mozilla/js/jsd/java/jre/jre.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Sun Microsystems, Inc.
+ * Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
+ * modify and redistribute this software in source and binary code form,
+ * provided that i) this copyright notice and license appear on all copies of
+ * the software; and ii) Licensee does not utilize the software in a manner
+ * which is disparaging to Sun.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * This software is not designed or intended for use in on-line control of
+ * aircraft, air traffic, aircraft navigation or aircraft communications; or in
+ * the design, construction, operation or maintenance of any nuclear
+ * facility. Licensee represents and warrants that it will not use or
+ * redistribute the Software for such purposes.
+ */
+
+/*
+ * Portable JRE support functions - pared this down to minimal set I need
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <jni.h>
+
+#include "jre_md.h"
+
+/*
+ * Java runtime settings.
+ */
+typedef struct JRESettings {
+    char *javaHome;	    /* Java home directory */
+    char *runtimeLib;	    /* Runtime shared library or DLL */
+    char *classPath;	    /* Default class path */
+    char *compiler;	    /* Just-in-time (JIT) compiler */
+    char *majorVersion;	    /* Major version of runtime */
+    char *minorVersion;	    /* Minor version of runtime */
+    char *microVersion;	    /* Micro version of runtime */
+} JRESettings;
+
+/*
+ * JRE functions.
+ */
+void *JRE_LoadLibrary(const char *path);
+void  JRE_UnloadLibrary(void *handle);
+jint JRE_GetDefaultJavaVMInitArgs(void *handle, void *vmargsp);
+jint JRE_CreateJavaVM(void *handle, JavaVM **vmp, JNIEnv **envp,
+		      void *vmargsp);
+jint JRE_GetCurrentSettings(JRESettings *set);
+jint JRE_GetSettings(JRESettings *set, const char *ver);
+jint JRE_GetDefaultSettings(JRESettings *set);
+jint JRE_ParseVersion(const char *version,
+		      char **majorp, char **minorp, char **microp);
+char *JRE_MakeVersion(const char *major, const char *minor, const char *micro);
+void *JRE_Malloc(size_t size);
+void JRE_FatalError(JNIEnv *env, const char *msg);
+char *JRE_GetDefaultRuntimeLib(const char *dir);
+char *JRE_GetDefaultClassPath(const char *dir);

mozilla/js/jsd/java/jre/win32/jre_md.c

@@ -0,0 +1,290 @@
+/*
+ * @(#)jre_md.c	1.6 97/05/15 David Connelly
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
+ * modify and redistribute this software in source and binary code form,
+ * provided that i) this copyright notice and license appear on all copies of
+ * the software; and ii) Licensee does not utilize the software in a manner
+ * which is disparaging to Sun.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * This software is not designed or intended for use in on-line control of
+ * aircraft, air traffic, aircraft navigation or aircraft communications; or in
+ * the design, construction, operation or maintenance of any nuclear
+ * facility. Licensee represents and warrants that it will not use or
+ * redistribute the Software for such purposes.
+ */
+
+/*
+ * Win32 specific JRE support functions
+ */
+
+#include <windows.h>
+#include <stdlib.h>
+#include <jni.h>
+#include "jre.h"
+
+#define JRE_KEY	    "Software\\JavaSoft\\Java Runtime Environment"
+#define JDK_KEY	    "Software\\JavaSoft\\Java Development Kit"
+
+#define RUNTIME_LIB "javai.dll"
+
+/* From jre_main.c */
+extern jboolean debug;
+
+/* Forward Declarations */
+jint LoadSettings(JRESettings *set, HKEY key);
+jint GetSettings(JRESettings *set, const char *version, const char *keyname);
+char *GetStringValue(HKEY key, const char *name);
+
+/*
+ * Retrieve settings from registry for current runtime version. Returns
+ * 0 if successful otherwise returns -1 if no installed runtime was found
+ * or the registry data was invalid.
+ */
+jint
+JRE_GetCurrentSettings(JRESettings *set)
+{
+    jint r = -1;
+    HKEY key;
+
+    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, JRE_KEY, 0, KEY_READ, &key) == 0) {
+	char *ver = GetStringValue(key, "CurrentVersion");
+	if (ver != 0) {
+	    r = JRE_GetSettings(set, ver);
+	}
+	free(ver);
+	RegCloseKey(key);
+    }
+    return r;
+}
+
+/*
+ * Retrieves settings from registry for specified runtime version.
+ * Searches for either installed JRE and JDK runtimes. Returns 0 if
+ * successful otherwise returns -1 if requested version of runtime
+ * could not be found.
+ */
+jint
+JRE_GetSettings(JRESettings *set, const char *version)
+{
+    if (GetSettings(set, version, JRE_KEY) != 0) {
+	return GetSettings(set, version, JDK_KEY);
+    }
+    return 0;
+}
+
+jint
+GetSettings(JRESettings *set, const char *version, const char *keyname)
+{
+    HKEY key;
+    int r = -1;
+
+    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyname, 0, KEY_READ, &key) == 0) {
+	char *major, *minor, *micro = 0;
+	if (JRE_ParseVersion(version, &major, &minor, &micro) == 0) {
+	    HKEY subkey;
+	    char *ver = JRE_MakeVersion(major, minor, 0);
+	    set->majorVersion = major;
+	    set->minorVersion = minor;
+	    if (RegOpenKeyEx(key, ver, 0, KEY_READ, &subkey) == 0) {
+		if ((r = LoadSettings(set, subkey)) == 0) {
+		    if (micro != 0) {
+			if (set->microVersion == 0 ||
+			    strcmp(micro, set->microVersion) != 0) {
+			    r = -1;
+			}
+		    }
+		}
+		RegCloseKey(subkey);
+	    }
+	    free(ver);
+	}
+	RegCloseKey(key);
+    }
+    return r;
+}
+
+/*
+ * Load runtime settings from specified registry key. Returns 0 if
+ * successful otherwise -1 if the registry data was invalid.
+ */
+static jint
+LoadSettings(JRESettings *set, HKEY key)
+{
+    /* Full path name of JRE home directory (required) */
+    set->javaHome = GetStringValue(key, "JavaHome");
+    if (set->javaHome == 0) {
+	return -1;
+    }
+    /* Full path name of JRE runtime DLL */
+    set->runtimeLib = GetStringValue(key, "RuntimeLib");
+    if (set->runtimeLib == 0) {
+	set->runtimeLib = JRE_GetDefaultRuntimeLib(set->javaHome);
+    }
+    /* Class path setting to override default */
+    set->classPath = GetStringValue(key, "ClassPath");
+    if (set->classPath == 0) {
+	set->classPath = JRE_GetDefaultClassPath(set->javaHome);
+    }
+    /* Optional JIT compiler library name */
+    set->compiler = GetStringValue(key, "Compiler");
+    /* Release micro-version */
+    set->microVersion = GetStringValue(key, "MicroVersion");
+    return 0;
+}
+
+/*
+ * Returns string data for the specified registry value name, or
+ * NULL if not found.
+ */
+static char *
+GetStringValue(HKEY key, const char *name)
+{
+    DWORD type, size;
+    char *value = 0;
+
+    if (RegQueryValueEx(key, name, 0, &type, 0, &size) == 0 &&
+	type == REG_SZ ) {
+	value = JRE_Malloc(size);
+	if (RegQueryValueEx(key, name, 0, 0, value, &size) != 0) {
+	    free(value);
+	    value = 0;
+	}
+    }
+    return value;
+}
+
+/*
+ * Returns default runtime settings based on location of this program.
+ * Makes best attempt at determining location of runtime. Returns 0
+ * if successful or -1 if a runtime could not be found.
+ */
+jint
+JRE_GetDefaultSettings(JRESettings *set)
+{
+    char buf[MAX_PATH], *bp;
+    int n;
+
+    // Try to obtain default value for Java home directory based on
+    // location of this executable.
+
+    if ((n = GetModuleFileName(0, buf, MAX_PATH)) == 0) {
+	return -1;
+    }
+    bp = buf + n;
+    while (*--bp != '\\') ;
+    bp -= 4;
+    if (bp < buf || strnicmp(bp, "\\bin", 4) != 0) {
+	return -1;
+    }
+    *bp = '\0';
+    set->javaHome = strdup(buf);
+
+    // Get default runtime library
+    set->runtimeLib = JRE_GetDefaultRuntimeLib(set->javaHome);
+
+    // Get default class path
+    set->classPath = JRE_GetDefaultClassPath(set->javaHome);
+
+    // Reset other fields since these are unknown
+    set->compiler = 0;
+    set->majorVersion = 0;
+    set->minorVersion = 0;
+    set->microVersion = 0;
+
+    return 0;
+}
+
+/*
+ * Return default runtime library for specified Java home directory.
+ */
+char *
+JRE_GetDefaultRuntimeLib(const char *dir)
+{
+    char *cp = JRE_Malloc(strlen(dir) + sizeof(RUNTIME_LIB) + 8);
+    sprintf(cp, "%s\\bin\\" RUNTIME_LIB, dir);
+    return cp;
+}
+
+/*
+ * Return default class path for specified Java home directory.
+ */
+char *
+JRE_GetDefaultClassPath(const char *dir)
+{
+    char *cp = JRE_Malloc(strlen(dir) * 4 + 64);
+    sprintf(cp, "%s\\lib\\rt.jar;%s\\lib\\i18n.jar;%s\\lib\\classes.zip;"
+		"%s\\classes", dir, dir, dir, dir);
+    return cp;
+}
+
+/*
+ * Loads the runtime library corresponding to 'libname' and returns
+ * an opaque handle to the library.
+ */
+void *
+JRE_LoadLibrary(const char *path)
+{
+    return (void *)LoadLibrary(path);
+}
+
+/*
+ * Unloads the runtime library associated with handle.
+ */
+void
+JRE_UnloadLibrary(void *handle)
+{
+    FreeLibrary(handle);
+}
+
+/*
+ * Loads default VM args for the specified runtime library handle.
+ */
+jint
+JRE_GetDefaultJavaVMInitArgs(void *handle, void *vmargs)
+{
+    FARPROC proc = GetProcAddress(handle, "JNI_GetDefaultJavaVMInitArgs");
+    return proc != 0 ? ((*proc)(vmargs), 0) : -1;
+}
+
+/*
+ * Creates a Java VM for the specified runtime library handle.
+ */
+jint
+JRE_CreateJavaVM(void *handle, JavaVM **vmp, JNIEnv **envp, void *vmargs)
+{
+    FARPROC proc = GetProcAddress(handle, "JNI_CreateJavaVM");
+    return proc != 0 ? (*proc)(vmp, envp, vmargs) : -1;
+}
+
+/*
+ * Entry point for JREW (Windows-only) version of the runtime loader.
+ * This entry point is called when the '-subsystem:windows' linker
+ * option is used, and will cause the resulting executable to run
+ * detached from the console.
+ */
+
+/**
+* int WINAPI
+* WinMain(HINSTANCE inst, HINSTANCE prevInst, LPSTR cmdLine, int cmdShow)
+* {
+*     __declspec(dllimport) char **__initenv;
+* 
+*     __initenv = _environ;
+*     exit(main(__argc, __argv));
+* }
+*/

mozilla/js/jsd/java/jre/win32/jre_md.h

@@ -0,0 +1,36 @@
+/*
+ * @(#)jre_md.h	1.1 97/05/19 David Connelly
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
+ * modify and redistribute this software in source and binary code form,
+ * provided that i) this copyright notice and license appear on all copies of
+ * the software; and ii) Licensee does not utilize the software in a manner
+ * which is disparaging to Sun.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * This software is not designed or intended for use in on-line control of
+ * aircraft, air traffic, aircraft navigation or aircraft communications; or in
+ * the design, construction, operation or maintenance of any nuclear
+ * facility. Licensee represents and warrants that it will not use or
+ * redistribute the Software for such purposes.
+ */
+
+/*
+ * Win32 specific JRE support definitions
+ */
+
+#define FILE_SEPARATOR	'\\'
+#define PATH_SEPARATOR	';'

mozilla/js/jsd/java/jsd_jvm.c

@@ -0,0 +1,349 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Sun Microsystems, Inc.
+ * Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ *
+ * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Sun grants you ("Licensee") a non-exclusive, royalty free, license to use,
+ * modify and redistribute this software in source and binary code form,
+ * provided that i) this copyright notice and license appear on all copies of
+ * the software; and ii) Licensee does not utilize the software in a manner
+ * which is disparaging to Sun.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
+ * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+ * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
+ * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
+ * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
+ * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
+ * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
+ * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
+ * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ * This software is not designed or intended for use in on-line control of
+ * aircraft, air traffic, aircraft navigation or aircraft communications; or in
+ * the design, construction, operation or maintenance of any nuclear
+ * facility. Licensee represents and warrants that it will not use or
+ * redistribute the Software for such purposes.
+ */
+
+/*                        
+* Code to start a Java VM (*some* code from the JRE)
+*/                        
+
+#include "jsdj.h"
+
+/***************************************************************************/
+#ifdef JSD_STANDALONE_JAVA_VM
+#include "jre.h"
+
+static char* more_classpath[] =
+{
+    {"..\\..\\jsdj\\dist\\classes"},
+    {"..\\..\\jsdj\\dist\\classes\\ifc11.jar"},
+
+/*
+*     {"..\\..\\..\\jsdj\\dist\\classes"},
+*     {"..\\..\\..\\jsdj\\dist\\classes\\ifc12.jar"},
+*/
+
+/*
+*     {"..\\..\\samples\\jslogger"},
+*     {"classes"},
+*     {"ifc12.jar"},
+*     {"jsd10.jar"},
+*     {"jsdeb15.jar"}
+*/
+};
+#define MORE_CLASSPATH_COUNT (sizeof(more_classpath)/sizeof(more_classpath[0]))
+
+/*
+* static char  main_class[]     = "callnative";
+* static char  main_class[]     = "simpleIFC";
+* static char* params[]         = {"16 Dec 1997"};
+* #define PARAM_COUNT (sizeof(params)/sizeof(params[0]))
+*/
+
+/*
+* static char  main_class[]     = "netscape/jslogger/JSLogger";
+* static char  main_class[]     = "LaunchJSDebugger";
+*/
+static char  main_class[]     = "com/netscape/jsdebugging/ifcui/launcher/local/LaunchJSDebugger";
+static char* params[]         = {NULL};
+#define PARAM_COUNT           0
+
+/* Globals */
+static char **props;		/* User-defined properties */
+static int numProps, maxProps;	/* Current, max number of properties */
+
+static void *handle;
+static JavaVM *jvm;
+static JNIEnv *env;
+
+/* Check for null value and return */
+#define NULL_CHECK(e) if ((e) == 0) return 0
+
+/*
+ * Adds a user-defined system property definition.
+ */
+void AddProperty(char *def)
+{
+    if (numProps >= maxProps) {
+        if (props == 0) {
+            maxProps = 4;
+            props = JRE_Malloc(maxProps * sizeof(char **));
+        } else {
+            char **tmp;
+            maxProps *= 2;
+            tmp = JRE_Malloc(maxProps * sizeof(char **));
+            memcpy(tmp, props, numProps * sizeof(char **));
+            free(props);
+            props = tmp;
+        }
+    }
+    props[numProps++] = def;
+}
+
+/*
+ * Deletes a property definition by name.
+ */
+void DeleteProperty(const char *name)
+{
+    int i;
+
+    for (i = 0; i < numProps; ) {
+        char *def = props[i];
+        char *c = strchr(def, '=');
+        int n;
+        if (c != 0) {
+            n = c - def;
+        } else {
+            n = strlen(def);
+        }
+        if (strncmp(name, def, n) == 0) {
+            if (i < --numProps) {
+                memmove(&props[i], &props[i+1], (numProps-i) * sizeof(char **));
+            }
+        } else {
+            i++;
+        }
+    }
+}
+
+/*
+ * Creates an array of Java string objects from the specified array of C
+ * strings. Returns 0 if the array could not be created.
+ */
+jarray NewStringArray(JNIEnv *env, char **cpp, int count)
+{
+    jclass cls;
+    jarray ary;
+    int i;
+
+    NULL_CHECK(cls = (*env)->FindClass(env, "java/lang/String"));
+    NULL_CHECK(ary = (*env)->NewObjectArray(env, count, cls, 0));
+    for (i = 0; i < count; i++) {
+        jstring str = (*env)->NewStringUTF(env, *cpp++);
+        NULL_CHECK(str);
+        (*env)->SetObjectArrayElement(env, ary, i, str);
+        (*env)->DeleteLocalRef(env, str);
+    }
+    return ary;
+}
+
+/***************************************************************************/
+
+static JNIEnv*
+_CreateJavaVM(void)
+{
+    JNIEnv* env = NULL;
+    JDK1_1InitArgs vmargs;
+    JRESettings set;
+
+    printf("Starting Java...\n");
+
+    if(JRE_GetCurrentSettings(&set) != 0)
+    {
+        if(JRE_GetDefaultSettings(&set) != 0)
+        {
+            fprintf(stderr, "Could not locate Java runtime\n");
+            return NULL;
+        }
+    }
+
+    /* Load runtime library */
+    handle = JRE_LoadLibrary(set.runtimeLib);
+    if (handle == 0) {
+        fprintf(stderr, "Could not load runtime library: %s\n",
+                set.runtimeLib);
+        return NULL;
+    }
+
+    /* Add pre-defined system properties */
+    if (set.javaHome != 0) {
+        char *def = JRE_Malloc(strlen(set.javaHome) + 16);
+        sprintf(def, "java.home=%s", set.javaHome);
+        AddProperty(def);
+    }
+
+    if (set.compiler != 0) {
+        char *def = JRE_Malloc(strlen(set.compiler) + 16);
+        sprintf(def, "java.compiler=%s", set.compiler);
+        AddProperty(def);
+    }
+
+    /*
+     * The following is used to specify that we require at least
+     * JNI version 1.1. Currently, this field is not checked but
+     * will be starting with JDK/JRE 1.2. The value returned after
+     * calling JNI_GetDefaultJavaVMInitArgs() is the actual JNI version
+     * supported, and is always higher that the requested version.
+     */
+    vmargs.version = 0x00010001;
+
+    if (JRE_GetDefaultJavaVMInitArgs(handle, &vmargs) != 0) {
+        fprintf(stderr, "Could not initialize Java VM\n");
+        return NULL;
+    }
+
+    /* Tack on our classpath */
+    if(MORE_CLASSPATH_COUNT)
+    {
+        int i;
+        int size = strlen(set.classPath) + 1;
+        char sep[2];
+
+        sep[0] = PATH_SEPARATOR;
+        sep[1] = 0;
+
+        for(i = 0; i < MORE_CLASSPATH_COUNT; i++)
+            size += strlen(more_classpath[i]) + 1;
+
+        vmargs.classpath = malloc(size);
+        if(vmargs.classpath == 0)
+        {
+            fprintf(stderr, "malloc error\n");
+            return NULL;
+        }
+
+        strcpy(vmargs.classpath, set.classPath);
+        for(i = 0; i < MORE_CLASSPATH_COUNT; i++)
+        {
+            strcat(vmargs.classpath, sep);
+            strcat(vmargs.classpath, more_classpath[i]);
+        }
+    }
+    else
+    {
+        vmargs.classpath = set.classPath;
+    }
+
+/*
+*     fprintf(stderr, "classpath: %s\n", vmargs.classpath);
+*/
+
+    /* Set user-defined system properties for Java VM */
+    if (props != 0) {
+        if (numProps == maxProps) {
+            char **tmp = JRE_Malloc((numProps + 1) * sizeof(char **));
+            memcpy(tmp, props, numProps * sizeof(char **));
+            free(props);
+            props = tmp;
+        }
+        props[numProps] = 0;
+        vmargs.properties = props;
+    }
+
+
+    /* verbose? */
+/*
+*     vmargs.verbose = JNI_TRUE;
+*/
+
+    /* Load and initialize Java VM */
+    if (JRE_CreateJavaVM(handle, &jvm, &env, &vmargs) != 0) {
+        fprintf(stderr, "Could not create Java VM\n");
+        return NULL;
+    }
+
+    /* Free properties */
+    if (props != 0) {
+        free(props);
+    }
+    return env;
+}
+
+static JSBool
+_StartDebuggerFE(JNIEnv* env)
+{
+    jclass clazz;
+    jmethodID mid;
+    jarray args;
+
+    /* Find class */
+    clazz = (*env)->FindClass(env, main_class);
+    if (clazz == 0) {
+        fprintf(stderr, "Class not found: %s\n", main_class);
+        return JS_FALSE;
+    }
+
+    /* Find main method of class */
+    mid = (*env)->GetStaticMethodID(env, clazz, "main",
+    				    "([Ljava/lang/String;)V");
+    if (mid == 0) {
+        fprintf(stderr, "In class %s: public static void main(String args[])"
+                        " is not defined\n");
+        return JS_FALSE;
+    }
+
+    /* Invoke main method */
+    args = NewStringArray(env, params, PARAM_COUNT);
+
+    if (args == 0) {
+        JRE_FatalError(env, "Couldn't build argument list for main\n");
+    }
+    (*env)->CallStaticVoidMethod(env, clazz, mid, args);
+    if ((*env)->ExceptionOccurred(env)) {
+        (*env)->ExceptionDescribe(env);
+    }
+
+    return JS_TRUE;
+}
+
+JNIEnv*
+jsdj_CreateJavaVMAndStartDebugger(JSDJContext* jsdjc)
+{
+    JNIEnv* env = NULL;
+
+    env = _CreateJavaVM();
+    if( ! env )
+        return NULL;
+
+    jsdj_SetJNIEnvForCurrentThread(jsdjc, env);
+    if( !  jsdj_RegisterNatives(jsdjc) )
+        return NULL;
+    if( ! _StartDebuggerFE(env) )
+        return NULL;
+
+    return env;
+}
+
+
+#endif /* JSD_STANDALONE_JAVA_VM */
+/***************************************************************************/
+

mozilla/js/jsd/java/jsdj.h

@@ -0,0 +1,147 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+* Header for JavaScript Debugger JNI support (internal functions)
+*/
+
+#ifndef jsdj_h___
+#define jsdj_h___
+
+/* Get jstypes.h included first. After that we can use PR macros for doing
+*  this extern "C" stuff!
+*/ 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "jstypes.h"
+#ifdef __cplusplus
+}
+#endif
+
+JS_BEGIN_EXTERN_C
+#include "jsutil.h" /* Added by JSIFY */
+#include "jshash.h" /* Added by JSIFY */
+#include "jsdjava.h"
+#include "jsobj.h"
+#include "jsfun.h"
+#include "jsdbgapi.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+JS_END_EXTERN_C
+
+JS_BEGIN_EXTERN_C
+
+/***************************************************************************/
+/* defines copied from Java sources.
+** NOTE: javah used to put these in the h files, but with JNI does not seem
+** to do this anymore. Be careful with synchronization of these
+**
+*/
+
+/* From: ThreadStateBase.java  */
+
+#define THR_STATUS_UNKNOWN      0x01
+#define THR_STATUS_ZOMBIE       0x02
+#define THR_STATUS_RUNNING      0x03
+#define THR_STATUS_SLEEPING     0x04
+#define THR_STATUS_MONWAIT      0x05
+#define THR_STATUS_CONDWAIT     0x06
+#define THR_STATUS_SUSPENDED    0x07
+#define THR_STATUS_BREAK        0x08
+
+#define DEBUG_STATE_DEAD        0x01
+#define DEBUG_STATE_RUN         0x02
+#define DEBUG_STATE_RETURN      0x03
+#define DEBUG_STATE_THROW       0x04
+
+/***************************************************************************/
+/* Our structures */
+
+typedef struct JSDJContext
+{
+    JSDContext*           jsdc;
+    JSHashTable*          envTable;
+    jobject               controller;
+    JSDJ_UserCallbacks    callbacks;
+    void*                 user;
+    JSBool                ownJSDC;
+} JSDJContext;
+
+/***************************************************************************/
+/* Code validation support */
+
+#ifdef DEBUG
+extern void JSDJ_ASSERT_VALID_CONTEXT(JSDJContext* jsdjc);
+#else
+#define JSDJ_ASSERT_VALID_CONTEXT(x)     ((void)0)
+#endif
+
+/***************************************************************************/
+/* higher level functions */
+
+extern JSDJContext*
+jsdj_SimpleInitForSingleContextMode(JSDContext* jsdc,
+                                    JSDJ_GetJNIEnvProc getEnvProc, void* user);
+extern JSBool
+jsdj_SetSingleContextMode();
+
+extern JSDJContext*
+jsdj_CreateContext();
+
+extern void
+jsdj_DestroyContext(JSDJContext* jsdjc);
+
+extern void
+jsdj_SetUserCallbacks(JSDJContext* jsdjc, JSDJ_UserCallbacks* callbacks, 
+                      void* user);
+extern void
+jsdj_SetJNIEnvForCurrentThread(JSDJContext* jsdjc, JNIEnv* env);
+
+extern JNIEnv*
+jsdj_GetJNIEnvForCurrentThread(JSDJContext* jsdjc);
+
+extern void
+jsdj_SetJSDContext(JSDJContext* jsdjc, JSDContext* jsdc);
+
+extern JSDContext*
+jsdj_GetJSDContext(JSDJContext* jsdjc);
+
+extern JSBool
+jsdj_RegisterNatives(JSDJContext* jsdjc);
+
+/***************************************************************************/
+#ifdef JSD_STANDALONE_JAVA_VM
+
+extern JNIEnv*
+jsdj_CreateJavaVMAndStartDebugger(JSDJContext* jsdjc);
+
+/**
+* extern JNIEnv*
+* jsdj_CreateJavaVM(JSDContext* jsdc);
+*/
+
+#endif /* JSD_STANDALONE_JAVA_VM */
+/***************************************************************************/
+
+JS_END_EXTERN_C
+
+#endif /* jsdj_h___ */
+

mozilla/js/jsd/java/jsdjava.c

@@ -0,0 +1,110 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*                                          
+* Public functions to reflect JSD into Java 
+*/                                          
+
+#include "jsdj.h"
+
+JSDJ_PUBLIC_API(JSDJContext*)
+JSDJ_SimpleInitForSingleContextMode(JSDContext* jsdc,
+                                    JSDJ_GetJNIEnvProc getEnvProc, void* user)
+{
+    return jsdj_SimpleInitForSingleContextMode(jsdc, getEnvProc, user);
+}
+
+JSDJ_PUBLIC_API(JSBool)
+JSDJ_SetSingleContextMode()
+{
+    return jsdj_SetSingleContextMode();
+}
+
+JSDJ_PUBLIC_API(JSDJContext*)
+JSDJ_CreateContext()
+{
+    return jsdj_CreateContext();
+}
+
+JSDJ_PUBLIC_API(void)
+JSDJ_DestroyContext(JSDJContext* jsdjc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    jsdj_DestroyContext(jsdjc);
+}
+
+JSDJ_PUBLIC_API(void)
+JSDJ_SetUserCallbacks(JSDJContext* jsdjc, JSDJ_UserCallbacks* callbacks, 
+                      void* user)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    JS_ASSERT(!callbacks ||
+              (callbacks->size > 0 && 
+               callbacks->size <= sizeof(JSDJ_UserCallbacks)));
+    jsdj_SetUserCallbacks(jsdjc, callbacks, user);
+}        
+
+JSDJ_PUBLIC_API(void)
+JSDJ_SetJNIEnvForCurrentThread(JSDJContext* jsdjc, JNIEnv* env)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    JS_ASSERT(env);
+    jsdj_SetJNIEnvForCurrentThread(jsdjc, env);
+}
+
+JSDJ_PUBLIC_API(JNIEnv*)
+JSDJ_GetJNIEnvForCurrentThread(JSDJContext* jsdjc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    return jsdj_GetJNIEnvForCurrentThread(jsdjc);
+}
+
+JSDJ_PUBLIC_API(void)
+JSDJ_SetJSDContext(JSDJContext* jsdjc, JSDContext* jsdc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    JS_ASSERT(jsdc);
+    jsdj_SetJSDContext(jsdjc, jsdc);
+}
+
+JSDJ_PUBLIC_API(JSDContext*)
+JSDJ_GetJSDContext(JSDJContext* jsdjc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    return jsdj_GetJSDContext(jsdjc);
+}
+
+JSDJ_PUBLIC_API(JSBool)
+JSDJ_RegisterNatives(JSDJContext* jsdjc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    return jsdj_RegisterNatives(jsdjc);
+}
+
+/***************************************************************************/
+#ifdef JSD_STANDALONE_JAVA_VM
+
+JSDJ_PUBLIC_API(JNIEnv*)
+JSDJ_CreateJavaVMAndStartDebugger(JSDJContext* jsdjc)
+{
+    JSDJ_ASSERT_VALID_CONTEXT(jsdjc);
+    return jsdj_CreateJavaVMAndStartDebugger(jsdjc);
+}
+
+#endif /* JSD_STANDALONE_JAVA_VM */
+/***************************************************************************/

mozilla/js/jsd/java/jsdjava.h

@@ -0,0 +1,133 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+* Header for JavaScript Debugger JNI interfaces
+*/
+
+#ifndef jsdjava_h___
+#define jsdjava_h___
+
+/* Get jstypes.h included first. After that we can use PR macros for doing
+*  this extern "C" stuff!
+*/ 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "jstypes.h"
+#ifdef __cplusplus
+}
+#endif
+
+JS_BEGIN_EXTERN_C
+#include "jsdebug.h"
+#include "jni.h"
+JS_END_EXTERN_C
+
+
+JS_BEGIN_EXTERN_C
+
+/*
+ * The linkage of JSDJ API functions differs depending on whether the file is
+ * used within the JSDJ library or not.  Any source file within the JSDJ
+ * libraray should define EXPORT_JSDJ_API whereas any client of the library
+ * should not.
+ */
+#ifdef EXPORT_JSDJ_API
+#define JSDJ_PUBLIC_API(t)    JS_EXPORT_API(t)
+#define JSDJ_PUBLIC_DATA(t)   JS_EXPORT_DATA(t)
+#else
+#define JSDJ_PUBLIC_API(t)    JS_IMPORT_API(t)
+#define JSDJ_PUBLIC_DATA(t)   JS_IMPORT_DATA(t)
+#endif
+
+#define JSDJ_FRIEND_API(t)    JSDJ_PUBLIC_API(t)
+#define JSDJ_FRIEND_DATA(t)   JSDJ_PUBLIC_DATA(t)
+
+/***************************************************************************/
+/* Opaque typedefs for handles */
+
+typedef struct JSDJContext        JSDJContext;
+
+/***************************************************************************/
+/* High Level functions */
+
+#define JSDJ_START_SUCCESS  1
+#define JSDJ_START_FAILURE  2
+#define JSDJ_STOP           3
+
+typedef void
+(*JSDJ_StartStopProc)(JSDJContext* jsdjc, int event, void *user);
+
+typedef JNIEnv*
+(*JSDJ_GetJNIEnvProc)(JSDJContext* jsdjc, void* user);
+
+/* This struct could have more fields in future versions */
+typedef struct
+{
+    uintN              size;       /* size of this struct (init before use)*/
+    JSDJ_StartStopProc startStop;
+    JSDJ_GetJNIEnvProc getJNIEnv;
+} JSDJ_UserCallbacks;
+
+extern JSDJ_PUBLIC_API(JSDJContext*)
+JSDJ_SimpleInitForSingleContextMode(JSDContext* jsdc,
+                                    JSDJ_GetJNIEnvProc getEnvProc, void* user);
+
+extern JSDJ_PUBLIC_API(JSBool)
+JSDJ_SetSingleContextMode();
+
+extern JSDJ_PUBLIC_API(JSDJContext*)
+JSDJ_CreateContext();
+
+extern JSDJ_PUBLIC_API(void)
+JSDJ_DestroyContext(JSDJContext* jsdjc);
+
+extern JSDJ_PUBLIC_API(void)
+JSDJ_SetUserCallbacks(JSDJContext* jsdjc, JSDJ_UserCallbacks* callbacks, 
+                      void* user);
+
+extern JSDJ_PUBLIC_API(void)
+JSDJ_SetJNIEnvForCurrentThread(JSDJContext* jsdjc, JNIEnv* env);
+
+extern JSDJ_PUBLIC_API(JNIEnv*)
+JSDJ_GetJNIEnvForCurrentThread(JSDJContext* jsdjc);
+
+extern JSDJ_PUBLIC_API(void)
+JSDJ_SetJSDContext(JSDJContext* jsdjc, JSDContext* jsdc);
+
+extern JSDJ_PUBLIC_API(JSDContext*)
+JSDJ_GetJSDContext(JSDJContext* jsdjc);
+
+extern JSDJ_PUBLIC_API(JSBool)
+JSDJ_RegisterNatives(JSDJContext* jsdjc);
+
+/***************************************************************************/
+#ifdef JSD_STANDALONE_JAVA_VM
+
+extern JSDJ_PUBLIC_API(JNIEnv*)
+JSDJ_CreateJavaVMAndStartDebugger(JSDJContext* jsdjc);
+
+#endif /* JSD_STANDALONE_JAVA_VM */
+/***************************************************************************/
+
+JS_END_EXTERN_C
+
+#endif /* jsdjava_h___ */
+

mozilla/js/jsd/java/jsdjava.mak

@@ -0,0 +1,78 @@
+
+PROJ = jsdjava
+JSDJAVA = .
+JSD = $(JSDJAVA)\..
+JS = $(JSD)\..\src
+JSPROJ = js32
+JSDPROJ = jsd
+
+!IF "$(BUILD_OPT)" != ""
+OBJ = Release
+CC_FLAGS = /DNDEBUG 
+!ELSE
+OBJ = Debug
+CC_FLAGS = /DDEBUG 
+LINK_FLAGS = /DEBUG
+!ENDIF 
+
+QUIET=@
+
+CFLAGS = /nologo /MDd /W3 /Gm /GX /Zi /Od\
+         /I $(JS)\
+         /I $(JSD)\
+         /I $(JSDJAVA)\
+         /DDEBUG /DWIN32 /DXP_PC /D_WINDOWS /D_WIN32\
+         /DJSD_THREADSAFE\
+         /DEXPORT_JSDJ_API\
+         /DJSDEBUGGER\
+!IF "$(JSD_STANDALONE_JAVA_VM)" != ""
+         /I $(JSDJAVA)\jre\
+         /I $(JSDJAVA)\jre\win32\
+         /DJSD_STANDALONE_JAVA_VM\
+!ENDIF 
+         $(CC_FLAGS)\
+         /c /Fp$(OBJ)\$(PROJ).pch /Fd$(OBJ)\$(PROJ).pdb /YX -Fo$@ $<
+
+LFLAGS = /nologo /subsystem:console /DLL /incremental:no /machine:I386 \
+         $(LINK_FLAGS) /pdb:$(OBJ)\$(PROJ).pdb -out:$(OBJ)\$(PROJ).dll
+
+LLIBS = kernel32.lib advapi32.lib \
+        $(JS)\$(OBJ)\$(JSPROJ).lib $(JSD)\$(OBJ)\$(JSDPROJ).lib
+
+CPP=cl.exe
+LINK32=link.exe
+
+all: $(OBJ) $(OBJ)\$(PROJ).dll
+     
+
+$(OBJ)\$(PROJ).dll:         \
+!IF "$(JSD_STANDALONE_JAVA_VM)" != ""
+        $(OBJ)\jsd_jvm.obj  \
+        $(OBJ)\jre.obj      \
+        $(OBJ)\jre_md.obj   \
+!ENDIF 
+        $(OBJ)\jsdjava.obj  \
+        $(OBJ)\jsd_jntv.obj
+  $(QUIET)$(LINK32) $(LFLAGS) $** $(LLIBS)
+
+{$(JSDJAVA)}.c{$(OBJ)}.obj :
+  $(QUIET)$(CPP) $(CFLAGS)
+
+{$(JSDJAVA)\jre}.c{$(OBJ)}.obj :
+  $(QUIET)$(CPP) $(CFLAGS)
+
+{$(JSDJAVA)\jre\win32}.c{$(OBJ)}.obj :
+  $(QUIET)$(CPP) $(CFLAGS)
+
+$(OBJ) :
+    $(QUIET)mkdir $(OBJ)
+
+clean:
+    @echo deleting old output
+    $(QUIET)del $(OBJ)\*.pch >NUL
+    $(QUIET)del $(OBJ)\*.obj >NUL
+    $(QUIET)del $(OBJ)\*.exp >NUL
+    $(QUIET)del $(OBJ)\*.lib >NUL
+    $(QUIET)del $(OBJ)\*.idb >NUL
+    $(QUIET)del $(OBJ)\*.pdb >NUL
+    $(QUIET)del $(OBJ)\*.dll >NUL

mozilla/js/jsd/javawrap/javawrap.mak

@@ -0,0 +1,147 @@
+
+PROJ = nativejsengine
+PACKAGE_DOT =   com.netscape.nativejsengine
+
+NJSE = .
+TESTS = $(NJSE)\tests
+GEN = $(NJSE)\_jni
+JSD = $(NJSE)\..
+JS = $(JSD)\..\src
+JSDJAVA = $(JSD)\java
+
+JSPROJ      = js32
+JSDPROJ     = jsd
+JSDJAVAPROJ = jsdjava
+
+EXPORT_BIN_BASE_DIR = $(NJSE)\..\..\jsdj\dist\bin
+EXPORT_CLASSES_BASE_DIR = $(NJSE)\..\..\jsdj\dist\classes
+
+!IF "$(BUILD_OPT)" != ""
+OBJ = Release
+CC_FLAGS = /DNDEBUG 
+!ELSE
+OBJ = Debug
+CC_FLAGS = /DDEBUG 
+LINK_FLAGS = /DEBUG
+!ENDIF 
+
+QUIET=@
+
+EXPORT_BIN_DIR = $(EXPORT_BIN_BASE_DIR)\$(OBJ)
+
+STD_CLASSPATH = -classpath $(EXPORT_CLASSES_BASE_DIR);$(CLASSPATH)
+
+CFLAGS = /nologo /MDd /W3 /Gm /GX /Zi /Od\
+         /DWIN32 /DXP_PC /D_WINDOWS /D_WIN32\
+         /I $(JS)\
+         /I $(JSD)\
+         /I $(JSDJAVA)\
+         /DJSDEBUGGER\
+         /DJSD_THREADSAFE\
+         $(CC_FLAGS)\
+         /c /Fp$(OBJ)\$(PROJ).pch /Fd$(OBJ)\$(PROJ).pdb /YX -Fo$@ $<
+
+LFLAGS = /nologo /subsystem:console /incremental:no /DLL /machine:I386 \
+        $(LINK_FLAGS) /pdb:$(OBJ)\$(PROJ).pdb -out:$(OBJ)\$(PROJ).dll
+
+LLIBS = kernel32.lib advapi32.lib \
+        $(JS)\$(OBJ)\$(JSPROJ).lib \
+        $(JSD)\$(OBJ)\$(JSDPROJ).lib \
+        $(JSDJAVA)\$(OBJ)\$(JSDJAVAPROJ).lib
+
+CPP=cl.exe
+LINK32=link.exe
+
+CLASSES_WITH_NATIVES = \
+    $(PACKAGE_DOT).JSRuntime\
+    $(PACKAGE_DOT).JSContext
+
+
+all: $(GEN) $(OBJ) dlls mkjniheaders $(OBJ)\$(PROJ).dll export_binaries
+
+$(OBJ)\$(PROJ).dll:         \
+    $(OBJ)\nativejsengine.obj
+  $(QUIET)$(LINK32) $(LFLAGS) $** $(LLIBS)
+
+.c{$(OBJ)}.obj:
+  $(QUIET)$(CPP) $(CFLAGS)
+
+$(GEN) :
+    @mkdir $(GEN)
+
+$(OBJ) :
+    @mkdir $(OBJ)
+
+dlls :
+    $(QUIET)cd ..\..\src
+!IF "$(BUILD_OPT)" != ""
+    $(QUIET)nmake -f js.mak CFG="js - Win32 Release"
+!ELSE
+    $(QUIET)nmake -f js.mak CFG="js - Win32 Debug"
+!ENDIF 
+    $(QUIET)cd ..\jsd\javawrap
+    $(QUIET)cd ..
+    $(QUIET)nmake -f jsd.mak JSD_THREADSAFE=1 $(OPT)
+    $(QUIET)cd javawrap
+    $(QUIET)cd ..\java
+    $(QUIET)nmake -f jsdjava.mak $(OPT)
+    $(QUIET)cd ..\javawrap
+
+
+export_binaries : mk_export_dirs
+    @echo exporting binaries
+    $(QUIET)copy $(JS)\$(OBJ)\$(JSPROJ).dll $(EXPORT_BIN_DIR)               >NUL
+    $(QUIET)copy $(JS)\$(OBJ)\$(JSPROJ).pdb $(EXPORT_BIN_DIR)               >NUL
+    $(QUIET)copy $(JSD)\$(OBJ)\$(JSDPROJ).dll $(EXPORT_BIN_DIR)             >NUL
+    $(QUIET)copy $(JSD)\$(OBJ)\$(JSDPROJ).pdb $(EXPORT_BIN_DIR)             >NUL
+    $(QUIET)copy $(JSDJAVA)\$(OBJ)\$(JSDJAVAPROJ).dll $(EXPORT_BIN_DIR)     >NUL
+    $(QUIET)copy $(JSDJAVA)\$(OBJ)\$(JSDJAVAPROJ).pdb $(EXPORT_BIN_DIR)     >NUL
+    $(QUIET)copy $(OBJ)\$(PROJ).pdb $(EXPORT_BIN_DIR)                       >NUL
+    $(QUIET)copy $(OBJ)\$(PROJ).dll $(EXPORT_BIN_DIR)                       >NUL
+
+mkjniheaders :
+    @echo generating JNI header
+    $(QUIET)javah -jni -d "$(GEN)" $(STD_CLASSPATH) $(CLASSES_WITH_NATIVES)
+    @touch *.c >NUL
+
+mk_export_dirs:
+    @if not exist $(JS)\..\jsdj\dist\NUL     @mkdir $(JS)\..\jsdj\dist
+    @if not exist $(JS)\..\jsdj\dist\bin\NUL @mkdir $(JS)\..\jsdj\dist\bin
+    @if not exist $(EXPORT_BIN_DIR)\NUL @mkdir $(EXPORT_BIN_DIR)
+
+#mktest :
+#    @echo compiling Java test file
+#    @sj  $(JAVAFLAGS) $(TEST_CLASSPATH) $(TESTS)\Main.java
+#    @echo copying js and jsd dlls
+#    @copy $(JS)\$(OBJ)\$(JSPROJ).dll $(OBJ) >NUL
+#    @copy $(JS)\$(OBJ)\$(JSPROJ).pdb $(OBJ) >NUL
+#    @copy $(JSD)\$(OBJ)\$(JSDPROJ).dll $(OBJ) >NUL
+#    @copy $(JSD)\$(OBJ)\$(JSDPROJ).pdb $(OBJ) >NUL
+#    @copy $(TESTS)\*.js $(OBJ) >NUL
+
+clean:
+    @echo deleting old output
+    $(QUIET)del $(OBJ)\*.pch >NUL
+    $(QUIET)del $(OBJ)\*.obj >NUL
+    $(QUIET)del $(OBJ)\*.exp >NUL
+    $(QUIET)del $(OBJ)\*.lib >NUL
+    $(QUIET)del $(OBJ)\*.idb >NUL
+    $(QUIET)del $(OBJ)\*.pdb >NUL
+    $(QUIET)del $(OBJ)\*.dll >NUL
+    $(QUIET)del $(GEN)\*.h   >NUL
+
+
+deep_clean: clean
+    $(QUIET)cd ..\..\src
+!IF "$(BUILD_OPT)" != ""
+    $(QUIET)nmake -f js.mak CFG="js - Win32 Release" clean
+!ELSE
+    $(QUIET)nmake -f js.mak CFG="js - Win32 Debug" clean
+!ENDIF 
+    $(QUIET)cd ..\jsd\javawrap
+    $(QUIET)cd ..
+    $(QUIET)nmake -f jsd.mak clean
+    $(QUIET)cd javawrap
+    $(QUIET)cd ..\java
+    $(QUIET)nmake -f jsdjava.mak clean
+    $(QUIET)cd ..\javawrap

mozilla/js/jsd/javawrap/mk.bat

@@ -0,0 +1 @@
+nmake -f javawrap.mak %1 %2 %3 %4 %5

mozilla/js/jsd/javawrap/nativejsengine.c

@@ -0,0 +1,616 @@
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "_jni/com_netscape_nativejsengine_JSRuntime.h"
+#include "_jni/com_netscape_nativejsengine_JSContext.h"
+
+#include "jsapi.h"
+#include "jstypes.h"
+#include "jsutil.h" /* Added by JSIFY */
+
+#ifdef JSDEBUGGER
+#include "jsdebug.h"
+#include "jsdjava.h"
+#endif
+
+/***************************************************************************/
+
+#define ASSERT_RETURN_VOID(x)   \
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        JS_ASSERT(0);           \
+        return;                 \
+    }                           \
+JS_END_MACRO
+
+#define ASSERT_RETURN_VALUE(x,v)\
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        JS_ASSERT(0);           \
+        return v;               \
+    }                           \
+JS_END_MACRO
+
+#define CHECK_RETURN_VOID(x)    \
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        return;                 \
+    }                           \
+JS_END_MACRO
+
+#define CHECK_RETURN_VALUE(x,v) \
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        return v;               \
+    }                           \
+JS_END_MACRO
+
+#define ASSERT_GOTO(x,w)        \
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        JS_ASSERT(0);           \
+        goto w;                 \
+    }                           \
+JS_END_MACRO
+
+#define CHECK_GOTO(x,w)         \
+JS_BEGIN_MACRO                  \
+    if(!(x))                    \
+    {                           \
+        goto w;                 \
+    }                           \
+JS_END_MACRO
+
+#ifdef DEBUG
+#define ASSERT_CLEAR_EXCEPTION(e)   \
+JS_BEGIN_MACRO                      \
+    if((*e)->ExceptionOccurred(e))  \
+    {                               \
+        (*e)->ExceptionDescribe(e); \
+        JS_ASSERT(0);               \
+    }                               \
+    (*e)->ExceptionClear(e);        \
+JS_END_MACRO
+#else  /* ! DEBUG */
+#define ASSERT_CLEAR_EXCEPTION(e) (*e)->ExceptionClear(e)
+#endif /* DEBUG */
+
+#define CHECK_CLEAR_EXCEPTION(e) (*e)->ExceptionClear(e)
+
+/***************************************************************************/
+
+typedef struct ContextInfo {
+    JNIEnv* env;
+    jobject contextObject;
+} ContextInfo;
+
+/***************************************************************************/
+
+#ifdef JSDEBUGGER
+static void
+_jamSourceIntoJSD(JSContext *cx, const char* src, int len, const char* filename)
+{
+    jclass clazz_self;
+    jclass clazz;
+    JSDJContext* jsdjc;
+    jobject rtObject;
+    jobject contextObject;
+    jmethodID mid;
+    jfieldID fid;
+    ContextInfo* info;
+    JNIEnv* env;
+
+    info = (ContextInfo*) JS_GetContextPrivate(cx);
+    ASSERT_RETURN_VOID(info);
+
+    env = info->env;
+    ASSERT_RETURN_VOID(env);
+
+    contextObject = info->contextObject;
+    ASSERT_RETURN_VOID(contextObject);
+
+    clazz_self = (*env)->GetObjectClass(env, contextObject);
+    ASSERT_RETURN_VOID(clazz_self);
+
+    fid = (*env)->GetFieldID(env, clazz_self, "_runtime", 
+                             "Lcom/netscape/nativejsengine/JSRuntime;");
+    ASSERT_RETURN_VOID(fid);
+
+    rtObject = (*env)->GetObjectField(env, contextObject, fid);
+    ASSERT_RETURN_VOID(rtObject);
+
+    clazz = (*env)->GetObjectClass(env, rtObject);
+    ASSERT_RETURN_VOID(clazz);
+
+    mid  = (*env)->GetMethodID(env, clazz, "getNativeDebugSupport", "()J");
+    ASSERT_RETURN_VOID(mid);
+
+    jsdjc = (JSDJContext*) (*env)->CallObjectMethod(env, rtObject, mid);
+    if(jsdjc)
+    {
+        JSDContext* jsdc;
+
+        jsdc = JSDJ_GetJSDContext(jsdjc);
+        ASSERT_RETURN_VOID(jsdc);
+
+        JSD_AddFullSourceText(jsdc, src, len, filename);
+    }
+}
+#endif   
+
+static JSBool
+_loadSingleFile(JSContext *cx, JSObject *obj, const char* filename)
+{
+    char* buf;
+    FILE* file;
+    int file_len;
+    jsval result;
+
+    errno = 0;
+    file = fopen(filename, "rb");
+    if (!file) {
+        JS_ReportError(cx, "can't open %s: %s", filename, strerror(errno));
+        return JS_FALSE;
+    }
+
+    fseek(file, 0, SEEK_END);
+    file_len = ftell(file);
+    fseek(file, 0, SEEK_SET);
+
+    if(! file_len) {
+        fclose(file);
+        JS_ReportError(cx, "%s is empty", filename);
+        return JS_FALSE;
+    }
+
+    buf = (char*) malloc(file_len);
+    if(! buf) {
+        fclose(file);
+        JS_ReportError(cx, "memory alloc error while trying to read %s", filename);
+        return JS_FALSE;
+    }
+    fread(buf, 1, file_len, file);
+    fclose(file);
+
+#ifdef JSDEBUGGER
+    _jamSourceIntoJSD(cx, buf, file_len, filename);
+#endif   
+
+    JS_EvaluateScript(cx, obj, buf, file_len, filename, 1, &result);
+
+    free(buf);
+    return JS_TRUE;
+}    
+                
+
+static void _sendPrintStringToJava(JNIEnv* env, jobject contextObject,
+                                   jmethodID mid, const char* str)
+{
+    if(! str)
+        return;
+    (*env)->CallObjectMethod(env, contextObject, mid, 
+                             (*env)->NewStringUTF(env, str));
+}
+
+static JSBool
+Print(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    uintN i, n;
+    JSString *str;
+
+    ContextInfo* info;
+    jmethodID mid;
+    jclass clazz;
+    JNIEnv* env;
+
+    info = (ContextInfo*) JS_GetContextPrivate(cx);
+    ASSERT_RETURN_VALUE(info, JS_FALSE);
+
+    env = info->env;
+    ASSERT_RETURN_VALUE(env, JS_FALSE);
+
+    clazz = (*env)->GetObjectClass(env, info->contextObject);
+    ASSERT_RETURN_VALUE(clazz, JS_FALSE);
+
+    mid  = (*env)->GetMethodID(env, clazz, "_print", "(Ljava/lang/String;)V");
+    ASSERT_RETURN_VALUE(mid, JS_FALSE);
+
+    for (i = n = 0; i < argc; i++) {
+        str = JS_ValueToString(cx, argv[i]);
+        if (!str)
+            return JS_FALSE;
+
+        if(i)
+            _sendPrintStringToJava(env, info->contextObject, mid, "");
+        _sendPrintStringToJava(env, info->contextObject, mid, JS_GetStringBytes(str));
+        n++;
+    }
+    if (n)
+        _sendPrintStringToJava(env, info->contextObject, mid, "\n");
+    return JS_TRUE;
+}
+
+static JSBool
+Version(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    if (argc > 0 && JSVAL_IS_INT(argv[0]))
+        *rval = INT_TO_JSVAL(JS_SetVersion(cx, JSVAL_TO_INT(argv[0])));
+    else
+        *rval = INT_TO_JSVAL(JS_GetVersion(cx));
+    return JS_TRUE;
+}
+
+static JSBool
+Load(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    uintN i;
+    JSString *str;
+    const char *filename;
+
+    for (i = 0; i < argc; i++) {
+        str = JS_ValueToString(cx, argv[i]);
+        if (!str)
+            return JS_FALSE;
+        argv[i] = STRING_TO_JSVAL(str);
+        filename = JS_GetStringBytes(str);
+
+        if(! _loadSingleFile(cx, obj, filename))
+            return JS_FALSE;
+    }
+    return JS_TRUE;
+}
+
+static JSFunctionSpec shell_functions[] = {
+    {"version",         Version,        0},
+    {"load",            Load,           1},
+    {"print",           Print,          0},
+    {0}
+};
+
+static void
+my_ErrorReporter(JSContext *cx, const char *message, JSErrorReport *report)
+{
+    ContextInfo* info;
+    jmethodID mid;
+    jclass clazz;
+    JNIEnv* env;
+
+    jobject msg      = NULL;
+    jobject filename = NULL;
+    jobject lineBuf  = NULL;
+    int lineno = 0;
+    int offset = 0;
+
+    info = (ContextInfo*) JS_GetContextPrivate(cx);
+    ASSERT_RETURN_VOID(info);
+
+    env = info->env;
+    ASSERT_RETURN_VOID(env);
+
+    clazz = (*env)->GetObjectClass(env, info->contextObject);
+    ASSERT_RETURN_VOID(clazz);
+
+    mid  = (*env)->GetMethodID(env, clazz, "_reportError", 
+            "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;I)V");
+    ASSERT_RETURN_VOID(mid);
+
+
+    if(message)
+        msg = (*env)->NewStringUTF(env, message);
+
+    if(report)
+    {
+        lineno = report->lineno;
+        if(report->filename)
+            filename = (*env)->NewStringUTF(env, report->filename);
+
+        if(report->linebuf)
+        {
+            lineBuf = (*env)->NewStringUTF(env, report->linebuf);
+            if(report->tokenptr)
+                offset = report->tokenptr - report->linebuf;
+        }
+    }
+
+    (*env)->CallObjectMethod(env, info->contextObject, mid, 
+                             msg, filename, lineno, lineBuf, offset);
+
+}
+
+static JSClass global_class = {
+    "global", 0,
+    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
+    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub
+};
+
+/*
+ * Class:     com_netscape_nativejsengine_JSRuntime
+ * Method:    _init
+ * Signature: (Z)Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_netscape_nativejsengine_JSRuntime__1init
+  (JNIEnv * env, jobject self, jboolean enableDebugging)
+{
+    JSRuntime *rt;
+    jclass clazz;
+    jfieldID fid;
+
+    rt = JS_NewRuntime(8L * 1024L * 1024L);
+    ASSERT_RETURN_VALUE(rt, JNI_FALSE);
+
+    clazz = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VALUE(clazz, JNI_FALSE);
+
+    fid = (*env)->GetFieldID(env, clazz, "_nativeRuntime", "J");
+    ASSERT_RETURN_VALUE(fid, JNI_FALSE);
+    (*env)->SetLongField(env, self, fid, (long) rt);
+
+
+#ifdef JSDEBUGGER
+    if(enableDebugging)
+    {
+        JSDJContext* jsdjc;
+        JSDContext* jsdc;
+
+        jsdc = JSD_DebuggerOnForUser(rt, NULL, NULL);
+        ASSERT_RETURN_VALUE(jsdc, JNI_FALSE);
+
+        jsdjc = JSDJ_CreateContext();
+        ASSERT_RETURN_VALUE(jsdjc, JNI_FALSE);
+
+        JSDJ_SetJSDContext(jsdjc, jsdc);
+        JSDJ_SetJNIEnvForCurrentThread(jsdjc, env);
+
+        fid = (*env)->GetFieldID(env, clazz, "_nativeDebugSupport", "J");
+        ASSERT_RETURN_VALUE(fid, JNI_FALSE);
+        (*env)->SetLongField(env, self, fid, (long) jsdjc);
+    }
+#else
+    if(enableDebugging)
+        printf("ERROR - Context created with enableDebugging flag, but no debugging support compiled in!");
+#endif
+
+    return JNI_TRUE;
+}
+
+/*
+ * Class:     com_netscape_nativejsengine_JSRuntime
+ * Method:    _exit
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_netscape_nativejsengine_JSRuntime__1exit
+  (JNIEnv * env, jobject self)
+{
+    jfieldID fid;
+    jclass clazz;
+    JSRuntime *rt;
+    JSContext *iterp = NULL;
+
+    clazz = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VOID(clazz);
+
+    fid = (*env)->GetFieldID(env, clazz, "_nativeRuntime", "J");
+    ASSERT_RETURN_VOID(fid);
+    rt = (JSRuntime *) (*env)->GetLongField(env, self, fid);
+    ASSERT_RETURN_VOID(rt);
+
+
+    /* 
+    * Can't kill runtime if it holds any contexts
+    *  
+    * However, JSD may make it's own context(s), so don't ASSERT 
+    */ 
+    CHECK_RETURN_VOID(!JS_ContextIterator(rt, &iterp));
+
+    printf("runtime = %d\n", (int)rt);
+
+    JS_DestroyRuntime(rt);
+}
+
+/***************************************************************************/
+
+/*
+ * Class:     com_netscape_nativejsengine_JSContext
+ * Method:    _init
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_netscape_nativejsengine_JSContext__1init
+  (JNIEnv *env, jobject self)
+{
+    JSContext *cx;
+    JSObject *glob;
+    jfieldID fid;
+    jmethodID mid;
+    JSRuntime *rt;
+    jobject rtObject;
+    jclass clazz;
+    jclass clazz_self;
+    JSBool ok;
+    ContextInfo* info;
+
+#ifdef JSDEBUGGER
+    JSDJContext* jsdjc;
+#endif
+
+    clazz_self = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VALUE(clazz_self, JNI_FALSE);
+
+    fid = (*env)->GetFieldID(env, clazz_self, "_runtime", 
+                             "Lcom/netscape/nativejsengine/JSRuntime;");
+    ASSERT_RETURN_VALUE(fid, JNI_FALSE);
+
+    rtObject = (*env)->GetObjectField(env, self, fid);
+    ASSERT_RETURN_VALUE(rtObject, JNI_FALSE);
+
+    clazz = (*env)->GetObjectClass(env, rtObject);
+    ASSERT_RETURN_VALUE(clazz, JNI_FALSE);
+
+    mid  = (*env)->GetMethodID(env, clazz, "getNativeRuntime", "()J");
+    ASSERT_RETURN_VALUE(mid, JNI_FALSE);
+    
+    rt = (JSRuntime *) (*env)->CallObjectMethod(env, rtObject, mid);
+    ASSERT_RETURN_VALUE(rt, JNI_FALSE);
+
+    cx = JS_NewContext(rt, 8192);
+    ASSERT_RETURN_VALUE(cx, JNI_FALSE);
+
+    JS_SetErrorReporter(cx, my_ErrorReporter);
+
+    glob = JS_NewObject(cx, &global_class, NULL, NULL);
+    ASSERT_RETURN_VALUE(glob, JNI_FALSE);
+
+    ok = JS_InitStandardClasses(cx, glob);
+    ASSERT_RETURN_VALUE(ok, JNI_FALSE);
+
+    ok = JS_DefineFunctions(cx, glob, shell_functions);
+    ASSERT_RETURN_VALUE(ok, JNI_FALSE);
+
+    fid = (*env)->GetFieldID(env, clazz_self, "_nativeContext", "J");
+    ASSERT_RETURN_VALUE(fid, JNI_FALSE);
+    (*env)->SetLongField(env, self, fid, (long) cx);
+
+
+    info = (ContextInfo*) malloc(sizeof(ContextInfo));
+    ASSERT_RETURN_VALUE(info, JNI_FALSE);
+    
+    info->env = env;
+    info->contextObject = self;
+
+    JS_SetContextPrivate(cx, info);
+
+#ifdef JSDEBUGGER
+    mid  = (*env)->GetMethodID(env, clazz, "getNativeDebugSupport", "()J");
+    ASSERT_RETURN_VALUE(mid, JNI_FALSE);
+
+    jsdjc = (JSDJContext*) (*env)->CallObjectMethod(env, rtObject, mid);
+    if(jsdjc)
+    {
+        JSDContext* jsdc = JSDJ_GetJSDContext(jsdjc);
+        ASSERT_RETURN_VALUE(jsdc, JNI_FALSE);
+
+        JSDJ_SetJNIEnvForCurrentThread(jsdjc, env);
+        JSD_JSContextInUse(jsdc, cx);
+    }
+#endif
+
+    return JNI_TRUE;
+}
+
+/*
+ * Class:     com_netscape_nativejsengine_JSContext
+ * Method:    _exit
+ * Signature: ()V
+ */
+JNIEXPORT void JNICALL Java_com_netscape_nativejsengine_JSContext__1exit
+  (JNIEnv *env, jobject self)
+{
+    jfieldID fid;
+    jclass clazz;
+    JSContext *cx;
+    ContextInfo* info;
+
+    clazz = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VOID(clazz);
+
+    fid = (*env)->GetFieldID(env, clazz, "_nativeContext", "J");
+    ASSERT_RETURN_VOID(fid);
+
+    cx = (JSContext *) (*env)->GetLongField(env, self, fid);
+    ASSERT_RETURN_VOID(cx);
+
+    info = (ContextInfo*) JS_GetContextPrivate(cx);
+    ASSERT_RETURN_VOID(info);
+    free(info);
+
+    printf("context = %d\n", (int)cx);
+
+    JS_DestroyContext(cx);
+}
+
+/*
+ * Class:     com_netscape_nativejsengine_JSContext
+ * Method:    _eval
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_netscape_nativejsengine_JSContext__1eval
+  (JNIEnv * env, jobject self, jstring str, jstring filename, jint lineno)
+{
+    jfieldID fid;
+    jclass clazz_self;
+    JSContext *cx;
+    JSObject *glob;
+    jsval rval;
+    int len;
+    const char* Cstr;
+    const char* Cfilename;
+    jboolean isCopy;
+
+    clazz_self = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VOID(clazz_self);
+
+    fid = (*env)->GetFieldID(env, clazz_self, "_nativeContext", "J");
+    ASSERT_RETURN_VOID(fid);
+
+    cx = (JSContext *) (*env)->GetLongField(env, self, fid);
+    ASSERT_RETURN_VOID(cx);
+
+    glob = JS_GetGlobalObject(cx);
+    ASSERT_RETURN_VOID(glob);
+
+    len = (*env)->GetStringUTFLength(env, str);
+    Cstr = (*env)->GetStringUTFChars(env, str, &isCopy); 
+    Cfilename = (*env)->GetStringUTFChars(env, filename, &isCopy);
+
+#ifdef JSDEBUGGER
+    /*                                                           
+    * XXX this just overwrites any previous source for this url! 
+    */                                                           
+    _jamSourceIntoJSD(cx, Cstr, len, Cfilename);
+#endif   
+
+    JS_EvaluateScript(cx, glob, Cstr, len, Cfilename, lineno, &rval);
+
+    (*env)->ReleaseStringUTFChars(env, str, Cstr);
+    (*env)->ReleaseStringUTFChars(env, filename, Cfilename);
+}
+
+/*
+ * Class:     com_netscape_nativejsengine_JSContext
+ * Method:    _load
+ * Signature: (Ljava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_com_netscape_nativejsengine_JSContext__1load
+  (JNIEnv *env, jobject self, jstring filename)
+{
+    jfieldID fid;
+    jclass clazz;
+    JSContext *cx;
+    const char* Cfilename;
+    jboolean isCopy;
+    JSObject *glob;
+
+    clazz = (*env)->GetObjectClass(env, self);
+    ASSERT_RETURN_VOID(clazz);
+
+    fid = (*env)->GetFieldID(env, clazz, "_nativeContext", "J");
+    ASSERT_RETURN_VOID(fid);
+
+    cx = (JSContext *) (*env)->GetLongField(env, self, fid);
+    ASSERT_RETURN_VOID(cx);
+    
+    glob = JS_GetGlobalObject(cx);
+    ASSERT_RETURN_VOID(glob);
+
+    Cfilename = (*env)->GetStringUTFChars(env, filename, &isCopy);
+
+    _loadSingleFile(cx, glob, Cfilename);
+
+    (*env)->ReleaseStringUTFChars(env, filename, Cfilename);
+}

mozilla/js/jsd/jsd.h

@@ -0,0 +1,954 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * Header for JavaScript Debugging support - Internal ONLY declarations
+ */
+
+#ifndef jsd_h___
+#define jsd_h___
+
+/*
+* NOTE: This is a *private* header file and should only be included by
+* the sources in js/jsd. Defining EXPORT_JSD_API in an outside module
+* using jsd would be bad.
+*/
+#define EXPORT_JSD_API 1 /* if used, must be set before include of jsdebug.h */
+
+/*
+* These can be controled by the makefile, but this allows a place to set
+* the values always used in the mozilla client, but perhaps done differnetly
+* in other embeddings.
+*/
+#ifdef MOZILLA_CLIENT
+#define JSD_THREADSAFE 1
+#define JSD_HAS_DANGEROUS_THREAD 1
+#define JSD_USE_NSPR_LOCKS 1
+#endif /* MOZILLA_CLIENT */
+
+
+/* Get jstypes.h included first. After that we can use PR macros for doing
+*  this extern "C" stuff!
+*/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "jstypes.h"
+#ifdef __cplusplus
+}
+#endif
+
+JS_BEGIN_EXTERN_C
+#include "jsprf.h"
+#include "jsutil.h" /* Added by JSIFY */
+#include "jshash.h" /* Added by JSIFY */
+#include "jsclist.h"
+#include "jsdebug.h"
+#include "jsapi.h"
+#include "jsobj.h"
+#include "jsfun.h"
+#include "jsdbgapi.h"
+#include "jsd_lock.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef LIVEWIRE
+#include <base/pblock.h>
+#include <base/session.h>
+#include <frame/log.h>
+#include <frame/req.h>
+#endif /* LIVEWIRE */
+JS_END_EXTERN_C
+
+JS_BEGIN_EXTERN_C
+
+#define JSD_MAJOR_VERSION 1
+#define JSD_MINOR_VERSION 1
+
+/***************************************************************************/
+/* handy macros */
+#undef  CHECK_BIT_FLAG
+#define CHECK_BIT_FLAG(f,b) ((f)&(b))
+#undef  SET_BIT_FLAG
+#define SET_BIT_FLAG(f,b)   ((f)|=(b))
+#undef  CLEAR_BIT_FLAG
+#define CLEAR_BIT_FLAG(f,b) ((f)&=(~(b)))
+
+
+/***************************************************************************/
+/* These are not exposed in jsdebug.h - typedef here for consistency */
+
+typedef struct JSDExecHook          JSDExecHook;
+typedef struct JSDAtom              JSDAtom;
+
+/***************************************************************************/
+/* Our structures */
+
+/*
+* XXX What I'm calling a JSDContext is really more of a JSDTaskState. 
+*/
+
+struct JSDContext
+{
+    JSCList                 links;      /* we are part of a JSCList */
+    JSBool                  inited;
+    JSD_ScriptHookProc      scriptHook;
+    void*                   scriptHookData;
+    JSD_ExecutionHookProc   interruptHook;
+    void*                   interruptHookData;
+    JSRuntime*              jsrt;
+    JSD_ErrorReporter       errorReporter;
+    void*                   errorReporterData;
+    JSCList                 threadsStates;
+    JSD_ExecutionHookProc   debugBreakHook;
+    void*                   debugBreakHookData;
+    JSD_ExecutionHookProc   debuggerHook;
+    void*                   debuggerHookData;
+    JSD_ExecutionHookProc   throwHook;
+    void*                   throwHookData;
+    JSContext*              dumbContext;
+    JSObject*               glob;
+    JSD_UserCallbacks       userCallbacks;
+    void*                   user;
+    JSCList                 scripts;
+    JSCList                 sources;
+    JSCList                 removedSources;
+    uintN                   sourceAlterCount;
+    JSHashTable*            atoms;
+    JSCList                 objectsList;
+    JSHashTable*            objectsTable;
+#ifdef JSD_THREADSAFE
+    void*                   scriptsLock;
+    void*                   sourceTextLock;
+    void*                   objectsLock;
+    void*                   atomsLock;
+    void*                   threadStatesLock;
+#endif /* JSD_THREADSAFE */
+#ifdef JSD_HAS_DANGEROUS_THREAD
+    void*                   dangerousThread;
+#endif /* JSD_HAS_DANGEROUS_THREAD */
+
+};
+
+struct JSDScript
+{
+    JSCList     links;      /* we are part of a JSCList */
+    JSDContext* jsdc;       /* JSDContext for this jsdscript */
+    JSScript*   script;     /* script we are wrapping */
+    JSFunction* function;   /* back pointer to owning function (can be NULL) */
+    uintN       lineBase;   /* we cache this */
+    uintN       lineExtent; /* we cache this */
+    JSCList     hooks;      /* JSCList of JSDExecHooks for this script */
+    char*       url;
+#ifdef LIVEWIRE
+    LWDBGApp*    app;
+    LWDBGScript* lwscript;
+#endif
+};
+
+struct JSDSourceText
+{
+    JSCList          links;      /* we are part of a JSCList */
+    char*            url;
+    char*            text;
+    uintN            textLength;
+    uintN            textSpace;
+    JSBool           dirty;
+    JSDSourceStatus  status;
+    uintN            alterCount;
+    JSBool           doingEval;
+};
+
+struct JSDExecHook
+{
+    JSCList               links;        /* we are part of a JSCList */
+    JSDScript*            jsdscript;
+    jsuword               pc;
+    JSD_ExecutionHookProc hook;
+    void*                 callerdata;
+};
+
+struct JSDThreadState
+{
+    JSCList             links;        /* we are part of a JSCList */
+    JSContext*          context;
+    void*               thread;
+    JSCList             stack;
+    uintN               stackDepth;
+};
+
+struct JSDStackFrameInfo
+{
+    JSCList             links;        /* we are part of a JSCList */
+    JSDThreadState*     jsdthreadstate;
+    JSDScript*          jsdscript;
+    jsuword             pc;
+    JSStackFrame*       fp;
+};
+
+#define GOT_PROTO   ((short) (1 << 0))
+#define GOT_PROPS   ((short) (1 << 1))
+#define GOT_PARENT  ((short) (1 << 2))
+#define GOT_CTOR    ((short) (1 << 3))
+
+struct JSDValue
+{
+    jsval       val;
+    intN        nref;
+    JSCList     props;
+    JSString*   string;
+    const char* funName;
+    const char* className;
+    JSDValue*   proto;
+    JSDValue*   parent;
+    JSDValue*   ctor;
+    uintN       flags;
+};
+
+struct JSDProperty
+{
+    JSCList     links;      /* we are part of a JSCList */
+    intN        nref;
+    JSDValue*   val;
+    JSDValue*   name;
+    JSDValue*   alias;
+    uintN       slot;
+    uintN       flags;
+};
+
+struct JSDAtom
+{
+    char* str;      /* must be first element in stuct for compare */
+    intN  refcount;
+};
+
+struct JSDObject
+{
+    JSCList     links;      /* we are part of a JSCList */
+    JSObject*   obj;
+    JSDAtom*    newURL;
+    uintN       newLineno;
+    JSDAtom*    ctorURL;
+    uintN       ctorLineno;
+    JSDAtom*    ctorName;
+};
+
+/***************************************************************************/
+/* Code validation support */
+
+#ifdef DEBUG
+extern void JSD_ASSERT_VALID_CONTEXT(JSDContext* jsdc);
+extern void JSD_ASSERT_VALID_SCRIPT(JSDScript* jsdscript);
+extern void JSD_ASSERT_VALID_SOURCE_TEXT(JSDSourceText* jsdsrc);
+extern void JSD_ASSERT_VALID_THREAD_STATE(JSDThreadState* jsdthreadstate);
+extern void JSD_ASSERT_VALID_STACK_FRAME(JSDStackFrameInfo* jsdframe);
+extern void JSD_ASSERT_VALID_EXEC_HOOK(JSDExecHook* jsdhook);
+extern void JSD_ASSERT_VALID_VALUE(JSDValue* jsdval);
+extern void JSD_ASSERT_VALID_PROPERTY(JSDProperty* jsdprop);
+extern void JSD_ASSERT_VALID_OBJECT(JSDObject* jsdobj);
+#else
+#define JSD_ASSERT_VALID_CONTEXT(x)     ((void)0)
+#define JSD_ASSERT_VALID_SCRIPT(x)      ((void)0)
+#define JSD_ASSERT_VALID_SOURCE_TEXT(x) ((void)0)
+#define JSD_ASSERT_VALID_THREAD_STATE(x)((void)0)
+#define JSD_ASSERT_VALID_STACK_FRAME(x) ((void)0)
+#define JSD_ASSERT_VALID_EXEC_HOOK(x)   ((void)0)
+#define JSD_ASSERT_VALID_VALUE(x)       ((void)0)
+#define JSD_ASSERT_VALID_PROPERTY(x)    ((void)0)
+#define JSD_ASSERT_VALID_OBJECT(x)      ((void)0)
+#endif
+
+/***************************************************************************/
+/* higher level functions */
+
+extern JSDContext*
+jsd_DebuggerOnForUser(JSRuntime*         jsrt,
+                      JSD_UserCallbacks* callbacks,
+                      void*              user);
+extern JSDContext*
+jsd_DebuggerOn(void);
+
+extern void
+jsd_DebuggerOff(JSDContext* jsdc);
+
+extern void
+jsd_SetUserCallbacks(JSRuntime* jsrt, JSD_UserCallbacks* callbacks, void* user);
+
+extern JSDContext*
+jsd_JSDContextForJSContext(JSContext* context);
+
+extern JSBool
+jsd_SetErrorReporter(JSDContext*       jsdc,
+                     JSD_ErrorReporter reporter,
+                     void*             callerdata);
+
+extern JSBool
+jsd_GetErrorReporter(JSDContext*        jsdc,
+                     JSD_ErrorReporter* reporter,
+                     void**             callerdata);
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+jsd_DebugErrorHook(JSContext *cx, const char *message,
+                   JSErrorReport *report, void *closure);
+
+/***************************************************************************/
+/* Script functions */
+
+extern void
+jsd_DestroyAllJSDScripts(JSDContext* jsdc);
+
+extern JSDScript*
+jsd_FindJSDScript(JSDContext*  jsdc,
+                  JSScript     *script);
+
+extern JSDScript*
+jsd_IterateScripts(JSDContext* jsdc, JSDScript **iterp);
+
+extern JSBool
+jsd_IsActiveScript(JSDContext* jsdc, JSDScript *jsdscript);
+
+extern const char*
+jsd_GetScriptFilename(JSDContext* jsdc, JSDScript *jsdscript);
+
+extern const char*
+jsd_GetScriptFunctionName(JSDContext* jsdc, JSDScript *jsdscript);
+
+extern uintN
+jsd_GetScriptBaseLineNumber(JSDContext* jsdc, JSDScript *jsdscript);
+
+extern uintN
+jsd_GetScriptLineExtent(JSDContext* jsdc, JSDScript *jsdscript);
+
+extern JSBool
+jsd_SetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc hook, void* callerdata);
+
+extern JSBool
+jsd_GetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc* hook, void** callerdata);
+
+extern jsuword
+jsd_GetClosestPC(JSDContext* jsdc, JSDScript* jsdscript, uintN line);
+
+extern uintN
+jsd_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc);
+
+extern void JS_DLL_CALLBACK
+jsd_NewScriptHookProc(
+                JSContext   *cx,
+                const char  *filename,      /* URL this script loads from */
+                uintN       lineno,         /* line where this script starts */
+                JSScript    *script,
+                JSFunction  *fun,
+                void*       callerdata);
+
+extern void JS_DLL_CALLBACK
+jsd_DestroyScriptHookProc(
+                JSContext   *cx,
+                JSScript    *script,
+                void*       callerdata);
+
+/* Script execution hook functions */
+
+extern JSBool
+jsd_SetExecutionHook(JSDContext*           jsdc,
+                     JSDScript*            jsdscript,
+                     jsuword               pc,
+                     JSD_ExecutionHookProc hook,
+                     void*                 callerdata);
+
+extern JSBool
+jsd_ClearExecutionHook(JSDContext*           jsdc,
+                       JSDScript*            jsdscript,
+                       jsuword               pc);
+
+extern JSBool
+jsd_ClearAllExecutionHooksForScript(JSDContext* jsdc, JSDScript* jsdscript);
+
+extern JSBool
+jsd_ClearAllExecutionHooks(JSDContext* jsdc);
+
+extern void
+jsd_ScriptCreated(JSDContext* jsdc,
+                  JSContext   *cx,
+                  const char  *filename,    /* URL this script loads from */
+                  uintN       lineno,       /* line where this script starts */
+                  JSScript    *script,
+                  JSFunction  *fun);
+
+extern void
+jsd_ScriptDestroyed(JSDContext* jsdc,
+                    JSContext   *cx,
+                    JSScript    *script);
+
+/***************************************************************************/
+/* Source Text functions */
+
+extern JSDSourceText*
+jsd_IterateSources(JSDContext* jsdc, JSDSourceText **iterp);
+
+extern JSDSourceText*
+jsd_FindSourceForURL(JSDContext* jsdc, const char* url);
+
+extern const char*
+jsd_GetSourceURL(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern JSBool
+jsd_GetSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc,
+                  const char** ppBuf, intN* pLen);
+
+extern void
+jsd_ClearSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern JSDSourceStatus
+jsd_GetSourceStatus(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern JSBool
+jsd_IsSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern void
+jsd_SetSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc, JSBool dirty);
+
+extern uintN
+jsd_GetSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern uintN
+jsd_IncrementSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern JSDSourceText*
+jsd_NewSourceText(JSDContext* jsdc, const char* url);
+
+extern JSDSourceText*
+jsd_AppendSourceText(JSDContext* jsdc,
+                     JSDSourceText* jsdsrc,
+                     const char* text,       /* *not* zero terminated */
+                     size_t length,
+                     JSDSourceStatus status);
+
+extern JSDSourceText*
+jsd_AppendUCSourceText(JSDContext* jsdc,
+                       JSDSourceText* jsdsrc,
+                       const jschar* text,       /* *not* zero terminated */
+                       size_t length,
+                       JSDSourceStatus status);
+
+/* convienence function for adding complete source of url in one call */
+extern JSBool
+jsd_AddFullSourceText(JSDContext* jsdc,
+                      const char* text,       /* *not* zero terminated */
+                      size_t      length,
+                      const char* url);
+
+extern void
+jsd_DestroyAllSources(JSDContext* jsdc);
+
+extern const char*
+jsd_BuildNormalizedURL(const char* url_string);
+
+extern void
+jsd_StartingEvalUsingFilename(JSDContext* jsdc, const char* url);
+
+extern void
+jsd_FinishedEvalUsingFilename(JSDContext* jsdc, const char* url);
+
+/***************************************************************************/
+/* Interrupt Hook functions */
+
+extern JSBool
+jsd_SetInterruptHook(JSDContext*           jsdc,
+                     JSD_ExecutionHookProc hook,
+                     void*                 callerdata);
+
+extern JSBool
+jsd_ClearInterruptHook(JSDContext* jsdc);
+
+extern JSBool
+jsd_SetDebugBreakHook(JSDContext*           jsdc,
+                      JSD_ExecutionHookProc hook,
+                      void*                 callerdata);
+
+extern JSBool
+jsd_ClearDebugBreakHook(JSDContext* jsdc);
+
+extern JSBool
+jsd_SetDebuggerHook(JSDContext*           jsdc,
+                    JSD_ExecutionHookProc hook,
+                    void*                 callerdata);
+
+extern JSBool
+jsd_ClearDebuggerHook(JSDContext* jsdc);
+
+extern JSTrapStatus
+jsd_CallExecutionHook(JSDContext* jsdc,
+                      JSContext *cx,
+                      JSDHookType type,
+                      JSD_ExecutionHookProc hook,
+                      void* hookData,
+                      jsval* rval);
+
+extern JSBool
+jsd_SetThrowHook(JSDContext*           jsdc,
+                 JSD_ExecutionHookProc hook,
+                 void*                 callerdata);
+extern JSBool
+jsd_ClearThrowHook(JSDContext* jsdc);
+
+extern JSTrapStatus JS_DLL_CALLBACK
+jsd_DebuggerHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
+                    jsval *rval, void *closure);
+
+extern JSTrapStatus JS_DLL_CALLBACK
+jsd_ThrowHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
+                 jsval *rval, void *closure);
+
+/***************************************************************************/
+/* Stack Frame functions */
+
+extern uintN
+jsd_GetCountOfStackFrames(JSDContext* jsdc, JSDThreadState* jsdthreadstate);
+
+extern JSDStackFrameInfo*
+jsd_GetStackFrame(JSDContext* jsdc, JSDThreadState* jsdthreadstate);
+
+extern JSDStackFrameInfo*
+jsd_GetCallingStackFrame(JSDContext* jsdc,
+                         JSDThreadState* jsdthreadstate,
+                         JSDStackFrameInfo* jsdframe);
+
+extern JSDScript*
+jsd_GetScriptForStackFrame(JSDContext* jsdc,
+                           JSDThreadState* jsdthreadstate,
+                           JSDStackFrameInfo* jsdframe);
+
+extern jsuword
+jsd_GetPCForStackFrame(JSDContext* jsdc,
+                       JSDThreadState* jsdthreadstate,
+                       JSDStackFrameInfo* jsdframe);
+
+extern JSDValue*
+jsd_GetCallObjectForStackFrame(JSDContext* jsdc,
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe);
+
+extern JSDValue*
+jsd_GetScopeChainForStackFrame(JSDContext* jsdc,
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe);
+
+extern JSDValue*
+jsd_GetThisForStackFrame(JSDContext* jsdc,
+                         JSDThreadState* jsdthreadstate,
+                         JSDStackFrameInfo* jsdframe);
+
+extern JSDThreadState*
+jsd_NewThreadState(JSDContext* jsdc, JSContext *cx);
+
+extern void
+jsd_DestroyThreadState(JSDContext* jsdc, JSDThreadState* jsdthreadstate);
+
+extern JSBool
+jsd_EvaluateScriptInStackFrame(JSDContext* jsdc,
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe,
+                               const char *bytes, uintN length,
+                               const char *filename, uintN lineno, jsval *rval);
+
+extern JSString*
+jsd_ValToStringInStackFrame(JSDContext* jsdc,
+                            JSDThreadState* jsdthreadstate,
+                            JSDStackFrameInfo* jsdframe,
+                            jsval val);
+
+extern JSBool
+jsd_IsValidThreadState(JSDContext*        jsdc,
+                       JSDThreadState*    jsdthreadstate);
+
+extern JSBool
+jsd_IsValidFrameInThreadState(JSDContext*        jsdc,
+                              JSDThreadState*    jsdthreadstate,
+                              JSDStackFrameInfo* jsdframe);
+
+extern JSDValue*
+jsd_GetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate);
+
+extern JSBool
+jsd_SetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate, 
+                 JSDValue* jsdval);
+
+/***************************************************************************/
+/* Locking support */
+
+/* protos are in js_lock.h for:
+ *      jsd_CreateLock
+ *      jsd_Lock
+ *      jsd_Unlock
+ *      jsd_IsLocked
+ *      jsd_CurrentThread
+ */
+
+#ifdef JSD_THREADSAFE
+
+/* the system-wide lock */
+extern void* _jsd_global_lock;
+#define JSD_LOCK()                               \
+    JS_BEGIN_MACRO                               \
+        if(!_jsd_global_lock)                    \
+            _jsd_global_lock = jsd_CreateLock(); \
+        JS_ASSERT(_jsd_global_lock);             \
+        jsd_Lock(_jsd_global_lock);              \
+    JS_END_MACRO
+
+#define JSD_UNLOCK()                             \
+    JS_BEGIN_MACRO                               \
+        JS_ASSERT(_jsd_global_lock);             \
+        jsd_Unlock(_jsd_global_lock);            \
+    JS_END_MACRO
+
+/* locks for the subsystems of a given context */
+#define JSD_INIT_LOCKS(jsdc)                                    \
+    ( (NULL != (jsdc->scriptsLock      = jsd_CreateLock())) &&  \
+      (NULL != (jsdc->sourceTextLock   = jsd_CreateLock())) &&  \
+      (NULL != (jsdc->atomsLock        = jsd_CreateLock())) &&  \
+      (NULL != (jsdc->objectsLock      = jsd_CreateLock())) &&  \
+      (NULL != (jsdc->threadStatesLock = jsd_CreateLock())) )
+
+#define JSD_LOCK_SCRIPTS(jsdc)        jsd_Lock(jsdc->scriptsLock)
+#define JSD_UNLOCK_SCRIPTS(jsdc)      jsd_Unlock(jsdc->scriptsLock)
+
+#define JSD_LOCK_SOURCE_TEXT(jsdc)    jsd_Lock(jsdc->sourceTextLock)
+#define JSD_UNLOCK_SOURCE_TEXT(jsdc)  jsd_Unlock(jsdc->sourceTextLock)
+
+#define JSD_LOCK_ATOMS(jsdc)          jsd_Lock(jsdc->atomsLock)
+#define JSD_UNLOCK_ATOMS(jsdc)        jsd_Unlock(jsdc->atomsLock)
+
+#define JSD_LOCK_OBJECTS(jsdc)        jsd_Lock(jsdc->objectsLock)
+#define JSD_UNLOCK_OBJECTS(jsdc)      jsd_Unlock(jsdc->objectsLock)
+
+#define JSD_LOCK_THREADSTATES(jsdc)   jsd_Lock(jsdc->threadStatesLock)
+#define JSD_UNLOCK_THREADSTATES(jsdc) jsd_Unlock(jsdc->threadStatesLock)
+
+#else  /* !JSD_THREADSAFE */
+
+#define JSD_LOCK()                    ((void)0)
+#define JSD_UNLOCK()                  ((void)0)
+
+#define JSD_INIT_LOCKS(jsdc)          1
+
+#define JSD_LOCK_SCRIPTS(jsdc)        ((void)0)
+#define JSD_UNLOCK_SCRIPTS(jsdc)      ((void)0)
+
+#define JSD_LOCK_SOURCE_TEXT(jsdc)    ((void)0)
+#define JSD_UNLOCK_SOURCE_TEXT(jsdc)  ((void)0)
+
+#define JSD_LOCK_ATOMS(jsdc)          ((void)0)
+#define JSD_UNLOCK_ATOMS(jsdc)        ((void)0)
+
+#define JSD_LOCK_OBJECTS(jsdc)        ((void)0)
+#define JSD_UNLOCK_OBJECTS(jsdc)      ((void)0)
+
+#define JSD_LOCK_THREADSTATES(jsdc)   ((void)0)
+#define JSD_UNLOCK_THREADSTATES(jsdc) ((void)0)
+
+#endif /* JSD_THREADSAFE */
+
+/* NOTE: These are intended for ASSERTs. Thus we supply checks for both
+ * LOCKED and UNLOCKED (rather that just LOCKED and !LOCKED) so that in
+ * the DEBUG non-Threadsafe case we can have an ASSERT that always succeeds
+ * without having to special case things in the code.
+ */
+#if defined(JSD_THREADSAFE) && defined(DEBUG)
+#define JSD_SCRIPTS_LOCKED(jsdc)        (jsd_IsLocked(jsdc->scriptsLock))
+#define JSD_SOURCE_TEXT_LOCKED(jsdc)    (jsd_IsLocked(jsdc->sourceTextLock))
+#define JSD_ATOMS_LOCKED(jsdc)          (jsd_IsLocked(jsdc->atomsLock))
+#define JSD_OBJECTS_LOCKED(jsdc)        (jsd_IsLocked(jsdc->objectsLock))
+#define JSD_THREADSTATES_LOCKED(jsdc)   (jsd_IsLocked(jsdc->threadStatesLock))
+#define JSD_SCRIPTS_UNLOCKED(jsdc)      (!jsd_IsLocked(jsdc->scriptsLock))
+#define JSD_SOURCE_TEXT_UNLOCKED(jsdc)  (!jsd_IsLocked(jsdc->sourceTextLock))
+#define JSD_ATOMS_UNLOCKED(jsdc)        (!jsd_IsLocked(jsdc->atomsLock))
+#define JSD_OBJECTS_UNLOCKED(jsdc)      (!jsd_IsLocked(jsdc->objectsLock))
+#define JSD_THREADSTATES_UNLOCKED(jsdc) (!jsd_IsLocked(jsdc->threadStatesLock))
+#else
+#define JSD_SCRIPTS_LOCKED(jsdc)        1
+#define JSD_SOURCE_TEXT_LOCKED(jsdc)    1
+#define JSD_ATOMS_LOCKED(jsdc)          1
+#define JSD_OBJECTS_LOCKED(jsdc)        1
+#define JSD_THREADSTATES_LOCKED(jsdc)   1
+#define JSD_SCRIPTS_UNLOCKED(jsdc)      1
+#define JSD_SOURCE_TEXT_UNLOCKED(jsdc)  1
+#define JSD_ATOMS_UNLOCKED(jsdc)        1
+#define JSD_OBJECTS_UNLOCKED(jsdc)      1
+#define JSD_THREADSTATES_UNLOCKED(jsdc) 1
+#endif /* defined(JSD_THREADSAFE) && defined(DEBUG) */
+
+/***************************************************************************/
+/* Threading support */
+
+#ifdef JSD_THREADSAFE
+
+#define JSD_CURRENT_THREAD()        jsd_CurrentThread()
+
+#else  /* !JSD_THREADSAFE */
+
+#define JSD_CURRENT_THREAD()        ((void*)0)
+
+#endif /* JSD_THREADSAFE */
+
+/***************************************************************************/
+/* Dangerous thread support */
+
+#ifdef JSD_HAS_DANGEROUS_THREAD
+
+#define JSD_IS_DANGEROUS_THREAD(jsdc) \
+    (JSD_CURRENT_THREAD() == jsdc->dangerousThread)
+
+#else  /* !JSD_HAS_DANGEROUS_THREAD */
+
+#define JSD_IS_DANGEROUS_THREAD(jsdc)   0
+
+#endif /* JSD_HAS_DANGEROUS_THREAD */
+
+/***************************************************************************/
+/* Value and Property Functions */
+
+extern JSDValue*
+jsd_NewValue(JSDContext* jsdc, jsval val);
+
+extern void
+jsd_DropValue(JSDContext* jsdc, JSDValue* jsdval);
+
+extern jsval
+jsd_GetValueWrappedJSVal(JSDContext* jsdc, JSDValue* jsdval);
+
+extern void
+jsd_RefreshValue(JSDContext* jsdc, JSDValue* jsdval);
+
+/**************************************************/
+
+extern JSBool
+jsd_IsValueObject(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueNumber(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueInt(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueString(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueBoolean(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueNull(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueVoid(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValuePrimitive(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueFunction(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSBool
+jsd_IsValueNative(JSDContext* jsdc, JSDValue* jsdval);
+
+/**************************************************/
+
+extern JSBool
+jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval);
+
+extern int32
+jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval);
+
+extern jsdouble*
+jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSString*
+jsd_GetValueString(JSDContext* jsdc, JSDValue* jsdval);
+
+extern const char*
+jsd_GetValueFunctionName(JSDContext* jsdc, JSDValue* jsdval);
+
+/**************************************************/
+
+extern uintN
+jsd_GetCountOfProperties(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSDProperty*
+jsd_IterateProperties(JSDContext* jsdc, JSDValue* jsdval, JSDProperty **iterp);
+
+extern JSDProperty*
+jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name);
+
+extern JSDValue*
+jsd_GetValuePrototype(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSDValue*
+jsd_GetValueParent(JSDContext* jsdc, JSDValue* jsdval);
+
+extern JSDValue*
+jsd_GetValueConstructor(JSDContext* jsdc, JSDValue* jsdval);
+
+extern const char*
+jsd_GetValueClassName(JSDContext* jsdc, JSDValue* jsdval);
+
+/**************************************************/
+
+extern void
+jsd_DropProperty(JSDContext* jsdc, JSDProperty* jsdprop);
+
+extern JSDValue*
+jsd_GetPropertyName(JSDContext* jsdc, JSDProperty* jsdprop);
+
+extern JSDValue*
+jsd_GetPropertyValue(JSDContext* jsdc, JSDProperty* jsdprop);
+
+extern JSDValue*
+jsd_GetPropertyAlias(JSDContext* jsdc, JSDProperty* jsdprop);
+
+extern JSDPropertyFlags
+jsd_GetPropertyFlags(JSDContext* jsdc, JSDProperty* jsdprop);
+
+extern uintN
+jsd_GetPropertyVarArgSlot(JSDContext* jsdc, JSDProperty* jsdprop);
+
+/**************************************************/
+/* Stepping Functions */
+
+extern void * JS_DLL_CALLBACK
+jsd_InterpreterHook(JSContext *cx, JSStackFrame *fp, JSBool before,
+                    JSBool *ok, void *closure);
+
+/**************************************************/
+/* Object Functions */
+
+extern JSBool
+jsd_InitObjectManager(JSDContext* jsdc);
+
+extern void
+jsd_DestroyObjectManager(JSDContext* jsdc);
+
+extern void JS_DLL_CALLBACK
+jsd_ObjectHook(JSContext *cx, JSObject *obj, JSBool isNew, void *closure);
+
+extern void
+jsd_Constructing(JSDContext* jsdc, JSContext *cx, JSObject *obj,
+                 JSStackFrame *fp);
+
+extern JSDObject*
+jsd_IterateObjects(JSDContext* jsdc, JSDObject** iterp);
+
+extern JSObject*
+jsd_GetWrappedObject(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern const char*
+jsd_GetObjectNewURL(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern uintN
+jsd_GetObjectNewLineNumber(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern const char*
+jsd_GetObjectConstructorURL(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern uintN
+jsd_GetObjectConstructorLineNumber(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern const char*
+jsd_GetObjectConstructorName(JSDContext* jsdc, JSDObject* jsdobj);
+
+extern JSDObject*
+jsd_GetJSDObjectForJSObject(JSDContext* jsdc, JSObject* jsobj);
+
+extern JSDObject*
+jsd_GetObjectForValue(JSDContext* jsdc, JSDValue* jsdval);
+
+/*
+* returns new refcounted JSDValue
+*/
+extern JSDValue*
+jsd_GetValueForObject(JSDContext* jsdc, JSDObject* jsdobj);
+
+/**************************************************/
+/* Atom Functions */
+
+extern JSBool
+jsd_CreateAtomTable(JSDContext* jsdc);
+
+extern void
+jsd_DestroyAtomTable(JSDContext* jsdc);
+
+extern JSDAtom*
+jsd_AddAtom(JSDContext* jsdc, const char* str);
+
+extern JSDAtom*
+jsd_CloneAtom(JSDContext* jsdc, JSDAtom* atom);
+
+extern void
+jsd_DropAtom(JSDContext* jsdc, JSDAtom* atom);
+
+#define JSD_ATOM_TO_STRING(a) ((const char*)((a)->str))
+
+/***************************************************************************/
+/* Livewire specific API */
+#ifdef LIVEWIRE
+
+extern LWDBGScript*
+jsdlw_GetLWScript(JSDContext* jsdc, JSDScript* jsdscript);
+
+extern char*
+jsdlw_BuildAppRelativeFilename(LWDBGApp* app, const char* filename);
+
+extern JSDSourceText*
+jsdlw_PreLoadSource(JSDContext* jsdc, LWDBGApp* app,
+                     const char* filename, JSBool clear);
+
+extern JSDSourceText*
+jsdlw_ForceLoadSource(JSDContext* jsdc, JSDSourceText* jsdsrc);
+
+extern JSBool
+jsdlw_UserCodeAtPC(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc);
+
+extern JSBool
+jsdlw_RawToProcessedLineNumber(JSDContext* jsdc, JSDScript* jsdscript,
+                               uintN lineIn, uintN* lineOut);
+
+extern JSBool
+jsdlw_ProcessedToRawLineNumber(JSDContext* jsdc, JSDScript* jsdscript,
+                               uintN lineIn, uintN* lineOut);
+
+
+#if 0
+/* our hook proc for LiveWire app start/stop */
+extern void JS_DLL_CALLBACK
+jsdlw_AppHookProc(LWDBGApp* app,
+                  JSBool created,
+                  void *callerdata);
+#endif
+
+
+#endif
+/***************************************************************************/
+
+JS_END_EXTERN_C
+
+#endif /* jsd_h___ */

mozilla/js/jsd/jsd.mak

@@ -0,0 +1,70 @@
+
+PROJ = jsd
+JSD = .
+JS = $(JSD)\..\src
+JSPROJ = js32
+
+!IF "$(BUILD_OPT)" != ""
+OBJ = Release
+CC_FLAGS = /DNDEBUG 
+!ELSE
+OBJ = Debug
+CC_FLAGS = /DDEBUG 
+LINK_FLAGS = /DEBUG
+!ENDIF 
+
+QUIET=@
+
+CFLAGS = /nologo /MDd /W3 /Gm /GX /Zi /Od\
+         /I $(JS)\
+         /I $(JSD)\
+         /DDEBUG /DWIN32 /D_CONSOLE /DXP_PC /D_WINDOWS /D_WIN32\
+         /DJSDEBUGGER\
+!IF "$(JSD_THREADSAFE)" != ""
+         /DJSD_THREADSAFE\
+!ENDIF 
+         /DEXPORT_JSD_API\
+         $(CC_FLAGS)\
+         /c /Fp$(OBJ)\$(PROJ).pch /Fd$(OBJ)\$(PROJ).pdb /YX -Fo$@ $<
+
+LFLAGS = /nologo /subsystem:console /DLL /incremental:no /machine:I386 \
+         $(LINK_FLAGS) /pdb:$(OBJ)\$(PROJ).pdb -out:$(OBJ)\$(PROJ).dll
+
+LLIBS = kernel32.lib advapi32.lib $(JS)\$(OBJ)\$(JSPROJ).lib
+# unused... user32.lib gdi32.lib winspool.lib comdlg32.lib shell32.lib                                    
+
+CPP=cl.exe
+LINK32=link.exe
+
+all: $(OBJ) $(OBJ)\$(PROJ).dll
+     
+
+$(OBJ)\$(PROJ).dll:         \
+        $(OBJ)\jsdebug.obj  \
+        $(OBJ)\jsd_atom.obj \
+        $(OBJ)\jsd_high.obj \
+        $(OBJ)\jsd_hook.obj \
+        $(OBJ)\jsd_obj.obj  \
+        $(OBJ)\jsd_scpt.obj \
+        $(OBJ)\jsd_stak.obj \
+        $(OBJ)\jsd_step.obj \
+        $(OBJ)\jsd_text.obj \
+        $(OBJ)\jsd_lock.obj \
+        $(OBJ)\jsd_val.obj 
+  $(QUIET)$(LINK32) $(LFLAGS) $** $(LLIBS)
+
+{$(JSD)}.c{$(OBJ)}.obj :
+  $(QUIET)$(CPP) $(CFLAGS)
+
+$(OBJ) :
+    $(QUIET)mkdir $(OBJ)
+
+clean:
+    @echo deleting old output
+    $(QUIET)del $(OBJ)\*.pch >NUL
+    $(QUIET)del $(OBJ)\*.obj >NUL
+    $(QUIET)del $(OBJ)\*.exp >NUL
+    $(QUIET)del $(OBJ)\*.lib >NUL
+    $(QUIET)del $(OBJ)\*.idb >NUL
+    $(QUIET)del $(OBJ)\*.pdb >NUL
+    $(QUIET)del $(OBJ)\*.dll >NUL

mozilla/js/jsd/jsd1640.def

@@ -0,0 +1,89 @@
+; -*- Mode: Fundamental; tab-width: 4; indent-tabs-mode: nil -*-
+;
+; The contents of this file are subject to the Netscape Public License
+; Version 1.0 (the "NPL"); you may not use this file except in
+; compliance with the NPL.  You may obtain a copy of the NPL at
+; http://www.mozilla.org/NPL/
+;
+; Software distributed under the NPL is distributed on an "AS IS" basis,
+; WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+; for the specific language governing rights and limitations under the
+; NPL.
+;
+; The Initial Developer of this code under the NPL is Netscape
+; Communications Corporation.  Portions created by Netscape are
+; Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+; Reserved.
+
+
+LIBRARY JSD1640.DLL
+EXETYPE WINDOWS
+PROTMODE
+
+DESCRIPTION 'Netscape 16-bit JavaScript Debugger Library'
+
+CODE    LOADONCALL MOVEABLE DISCARDABLE
+DATA	PRELOAD MOVEABLE SINGLE
+
+HEAPSIZE    8192
+
+EXPORTS
+	WEP															@1 RESIDENTNAME	NONAME
+	_JSD_AppendSourceText
+	_JSD_ClearAllExecutionHooks
+	_JSD_ClearAllExecutionHooksForScript
+	_JSD_ClearDebugBreakHook
+	_JSD_ClearExecutionHook
+	_JSD_ClearInterruptHook
+	_JSD_ClearSourceText
+	_JSD_DebuggerOff
+	_JSD_DebuggerOn
+	_JSD_EvaluateScriptInStackFrame
+	_JSD_FindSourceForURL
+	_JSD_GetCallingStackFrame
+	_JSD_GetClosestLine
+	_JSD_GetClosestPC
+	_JSD_GetCountOfStackFrames
+	_JSD_GetDefaultJSContext
+	_JSD_GetMajorVersion
+	_JSD_GetMinorVersion
+	_JSD_GetPCForStackFrame
+	_JSD_GetScriptBaseLineNumber
+	_JSD_GetScriptFilename
+	_JSD_GetScriptForStackFrame
+	_JSD_GetScriptFunctionName
+	_JSD_GetScriptHook
+	_JSD_GetScriptLineExtent
+	_JSD_GetSourceAlterCount
+	_JSD_GetSourceStatus
+	_JSD_GetSourceText
+	_JSD_GetSourceURL
+	_JSD_GetStackFrame
+	_JSD_IncrementSourceAlterCount
+	_JSD_IsSourceDirty
+	_JSD_IterateScripts
+	_JSD_IterateSources
+	_JSD_LockScriptSubsystem
+	_JSD_LockSourceTextSubsystem
+	_JSD_NewSourceText
+	_JSD_SetDebugBreakHook
+	_JSD_SetErrorReporter
+	_JSD_SetExecutionHook
+	_JSD_SetInterruptHook
+	_JSD_SetScriptHook
+	_JSD_SetSourceDirty
+	_JSD_SetUserCallbacks
+	_JSD_UnlockScriptSubsystem
+	_JSD_UnlockSourceTextSubsystem
+	_Java_netscape_jsdebug_DebugController__0005fsetController_stub
+	_Java_netscape_jsdebug_DebugController_executeScriptInStackFrame_stub
+	_Java_netscape_jsdebug_DebugController_sendInterrupt_stub
+	_Java_netscape_jsdebug_DebugController_setInstructionHook0_stub
+	_Java_netscape_jsdebug_JSPC_getSourceLocation_stub
+	_Java_netscape_jsdebug_JSSourceTextProvider_loadSourceTextItem_stub
+	_Java_netscape_jsdebug_JSSourceTextProvider_refreshSourceTextVector_stub
+	_Java_netscape_jsdebug_JSStackFrameInfo_getCaller0_stub
+	_Java_netscape_jsdebug_JSStackFrameInfo_getPC_stub
+	_Java_netscape_jsdebug_JSThreadState_countStackFrames_stub
+	_Java_netscape_jsdebug_JSThreadState_getCurrentFrame_stub
+	_Java_netscape_jsdebug_Script_getClosestPC_stub

mozilla/js/jsd/jsd1640.rc

@@ -0,0 +1,80 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+// Version stamp for this .DLL
+
+#include <windows.h>
+
+#include <ver.h>
+
+
+
+VS_VERSION_INFO     VERSIONINFO
+
+  FILEVERSION       4 // major, minor, release (alpha 1), build #
+
+  PRODUCTVERSION    4
+
+  FILEFLAGSMASK     0
+
+  FILEFLAGS         0 // final version
+
+  FILEOS            VOS_DOS_WINDOWS16
+
+  FILETYPE          VFT_DLL
+
+  FILESUBTYPE       0   // not used
+
+BEGIN
+
+    BLOCK "StringFileInfo"
+
+    BEGIN
+
+        BLOCK "040904E4" // Lang=US English, CharSet=Windows Multilingual
+
+        BEGIN
+
+            VALUE "CompanyName",     "Netscape Communications Corporation\0"
+
+            VALUE "FileDescription", "Netscape 16-bit JavaScript Debugger Module\0"
+
+            VALUE "FileVersion",     "4.0\0"
+
+            VALUE "InternalName",    "JSD1640\0"
+
+            VALUE "LegalCopyright",  "Copyright Netscape Communications. 1994-96\0"
+
+            VALUE "LegalTrademarks", "Netscape, Mozilla\0"
+
+            VALUE "OriginalFilename","JSD1640.DLL\0"
+
+            VALUE "ProductName",     "NETSCAPE\0"
+
+            VALUE "ProductVersion",  "4.0\0"
+
+        END
+
+    END
+
+END
+

mozilla/js/jsd/jsd3240.rc

@@ -0,0 +1,99 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "winver.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 4,0,0,0
+ PRODUCTVERSION 4,0,0,0
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x10004L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904e4"
+        BEGIN
+            VALUE "CompanyName", "Netscape Communications Corporation\0"
+            VALUE "FileDescription", "Netscape 32-bit JavaScript Debugger Module\0"
+            VALUE "FileVersion", "4.0\0"
+            VALUE "InternalName", "JSD3240\0"
+            VALUE "LegalCopyright", "Copyright Netscape Communications. 1994-96\0"
+            VALUE "LegalTrademarks", "Netscape, Mozilla\0"
+            VALUE "OriginalFilename", "jsd3240.dll\0"
+            VALUE "ProductName", "NETSCAPE\0"
+            VALUE "ProductVersion", "4.0\0"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1252
+    END
+END
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""winver.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+/////////////////////////////////////////////////////////////////////////////

mozilla/js/jsd/jsd_atom.c

@@ -0,0 +1,159 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Atom support
+ */
+
+#include "jsd.h"
+
+/* #define TEST_ATOMS 1 */
+
+#ifdef TEST_ATOMS
+static void 
+_testAtoms(JSDContext*jsdc)
+{
+    JSDAtom* atom0 = jsd_AddAtom(jsdc, "foo");
+    JSDAtom* atom1 = jsd_AddAtom(jsdc, "foo");
+    JSDAtom* atom2 = jsd_AddAtom(jsdc, "bar");
+    JSDAtom* atom3 = jsd_CloneAtom(jsdc, atom1);
+    JSDAtom* atom4 = jsd_CloneAtom(jsdc, atom2);
+
+    const char* c0 = JSD_ATOM_TO_STRING(atom0);
+    const char* c1 = JSD_ATOM_TO_STRING(atom1);
+    const char* c2 = JSD_ATOM_TO_STRING(atom2);
+    const char* c3 = JSD_ATOM_TO_STRING(atom3);
+    const char* c4 = JSD_ATOM_TO_STRING(atom4);
+
+    jsd_DropAtom(jsdc, atom0);
+    jsd_DropAtom(jsdc, atom1);
+    jsd_DropAtom(jsdc, atom2);
+    jsd_DropAtom(jsdc, atom3);
+    jsd_DropAtom(jsdc, atom4);
+}        
+#endif    
+
+JS_STATIC_DLL_CALLBACK(intN)
+_atom_smasher(JSHashEntry *he, intN i, void *arg)
+{
+    JS_ASSERT(he);
+    JS_ASSERT(he->value);
+    JS_ASSERT(((JSDAtom*)(he->value))->str);
+
+    free(((JSDAtom*)(he->value))->str);
+    free(he->value);
+    he->value = NULL;
+    he->key   = NULL;
+    return HT_ENUMERATE_NEXT;
+}
+
+JS_STATIC_DLL_CALLBACK(intN)
+_compareAtomKeys(const void *v1, const void *v2)
+{
+    return 0 == strcmp((const char*)v1, (const char*)v2);
+}        
+
+JS_STATIC_DLL_CALLBACK(intN)
+_compareAtoms(const void *v1, const void *v2)
+{
+    return 0 == strcmp(((JSDAtom*)v1)->str, ((JSDAtom*)v2)->str);
+}        
+
+
+JSBool
+jsd_CreateAtomTable(JSDContext* jsdc)
+{
+    jsdc->atoms = JS_NewHashTable(256, JS_HashString,
+                                  _compareAtomKeys, _compareAtoms,
+                                  NULL, NULL);
+#ifdef TEST_ATOMS
+    _testAtoms(jsdc);
+#endif    
+    return (JSBool) jsdc->atoms;
+}
+
+void
+jsd_DestroyAtomTable(JSDContext* jsdc)
+{
+    if( jsdc->atoms )
+    {
+        JS_HashTableEnumerateEntries(jsdc->atoms, _atom_smasher, NULL);
+        JS_HashTableDestroy(jsdc->atoms);
+        jsdc->atoms = NULL;
+    }
+}
+
+JSDAtom*
+jsd_AddAtom(JSDContext* jsdc, const char* str)
+{
+    JSDAtom* atom;
+
+    if(!str)
+    {
+        JS_ASSERT(0);
+        return NULL;
+    }
+
+    JSD_LOCK_ATOMS(jsdc);
+    
+    atom = (JSDAtom*) JS_HashTableLookup(jsdc->atoms, str);
+
+    if( atom )
+        atom->refcount++;
+    else
+    {
+        atom = (JSDAtom*) malloc(sizeof(JSDAtom));
+        if( atom )
+        {
+            atom->str = strdup(str);
+            atom->refcount = 1;
+            if(!JS_HashTableAdd(jsdc->atoms, atom->str, atom))
+            {
+                free(atom->str);
+                free(atom);
+                atom = NULL;
+            }
+        }
+    }
+
+    JSD_UNLOCK_ATOMS(jsdc);
+    return atom;
+}        
+
+JSDAtom*
+jsd_CloneAtom(JSDContext* jsdc, JSDAtom* atom)
+{
+    JSD_LOCK_ATOMS(jsdc);
+    atom->refcount++;
+    JSD_UNLOCK_ATOMS(jsdc);
+    return atom;
+}        
+
+void
+jsd_DropAtom(JSDContext* jsdc, JSDAtom* atom)
+{
+    JSD_LOCK_ATOMS(jsdc);
+    if(! --atom->refcount)
+    {
+        JS_HashTableRemove(jsdc->atoms, atom->str);
+        free(atom->str);
+        free(atom);
+    }
+    JSD_UNLOCK_ATOMS(jsdc);
+}        
+

mozilla/js/jsd/jsd_high.c

@@ -0,0 +1,348 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - 'High Level' functions
+ */
+
+#include "jsd.h"
+
+/***************************************************************************/
+
+/* XXX not 'static' because of old Mac CodeWarrior bug */ 
+JSCList _jsd_context_list = JS_INIT_STATIC_CLIST(&_jsd_context_list);
+
+/* these are used to connect JSD_SetUserCallbacks() with JSD_DebuggerOn() */
+static JSD_UserCallbacks _callbacks;
+static void*             _user = NULL; 
+static JSRuntime*        _jsrt = NULL;
+
+#ifdef JSD_HAS_DANGEROUS_THREAD
+static void* _dangerousThread = NULL;
+#endif
+
+#ifdef JSD_THREADSAFE
+void* _jsd_global_lock = NULL;
+#endif
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_CONTEXT(JSDContext* jsdc)
+{
+    JS_ASSERT(jsdc->inited);
+    JS_ASSERT(jsdc->jsrt);
+    JS_ASSERT(jsdc->dumbContext);
+    JS_ASSERT(jsdc->glob);
+}
+#endif
+
+static JSClass global_class = {
+    "JSDGlobal", 0,
+    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
+    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub
+};
+
+static JSBool
+_validateUserCallbacks(JSD_UserCallbacks* callbacks)
+{
+    return !callbacks ||
+           (callbacks->size && callbacks->size <= sizeof(JSD_UserCallbacks));
+}    
+
+static JSDContext*
+_newJSDContext(JSRuntime*         jsrt, 
+               JSD_UserCallbacks* callbacks, 
+               void*              user)
+{
+    JSDContext* jsdc = NULL;
+
+    if( ! jsrt )
+        return NULL;
+
+    if( ! _validateUserCallbacks(callbacks) )
+        return NULL;
+
+    jsdc = (JSDContext*) calloc(1, sizeof(JSDContext));
+    if( ! jsdc )
+        goto label_newJSDContext_failure;
+
+    if( ! JSD_INIT_LOCKS(jsdc) )
+        goto label_newJSDContext_failure;
+
+    JS_INIT_CLIST(&jsdc->links);
+
+    jsdc->jsrt = jsrt;
+
+    if( callbacks )
+        memcpy(&jsdc->userCallbacks, callbacks, callbacks->size);
+    
+    jsdc->user = user;
+
+#ifdef JSD_HAS_DANGEROUS_THREAD
+    jsdc->dangerousThread = _dangerousThread;
+#endif
+
+    JS_INIT_CLIST(&jsdc->threadsStates);
+    JS_INIT_CLIST(&jsdc->scripts);
+    JS_INIT_CLIST(&jsdc->sources);
+    JS_INIT_CLIST(&jsdc->removedSources);
+
+    jsdc->sourceAlterCount = 1;
+
+    if( ! jsd_CreateAtomTable(jsdc) )
+        goto label_newJSDContext_failure;
+
+    if( ! jsd_InitObjectManager(jsdc) )
+        goto label_newJSDContext_failure;
+
+    jsdc->dumbContext = JS_NewContext(jsdc->jsrt, 256);
+    if( ! jsdc->dumbContext )
+        goto label_newJSDContext_failure;
+
+    jsdc->glob = JS_NewObject(jsdc->dumbContext, &global_class, NULL, NULL);
+    if( ! jsdc->glob )
+        goto label_newJSDContext_failure;
+
+    if( ! JS_InitStandardClasses(jsdc->dumbContext, jsdc->glob) )
+        goto label_newJSDContext_failure;
+
+    jsdc->inited = JS_TRUE;
+
+    JSD_LOCK();
+    JS_INSERT_LINK(&jsdc->links, &_jsd_context_list);
+    JSD_UNLOCK();
+
+    return jsdc;
+
+label_newJSDContext_failure:
+    jsd_DestroyObjectManager(jsdc);
+    jsd_DestroyAtomTable(jsdc);
+    if( jsdc )
+        free(jsdc);
+    return NULL;
+}
+
+static void
+_destroyJSDContext(JSDContext* jsdc)
+{
+    JSD_ASSERT_VALID_CONTEXT(jsdc);
+
+    JSD_LOCK();
+    JS_REMOVE_LINK(&jsdc->links);
+    JSD_UNLOCK();
+
+    jsd_DestroyObjectManager(jsdc);
+    jsd_DestroyAtomTable(jsdc);
+
+    jsdc->inited = JS_FALSE;
+
+    /*
+    * We should free jsdc here, but we let it leak in case there are any 
+    * asynchronous hooks calling into the system using it as a handle
+    *
+    * XXX we also leak the locks
+    */
+
+}
+
+/***************************************************************************/
+
+JSDContext*
+jsd_DebuggerOnForUser(JSRuntime*         jsrt, 
+                      JSD_UserCallbacks* callbacks, 
+                      void*              user)
+{
+    JSDContext* jsdc;
+    JSContext* iter = NULL;
+
+    jsdc = _newJSDContext(jsrt, callbacks, user);
+    if( ! jsdc )
+        return NULL;
+
+    /* set hooks here */
+    JS_SetNewScriptHookProc(jsdc->jsrt, jsd_NewScriptHookProc, jsdc);
+    JS_SetDestroyScriptHookProc(jsdc->jsrt, jsd_DestroyScriptHookProc, jsdc);
+    JS_SetDebuggerHandler(jsdc->jsrt, jsd_DebuggerHandler, jsdc);
+    JS_SetExecuteHook(jsdc->jsrt, jsd_InterpreterHook, jsdc);
+    JS_SetCallHook(jsdc->jsrt, jsd_InterpreterHook, jsdc);
+    JS_SetObjectHook(jsdc->jsrt, jsd_ObjectHook, jsdc);
+    JS_SetThrowHook(jsdc->jsrt, jsd_ThrowHandler, jsdc);
+    JS_SetDebugErrorHook(jsdc->jsrt, jsd_DebugErrorHook, jsdc);
+#ifdef LIVEWIRE
+    LWDBG_SetNewScriptHookProc(jsd_NewScriptHookProc, jsdc);
+#endif
+    if( jsdc->userCallbacks.setContext )
+        jsdc->userCallbacks.setContext(jsdc, jsdc->user);
+    return jsdc;
+}
+
+JSDContext*
+jsd_DebuggerOn(void)
+{
+    JS_ASSERT(_jsrt);
+    JS_ASSERT(_validateUserCallbacks(&_callbacks));
+    return jsd_DebuggerOnForUser(_jsrt, &_callbacks, _user);
+}
+
+void
+jsd_DebuggerOff(JSDContext* jsdc)
+{
+    /* clear hooks here */
+    JS_SetNewScriptHookProc(jsdc->jsrt, NULL, NULL);
+    JS_SetDestroyScriptHookProc(jsdc->jsrt, NULL, NULL);
+    JS_SetDebuggerHandler(jsdc->jsrt, NULL, NULL);
+    JS_SetExecuteHook(jsdc->jsrt, NULL, NULL);
+    JS_SetCallHook(jsdc->jsrt, NULL, NULL);
+    JS_SetObjectHook(jsdc->jsrt, NULL, NULL);
+    JS_SetThrowHook(jsdc->jsrt, NULL, NULL);
+    JS_SetDebugErrorHook(jsdc->jsrt, NULL, NULL);
+#ifdef LIVEWIRE
+    LWDBG_SetNewScriptHookProc(NULL,NULL);
+#endif
+
+    /* clean up */
+    jsd_DestroyAllJSDScripts(jsdc);
+    jsd_DestroyAllSources(jsdc);
+    
+    _destroyJSDContext(jsdc);
+
+    if( jsdc->userCallbacks.setContext )
+        jsdc->userCallbacks.setContext(NULL, jsdc->user);
+}
+
+void
+jsd_SetUserCallbacks(JSRuntime* jsrt, JSD_UserCallbacks* callbacks, void* user)
+{
+    _jsrt = jsrt;
+    _user = user;
+
+#ifdef JSD_HAS_DANGEROUS_THREAD
+    _dangerousThread = JSD_CURRENT_THREAD();
+#endif
+
+    if( callbacks )
+        memcpy(&_callbacks, callbacks, sizeof(JSD_UserCallbacks));
+    else
+        memset(&_callbacks, 0 , sizeof(JSD_UserCallbacks));
+}
+
+JSDContext*
+jsd_JSDContextForJSContext(JSContext* context)
+{
+    JSDContext* iter;
+    JSDContext* jsdc = NULL;
+    JSRuntime*  runtime = JS_GetRuntime(context);
+
+    JSD_LOCK();
+    for( iter = (JSDContext*)_jsd_context_list.next;
+         iter != (JSDContext*)&_jsd_context_list;
+         iter = (JSDContext*)iter->links.next )
+    {
+        if( runtime == iter->jsrt )
+        {
+            jsdc = iter;
+            break;
+        }
+    }
+    JSD_UNLOCK();
+    return jsdc;
+}    
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+jsd_DebugErrorHook(JSContext *cx, const char *message,
+                   JSErrorReport *report, void *closure)
+{
+    JSDContext* jsdc = (JSDContext*) closure;
+    JSD_ErrorReporter errorReporter;
+    void*             errorReporterData;
+    
+    if( ! jsdc )
+    {
+        JS_ASSERT(0);
+        return JS_TRUE;
+    }
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return JS_TRUE;
+
+    /* local in case hook gets cleared on another thread */
+    JSD_LOCK();
+    errorReporter     = jsdc->errorReporter;
+    errorReporterData = jsdc->errorReporterData;
+    JSD_UNLOCK();
+
+    if(!errorReporter)
+        return JS_TRUE;
+
+    switch(errorReporter(jsdc, cx, message, report, errorReporterData))
+    {
+        case JSD_ERROR_REPORTER_PASS_ALONG:
+            return JS_TRUE;
+        case JSD_ERROR_REPORTER_RETURN:
+            return JS_FALSE;
+        case JSD_ERROR_REPORTER_DEBUG:
+        {
+            jsval rval;
+            JSD_ExecutionHookProc   hook;
+            void*                   hookData;
+
+            /* local in case hook gets cleared on another thread */
+            JSD_LOCK();
+            hook = jsdc->debugBreakHook;
+            hookData = jsdc->debugBreakHookData;
+            JSD_UNLOCK();
+
+            jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_DEBUG_REQUESTED,
+                                  hook, hookData, &rval);
+            /* XXX Should make this dependent on ExecutionHook retval */
+            return JS_TRUE;
+        }
+        case JSD_ERROR_REPORTER_CLEAR_RETURN:
+            if(report && JSREPORT_IS_EXCEPTION(report->flags))
+                JS_ClearPendingException(cx);
+            return JS_FALSE;
+        default:
+            JS_ASSERT(0);
+            break;
+    }
+    return JS_TRUE;
+}
+
+JSBool
+jsd_SetErrorReporter(JSDContext*       jsdc, 
+                     JSD_ErrorReporter reporter, 
+                     void*             callerdata)
+{
+    JSD_LOCK();
+    jsdc->errorReporter = reporter;
+    jsdc->errorReporterData = callerdata;
+    JSD_UNLOCK();
+    return JS_TRUE;
+}
+
+JSBool
+jsd_GetErrorReporter(JSDContext*        jsdc, 
+                     JSD_ErrorReporter* reporter, 
+                     void**             callerdata)
+{
+    JSD_LOCK();
+    if( reporter )
+        *reporter = jsdc->errorReporter;
+    if( callerdata )
+        *callerdata = jsdc->errorReporterData;
+    JSD_UNLOCK();
+    return JS_TRUE;
+}

mozilla/js/jsd/jsd_hook.c

@@ -0,0 +1,260 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Hook support
+ */
+
+#include "jsd.h"
+
+JSTrapStatus JS_DLL_CALLBACK
+jsd_InterruptHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
+                     void *closure)
+{
+    JSDScript*      jsdscript;
+    JSDContext*     jsdc = (JSDContext*) closure;
+    JSD_ExecutionHookProc hook;
+    void*                 hookData;
+
+    if( ! jsdc || ! jsdc->inited )
+        return JSTRAP_CONTINUE;
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return JSTRAP_CONTINUE;
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    if( ! jsdscript )
+        return JSTRAP_CONTINUE;
+
+#ifdef LIVEWIRE
+    if( ! jsdlw_UserCodeAtPC(jsdc, jsdscript, (jsuword)pc) )
+        return JSTRAP_CONTINUE;
+#endif
+
+    /* local in case jsdc->interruptHook gets cleared on another thread */
+    JSD_LOCK();
+    hook     = jsdc->interruptHook;
+    hookData = jsdc->interruptHookData;
+    JSD_UNLOCK();
+
+    return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_INTERRUPTED,
+                                 hook, hookData, rval);
+}
+
+JSTrapStatus JS_DLL_CALLBACK
+jsd_DebuggerHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
+                    jsval *rval, void *closure)
+{
+    JSDScript*      jsdscript;
+    JSDContext*     jsdc = (JSDContext*) closure;
+    JSD_ExecutionHookProc hook;
+    void*                 hookData;
+
+    if( ! jsdc || ! jsdc->inited )
+        return JSTRAP_CONTINUE;
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return JSTRAP_CONTINUE;
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    if( ! jsdscript )
+        return JSTRAP_CONTINUE;
+
+    /* local in case jsdc->debuggerHook gets cleared on another thread */
+    JSD_LOCK();
+    hook     = jsdc->debuggerHook;
+    hookData = jsdc->debuggerHookData;
+    JSD_UNLOCK();
+
+    return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_DEBUGGER_KEYWORD,
+                                 hook, hookData, rval);
+}
+
+
+JSTrapStatus JS_DLL_CALLBACK
+jsd_ThrowHandler(JSContext *cx, JSScript *script, jsbytecode *pc,
+                 jsval *rval, void *closure)
+{
+    JSDScript*      jsdscript;
+    JSDContext*     jsdc = (JSDContext*) closure;
+    JSD_ExecutionHookProc hook;
+    void*                 hookData;
+
+    JS_GetPendingException(cx, rval);
+
+    if( ! jsdc || ! jsdc->inited )
+        return JSD_HOOK_RETURN_CONTINUE_THROW;
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return JSD_HOOK_RETURN_CONTINUE_THROW;
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    if( ! jsdscript )
+        return JSD_HOOK_RETURN_CONTINUE_THROW;
+
+    /* local in case jsdc->throwHook gets cleared on another thread */
+    JSD_LOCK();
+    hook     = jsdc->throwHook;
+    hookData = jsdc->throwHookData;
+    JSD_UNLOCK();
+
+    return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_THROW,
+                                 hook, hookData, rval);
+}
+
+JSTrapStatus
+jsd_CallExecutionHook(JSDContext* jsdc,
+                      JSContext *cx,
+                      JSDHookType type,
+                      JSD_ExecutionHookProc hook,
+                      void* hookData,
+                      jsval* rval)
+{
+    JSDHookResult hookanswer = JSD_HOOK_THROW == type ? 
+                                    JSD_HOOK_RETURN_CONTINUE_THROW :
+                                    JSD_HOOK_RETURN_CONTINUE;
+    JSDThreadState* jsdthreadstate;
+
+    if(hook && NULL != (jsdthreadstate = jsd_NewThreadState(jsdc,cx)))
+    {
+        hookanswer = hook(jsdc, jsdthreadstate, type, hookData, rval);
+        jsd_DestroyThreadState(jsdc, jsdthreadstate);
+    }
+
+    switch(hookanswer)
+    {
+        case JSD_HOOK_RETURN_ABORT:
+        case JSD_HOOK_RETURN_HOOK_ERROR:
+            return JSTRAP_ERROR;
+        case JSD_HOOK_RETURN_RET_WITH_VAL:
+            return JSTRAP_RETURN;
+        case JSD_HOOK_RETURN_THROW_WITH_VAL:
+            return JSTRAP_THROW;
+        case JSD_HOOK_RETURN_CONTINUE:
+            break;
+        case JSD_HOOK_RETURN_CONTINUE_THROW:
+            /* only makes sense for jsd_ThrowHandler (which init'd rval) */
+            JS_ASSERT(JSD_HOOK_THROW == type);
+            return JSTRAP_THROW;
+        default:
+            JS_ASSERT(0);
+            break;
+    }
+    return JSTRAP_CONTINUE;
+}
+
+JSBool
+jsd_SetInterruptHook(JSDContext*           jsdc,
+                     JSD_ExecutionHookProc hook,
+                     void*                 callerdata)
+{
+    JSD_LOCK();
+    jsdc->interruptHookData  = callerdata;
+    jsdc->interruptHook      = hook;
+    JS_SetInterrupt(jsdc->jsrt, jsd_InterruptHandler, (void*) jsdc);
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearInterruptHook(JSDContext* jsdc)
+{
+    JSD_LOCK();
+    JS_ClearInterrupt(jsdc->jsrt, NULL, NULL );
+    jsdc->interruptHook      = NULL;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_SetDebugBreakHook(JSDContext*           jsdc,
+                      JSD_ExecutionHookProc hook,
+                      void*                 callerdata)
+{
+    JSD_LOCK();
+    jsdc->debugBreakHookData  = callerdata;
+    jsdc->debugBreakHook      = hook;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearDebugBreakHook(JSDContext* jsdc)
+{
+    JSD_LOCK();
+    jsdc->debugBreakHook      = NULL;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_SetDebuggerHook(JSDContext*           jsdc,
+                      JSD_ExecutionHookProc hook,
+                      void*                 callerdata)
+{
+    JSD_LOCK();
+    jsdc->debuggerHookData  = callerdata;
+    jsdc->debuggerHook      = hook;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearDebuggerHook(JSDContext* jsdc)
+{
+    JSD_LOCK();
+    jsdc->debuggerHook      = NULL;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_SetThrowHook(JSDContext*           jsdc,
+                 JSD_ExecutionHookProc hook,
+                 void*                 callerdata)
+{
+    JSD_LOCK();
+    jsdc->throwHookData  = callerdata;
+    jsdc->throwHook      = hook;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearThrowHook(JSDContext* jsdc)
+{
+    JSD_LOCK();
+    jsdc->throwHook      = NULL;
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+

mozilla/js/jsd/jsd_java.c

@@ -0,0 +1,801 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/* this is all going away... replaced by code in js/jsd/java */
+
+#if 0
+
+#include "native.h"
+#include "jsdebug.h"
+
+#ifndef XP_MAC
+#include "_gen/netscape_jsdebug_DebugController.h"
+#include "_gen/netscape_jsdebug_Script.h"
+#include "_gen/netscape_jsdebug_JSThreadState.h"
+#include "_gen/netscape_jsdebug_JSStackFrameInfo.h"
+#include "_gen/netscape_jsdebug_JSPC.h"
+#include "_gen/netscape_jsdebug_JSSourceTextProvider.h"
+#include "_gen/netscape_jsdebug_JSErrorReporter.h"
+#else
+#include "n_jsdebug_DebugController.h"
+#include "netscape_jsdebug_Script.h"
+#include "n_jsdebug_JSThreadState.h"
+#include "n_jsdebug_JSStackFrameInfo.h"
+#include "netscape_jsdebug_JSPC.h"
+#include "n_j_JSSourceTextProvider.h"
+#include "n_jsdebug_JSErrorReporter.h"
+#endif
+
+static JSDContext* context = 0;
+static struct Hnetscape_jsdebug_DebugController* controller = 0;
+
+/***************************************************************************/
+/* helpers */
+
+static JHandle*
+_constructInteger(ExecEnv *ee, long i)
+{
+    return (JHandle*) 
+        execute_java_constructor(ee, "java/lang/Integer", 0, "(I)", i);
+}
+
+static JHandle*
+_putHash(ExecEnv *ee, JHandle* tbl, JHandle* key, JHandle* ob)
+{
+    return (JHandle*) 
+        execute_java_dynamic_method( 
+            ee, tbl, "put",
+            "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", 
+            key, ob );
+}
+
+static JHandle*
+_getHash(ExecEnv *ee, JHandle* tbl, JHandle* key)
+{
+    return (JHandle*) 
+        execute_java_dynamic_method( 
+            ee, tbl, "get",
+            "(Ljava/lang/Object;)Ljava/lang/Object;", 
+            key );
+}
+
+static JHandle*
+_removeHash(ExecEnv *ee, JHandle* tbl, JHandle* key)
+{
+    return (JHandle*) 
+        execute_java_dynamic_method( 
+            ee, tbl, "remove",
+            "(Ljava/lang/Object;)Ljava/lang/Object;", 
+            key );
+}
+
+struct Hnetscape_jsdebug_JSStackFrameInfo*
+_constructJSStackFrameInfo( ExecEnv* ee, JSDStackFrameInfo* jsdframe, 
+                            struct Hnetscape_jsdebug_JSThreadState* threadState )
+{
+    struct Hnetscape_jsdebug_JSStackFrameInfo* frame;
+
+    frame = (struct Hnetscape_jsdebug_JSStackFrameInfo*)
+        execute_java_constructor( ee, "netscape/jsdebug/JSStackFrameInfo", 0, 
+                                  "(Lnetscape/jsdebug/JSThreadState;)",
+                                  threadState );
+    if( ! frame )
+        return NULL;
+
+    /* XXX fill in additional fields */
+    unhand(frame)->_nativePtr = (long) jsdframe;
+
+    return frame;
+}
+
+struct Hnetscape_jsdebug_JSPC*
+_constructJSPC( ExecEnv* ee, struct Hnetscape_jsdebug_Script* script, long pc )
+{
+    struct Hnetscape_jsdebug_JSPC * pcOb;
+
+    pcOb = (struct Hnetscape_jsdebug_JSPC *)
+        execute_java_constructor( ee, "netscape/jsdebug/JSPC", 0, 
+                                  "(Lnetscape/jsdebug/Script;I)",
+                                  script, pc );
+    if( ! pcOb )
+        return NULL;
+
+    /* XXX fill in additional fields */
+
+    return pcOb;
+}
+
+static Hnetscape_jsdebug_Script*
+_scriptObFromJSDScriptPtr( ExecEnv* ee, JSDScript* jsdscript )
+{
+    JHandle* tbl = (JHandle*) unhand(controller)->scriptTable;
+    JHandle* key = _constructInteger(ee,(long)jsdscript);
+    return (Hnetscape_jsdebug_Script*) _getHash( ee, tbl, key );
+}
+
+/***************************************************************************/
+
+void PR_CALLBACK
+_scriptHook( JSDContext* jsdc, 
+             JSDScript*  jsdscript,
+             JSBool      creating,
+             void*       callerdata )
+{
+    Hnetscape_jsdebug_Script* script;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return;
+
+    if( creating )
+    {
+        char* url      = (char*)JSD_GetScriptFilename       (jsdc, jsdscript);
+        char* function = (char*)JSD_GetScriptFunctionName   (jsdc, jsdscript);
+        int base       =        JSD_GetScriptBaseLineNumber (jsdc, jsdscript);
+        int extent     =        JSD_GetScriptLineExtent     (jsdc, jsdscript);
+
+        if( ! url )
+        {
+            return;
+            /* url = ""; */
+        }
+
+        /* create Java Object for Script */
+        script = (Hnetscape_jsdebug_Script*)
+                execute_java_constructor(ee, "netscape/jsdebug/Script", 0, "()");
+
+        if( ! script )
+            return;
+
+        /* set the members */
+        unhand(script)->_url = makeJavaString(url,strlen(url));
+        unhand(script)->_function = function ? makeJavaString(function,strlen(function)) : 0;
+        unhand(script)->_baseLineNumber = base;
+        unhand(script)->_lineExtent = extent;
+        unhand(script)->_nativePtr = (long)jsdscript;
+
+        /* add it to the hash table */
+        _putHash( ee, (JHandle*) unhand(controller)->scriptTable,
+                  _constructInteger(ee, (long)jsdscript), (JHandle*)script );
+
+        /* call the hook */
+        if( unhand(controller)->scriptHook )
+        {
+            execute_java_dynamic_method( ee,(JHandle*)unhand(controller)->scriptHook,
+                                         "justLoadedScript",
+                                         "(Lnetscape/jsdebug/Script;)V", 
+                                         script );
+        }
+    }
+    else
+    {
+        JHandle* tbl = (JHandle*) unhand(controller)->scriptTable;
+        JHandle* key = _constructInteger(ee,(long)jsdscript);
+
+        /* find Java Object for Script    */
+        script = (Hnetscape_jsdebug_Script*) _getHash( ee, tbl, key );
+
+        if( ! script )
+            return;
+
+        /* remove it from the hash table  */
+        _removeHash( ee, tbl, key );
+
+        /* call the hook */
+        if( unhand(controller)->scriptHook )
+        {
+            execute_java_dynamic_method( ee,(JHandle*)unhand(controller)->scriptHook,
+                                         "aboutToUnloadScript",
+                                         "(Lnetscape/jsdebug/Script;)V", 
+                                         script );
+        }
+        /* set the Script as invalid */
+        execute_java_dynamic_method( ee,(JHandle*)script,
+                                     "_setInvalid",
+                                     "()V" );
+    }
+}
+
+/***************************************************************************/
+PRUintn PR_CALLBACK
+_executionHook( JSDContext*     jsdc, 
+                JSDThreadState* jsdstate,
+                PRUintn         type,
+                void*           callerdata )
+{
+    Hnetscape_jsdebug_JSThreadState* threadState;
+    Hnetscape_jsdebug_Script* script;
+    JHandle* pcOb;
+    JSDStackFrameInfo* jsdframe;
+    JSDScript*  jsdscript;
+    int pc;
+    JHandle* tblScript;
+    JHandle* keyScript;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* get the JSDStackFrameInfo */
+    jsdframe = JSD_GetStackFrame(jsdc, jsdstate);
+    if( ! jsdframe )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* get the JSDScript */
+    jsdscript = JSD_GetScriptForStackFrame(jsdc, jsdstate, jsdframe);
+    if( ! jsdscript )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* find Java Object for Script    */
+    tblScript = (JHandle*) unhand(controller)->scriptTable;
+    keyScript = _constructInteger(ee, (long)jsdscript);
+    script = (Hnetscape_jsdebug_Script*) _getHash( ee, tblScript, keyScript );
+    if( ! script )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* generate a JSPC */
+    pc = JSD_GetPCForStackFrame(jsdc, jsdstate, jsdframe);
+
+    pcOb = (JHandle*)
+        _constructJSPC(ee, script, pc);
+    if( ! pcOb )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* build a JSThreadState */
+    threadState = (struct Hnetscape_jsdebug_JSThreadState*)
+            execute_java_constructor( ee, "netscape/jsdebug/JSThreadState",0,"()");
+    if( ! threadState )
+        return JSD_HOOK_RETURN_HOOK_ERROR;
+
+    /* populate the ThreadState */
+    /* XXX FILL IN THE REST... */
+    unhand(threadState)->valid           = 1; /* correct value for true? */
+    unhand(threadState)->currentFramePtr = (long) jsdframe;
+    unhand(threadState)->nativeThreadState = (long) jsdstate;
+    unhand(threadState)->continueState = netscape_jsdebug_JSThreadState_DEBUG_STATE_RUN;
+
+    /* XXX FILL IN THE REST... */
+
+
+    /* find and call the appropriate Hook */
+    if( JSD_HOOK_INTERRUPTED == type )
+    {
+        JHandle* hook;
+
+        /* clear the JSD level hook (must reset on next sendInterrupt0()*/
+        JSD_ClearInterruptHook(context); 
+
+        hook = (JHandle*) unhand(controller)->interruptHook;
+        if( ! hook )
+            return JSD_HOOK_RETURN_HOOK_ERROR;
+
+        /* call the hook */
+        execute_java_dynamic_method( 
+            ee, hook, "aboutToExecute",
+            "(Lnetscape/jsdebug/ThreadStateBase;Lnetscape/jsdebug/PC;)V",
+            threadState, pcOb );
+    }
+    else if( JSD_HOOK_DEBUG_REQUESTED == type )
+    {
+        JHandle* hook;
+
+        hook = (JHandle*) unhand(controller)->debugBreakHook;
+        if( ! hook )
+            return JSD_HOOK_RETURN_HOOK_ERROR;
+
+        /* call the hook */
+        execute_java_dynamic_method( 
+            ee, hook, "aboutToExecute",
+            "(Lnetscape/jsdebug/ThreadStateBase;Lnetscape/jsdebug/PC;)V",
+            threadState, pcOb );
+    }
+    else if( JSD_HOOK_BREAKPOINT == type )
+    {
+        JHandle* hook;
+
+        hook = (JHandle*)
+                execute_java_dynamic_method( 
+                        ee,(JHandle*)controller,
+                        "getInstructionHook0",
+                        "(Lnetscape/jsdebug/PC;)Lnetscape/jsdebug/InstructionHook;",
+                        pcOb );
+        if( ! hook )
+            return JSD_HOOK_RETURN_HOOK_ERROR;
+
+        /* call the hook */
+        execute_java_dynamic_method( 
+            ee, hook, "aboutToExecute",
+            "(Lnetscape/jsdebug/ThreadStateBase;)V",
+            threadState );
+    }
+
+    if( netscape_jsdebug_JSThreadState_DEBUG_STATE_THROW == 
+        unhand(threadState)->continueState )
+        return JSD_HOOK_RETURN_ABORT;
+
+    return JSD_HOOK_RETURN_CONTINUE;
+}
+
+PRUintn PR_CALLBACK
+_errorReporter( JSDContext*     jsdc, 
+                JSContext*      cx,
+                const char*     message, 
+                JSErrorReport*  report,
+                void*           callerdata )
+{
+    JHandle* reporter;
+    JHandle* msg         = NULL;
+    JHandle* filename    = NULL;
+    int      lineno      = 0;
+    JHandle* linebuf     = NULL;
+    int      tokenOffset = 0;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return JSD_ERROR_REPORTER_PASS_ALONG;
+
+    reporter = (JHandle*) unhand(controller)->errorReporter;
+    if( ! reporter )
+        return JSD_ERROR_REPORTER_PASS_ALONG;
+
+    if( message )
+        msg = (JHandle*) makeJavaString((char*)message, strlen(message));
+    if( report && report->filename )
+        filename = (JHandle*) makeJavaString((char*)report->filename, strlen(report->filename));
+    if( report && report->linebuf )
+        linebuf = (JHandle*) makeJavaString((char*)report->linebuf, strlen(report->linebuf));
+    if( report )
+        lineno = report->lineno;
+    if( report && report->linebuf && report->tokenptr )
+        tokenOffset = report->tokenptr - report->linebuf;
+
+    return (int) 
+        execute_java_dynamic_method( 
+                ee, reporter, "reportError",
+                "(Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;I)I", 
+                msg,
+                filename,
+                lineno,
+                linebuf,
+                tokenOffset );
+}
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_DebugController.h" */
+
+
+/* XXX HACK */
+JSDContext* _simContext = 0;
+
+void netscape_jsdebug_DebugController__setController(struct Hnetscape_jsdebug_DebugController * self,/*boolean*/ long on)
+{
+    if(on)
+    {
+        context = JSD_DebuggerOn();
+        if( ! context )
+            return;
+
+        _simContext = context; /* XXX HACK */
+
+        unhand(self)->_nativeContext = (long) context;
+        controller = self;
+        JSD_SetScriptHook(context, _scriptHook, (void*)1 );
+        JSD_SetErrorReporter(context, _errorReporter, (void*)1 );
+        JSD_SetDebugBreakHook(context, _executionHook, (void*)1 );
+    }
+    else
+    {
+        /* XXX stop somehow... */
+        /* kill context        */
+        JSD_SetDebugBreakHook(context, NULL, NULL );
+        JSD_SetErrorReporter(context, NULL, NULL);
+        JSD_SetScriptHook(context, NULL, NULL);
+        context = 0;
+        controller = 0;
+    }
+}
+
+void netscape_jsdebug_DebugController_setInstructionHook0(struct Hnetscape_jsdebug_DebugController * self,struct Hnetscape_jsdebug_PC * pcOb)
+{
+    Hnetscape_jsdebug_Script* script;
+    JSDScript* jsdscript;
+    PRUintn pc;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return;
+
+    script = (Hnetscape_jsdebug_Script*)
+        execute_java_dynamic_method(ee, (JHandle*)pcOb, "getScript","()Lnetscape/jsdebug/Script;");
+
+    if( ! script )
+        return;
+
+    jsdscript = (JSDScript*) unhand(script)->_nativePtr;
+    if( ! jsdscript )
+        return;
+
+    pc = (PRUintn)
+        execute_java_dynamic_method(ee, (JHandle*)pcOb, "getPC","()I");
+
+    JSD_SetExecutionHook(context, jsdscript, pc, _executionHook, 0);
+}
+
+void netscape_jsdebug_DebugController_sendInterrupt0(struct Hnetscape_jsdebug_DebugController * self)
+{
+    if( ! context || ! controller )
+        return;
+    JSD_SetInterruptHook(context, _executionHook, 0);
+}
+
+struct Hjava_lang_String *netscape_jsdebug_DebugController_executeScriptInStackFrame0(struct Hnetscape_jsdebug_DebugController *self,struct Hnetscape_jsdebug_JSStackFrameInfo *frame,struct Hjava_lang_String *src,struct Hjava_lang_String *filename,long lineno)
+{
+    struct Hnetscape_jsdebug_JSThreadState* threadStateOb;
+    JSDThreadState* jsdthreadstate;
+    JSDStackFrameInfo* jsdframe;
+    char* filenameC;
+    char* srcC;
+    JSString* jsstr;
+    jsval rval;
+    JSBool success;
+    int srclen;
+
+    threadStateOb = (struct Hnetscape_jsdebug_JSThreadState*)unhand(frame)->threadState;
+    jsdthreadstate = (JSDThreadState*) unhand(threadStateOb)->nativeThreadState;
+
+    jsdframe = (JSDStackFrameInfo*) unhand(frame)->_nativePtr;
+
+    if( ! context || ! controller || ! jsdframe )
+        return NULL;
+
+    filenameC = allocCString(filename);
+    if( ! filenameC )
+        return NULL;
+    srcC = allocCString(src);
+    if( ! srcC )
+    {
+        free(filenameC);
+        return NULL;
+    }
+
+    srclen = strlen(srcC);
+
+    success = JSD_EvaluateScriptInStackFrame(context, jsdthreadstate, jsdframe, 
+                                             srcC, srclen,
+                                             filenameC, lineno, &rval);
+
+    /* XXX crashing on Windows under Symantec (though I can't see why!)*/
+
+    free(filenameC);
+    free(srcC);
+
+
+    if( ! success )
+        return NULL;
+
+    if( JSVAL_IS_NULL(rval) || JSVAL_IS_VOID(rval) )
+        return NULL;
+
+    jsstr = JSD_ValToStringInStackFrame(context,jsdthreadstate,jsdframe,rval);
+    if( ! jsstr )
+        return NULL;
+
+    /* XXXbe should use JS_GetStringChars and preserve Unicode. */
+    return makeJavaString((char*)JS_GetStringBytes(jsstr), JS_GetStringLength(jsstr));
+}    
+
+long netscape_jsdebug_DebugController_getNativeMajorVersion(struct Hnetscape_jsdebug_DebugController* self)
+{
+    return (long) JSD_GetMajorVersion();
+}
+
+long netscape_jsdebug_DebugController_getNativeMinorVersion(struct Hnetscape_jsdebug_DebugController* self)
+{
+    return (long) JSD_GetMinorVersion();
+}
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_Script.h" */
+
+struct Hnetscape_jsdebug_JSPC *netscape_jsdebug_Script_getClosestPC(struct Hnetscape_jsdebug_Script * self,long line)
+{
+    PRUintn pc;
+    JSDScript* jsdscript;
+
+    if( ! context || ! controller )
+        return 0;
+
+    jsdscript = (JSDScript*) unhand(self)->_nativePtr;
+    if( ! jsdscript )
+        return 0;
+
+    pc = JSD_GetClosestPC(context, jsdscript, line);
+
+    if( -1 == pc )
+        return 0;
+    return _constructJSPC( 0, self, pc);
+}
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_JSThreadState.h" */
+
+long netscape_jsdebug_JSThreadState_countStackFrames(struct Hnetscape_jsdebug_JSThreadState * self)
+{
+    JSDThreadState* jsdstate;
+        
+    if( ! context || ! controller )
+        return 0;
+
+    jsdstate = (JSDThreadState*) unhand(self)->nativeThreadState;
+
+    if( ! jsdstate )
+        return 0;
+
+    return (long) JSD_GetCountOfStackFrames(context, jsdstate);
+}
+
+struct Hnetscape_jsdebug_StackFrameInfo *netscape_jsdebug_JSThreadState_getCurrentFrame(struct Hnetscape_jsdebug_JSThreadState * self)
+{
+    JSDThreadState* jsdstate;
+    JSDStackFrameInfo* jsdframe;
+        
+    if( ! context || ! controller )
+        return NULL;
+
+    jsdstate = (JSDThreadState*) unhand(self)->nativeThreadState;
+
+    if( ! jsdstate )
+        return NULL;
+
+    jsdframe = JSD_GetStackFrame(context, jsdstate);
+    if( ! jsdframe )
+        return NULL;
+
+    return (struct Hnetscape_jsdebug_StackFrameInfo*)
+                _constructJSStackFrameInfo( 0, jsdframe, self );
+}
+
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_JSStackFrameInfo.h" */
+
+struct Hnetscape_jsdebug_StackFrameInfo *netscape_jsdebug_JSStackFrameInfo_getCaller0(struct Hnetscape_jsdebug_JSStackFrameInfo * self)
+{
+    JSDStackFrameInfo* jsdframeCur;
+    JSDStackFrameInfo* jsdframeCaller;
+    struct Hnetscape_jsdebug_JSThreadState* threadState;
+    JSDThreadState* jsdthreadstate;
+
+    if( ! context || ! controller )
+        return NULL;
+
+    jsdframeCur = (JSDStackFrameInfo*) unhand(self)->_nativePtr;
+    if( ! jsdframeCur )
+        return NULL;
+
+    threadState = (struct Hnetscape_jsdebug_JSThreadState*) unhand(self)->threadState;
+    if( ! threadState )
+        return NULL;
+
+    jsdthreadstate = (JSDThreadState*) unhand(threadState)->nativeThreadState;
+    if( ! jsdthreadstate )
+        return NULL;
+
+    jsdframeCaller = JSD_GetCallingStackFrame(context, jsdthreadstate, jsdframeCur);
+    if( ! jsdframeCaller )
+        return NULL;
+
+    return (struct Hnetscape_jsdebug_StackFrameInfo*)
+                _constructJSStackFrameInfo( 0, jsdframeCaller, threadState );
+}
+struct Hnetscape_jsdebug_PC *netscape_jsdebug_JSStackFrameInfo_getPC(struct Hnetscape_jsdebug_JSStackFrameInfo * self)
+{
+    JSDScript* jsdscript;
+    JSDStackFrameInfo* jsdframe;
+    struct Hnetscape_jsdebug_Script* script;
+    struct Hnetscape_jsdebug_JSThreadState* threadState;
+    JSDThreadState* jsdthreadstate;
+    int pc;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return NULL;
+
+    jsdframe = (JSDStackFrameInfo*) unhand(self)->_nativePtr;
+    if( ! jsdframe )
+        return NULL;
+
+    threadState = (struct Hnetscape_jsdebug_JSThreadState*) unhand(self)->threadState;
+    if( ! threadState )
+        return NULL;
+
+    jsdthreadstate = (JSDThreadState*) unhand(threadState)->nativeThreadState;
+    if( ! jsdthreadstate )
+        return NULL;
+
+    jsdscript = JSD_GetScriptForStackFrame(context, jsdthreadstate, jsdframe );
+    if( ! jsdscript )
+        return NULL;
+
+    script = _scriptObFromJSDScriptPtr(ee, jsdscript);
+    if( ! script )
+        return NULL;
+
+    pc = JSD_GetPCForStackFrame(context, jsdthreadstate, jsdframe);
+    if( ! pc )
+        return NULL;
+
+    return (struct Hnetscape_jsdebug_PC*) _constructJSPC(ee, script, pc);
+}
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_JSPC.h" */
+
+struct Hnetscape_jsdebug_SourceLocation *netscape_jsdebug_JSPC_getSourceLocation(struct Hnetscape_jsdebug_JSPC * self)
+{
+    JSDScript* jsdscript;
+    struct Hnetscape_jsdebug_Script* script;
+    struct Hnetscape_jsdebug_JSPC* newPCOb;
+    int line;
+    int newpc;
+    int pc;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return NULL;
+
+    script = unhand(self)->script;
+
+    if( ! script )
+        return NULL;
+
+    jsdscript = (JSDScript*) unhand(script)->_nativePtr;
+    if( ! jsdscript )
+        return NULL;
+    pc = unhand(self)->pc;
+
+    line = JSD_GetClosestLine(context, jsdscript, pc);
+    newpc = JSD_GetClosestPC(context, jsdscript, line);
+
+    newPCOb = _constructJSPC(ee, script, newpc );
+    if( ! newPCOb )
+        return NULL;
+
+    return (struct Hnetscape_jsdebug_SourceLocation *)
+        execute_java_constructor( ee, "netscape/jsdebug/JSSourceLocation", 0, 
+                                  "(Lnetscape/jsdebug/JSPC;I)",
+                                  newPCOb, line );
+}
+
+/***************************************************************************/
+/* from "_gen\netscape_jsdebug_JSSourceTextProvider.h" */
+
+struct Hnetscape_jsdebug_SourceTextItem *netscape_jsdebug_JSSourceTextProvider_loadSourceTextItem0(struct Hnetscape_jsdebug_JSSourceTextProvider * self,struct Hjava_lang_String * url)
+{
+    /* this should attempt to load the source for the indicated URL */
+    return NULL;    
+}
+
+void netscape_jsdebug_JSSourceTextProvider_refreshSourceTextVector(struct Hnetscape_jsdebug_JSSourceTextProvider * self)
+{
+
+    JHandle* vec;
+    JHandle* itemOb;
+    JSDSourceText* iterp = 0;
+    JSDSourceText* item;
+    const char* url;
+    struct Hjava_lang_String* urlOb;
+    ExecEnv* ee = EE();
+
+    if( ! context || ! controller || ! ee )
+        return;
+
+    /* create new vector */
+    vec = (JHandle*) execute_java_constructor(ee, "netscape/util/Vector", 0, "()");
+    if( ! vec )
+        return;
+
+    /* lock the native subsystem */
+    JSD_LockSourceTextSubsystem(context);
+
+    /* iterate through the native items */
+    while( 0 != (item = JSD_IterateSources(context, &iterp)) )
+    {
+        int urlStrLen;
+        int status = JSD_GetSourceStatus(context,item);
+
+        /* try to find Java object */
+        url = JSD_GetSourceURL(context, item);
+        if( ! url || 0 == (urlStrLen = strlen(url)) ) /* ignoring those with no url */
+            continue;
+
+        urlOb = makeJavaString((char*)url,urlStrLen);
+        if( ! urlOb )
+            continue;
+
+        itemOb = (JHandle*)
+            execute_java_dynamic_method( ee, (JHandle*)self, "findSourceTextItem0",
+                      "(Ljava/lang/String;)Lnetscape/jsdebug/SourceTextItem;",
+                      urlOb );
+                      
+        if( ! itemOb )
+        {
+            /* if not found then generate new item */
+            struct Hjava_lang_String* textOb;
+            const char* str;
+            int length;
+
+            if( ! JSD_GetSourceText(context, item, &str, &length ) )
+            {
+                str = "";
+                length = 0;
+            }
+            textOb = makeJavaString((char*)str, length);
+
+            itemOb = (JHandle*)
+                execute_java_constructor(ee, "netscape/jsdebug/SourceTextItem",0,  
+                     "(Ljava/lang/String;Ljava/lang/String;I)",
+                     urlOb, textOb, status );
+        }
+        else if( JSD_IsSourceDirty(context, item) && 
+                 JSD_SOURCE_CLEARED != status )
+        {
+            /* if found and dirty then update */
+            struct Hjava_lang_String* textOb;
+            const char* str;
+            int length;
+
+            if( ! JSD_GetSourceText(context, item, &str, &length ) )
+            {
+                str = "";
+                length = 0;
+            }
+            textOb = makeJavaString((char*)str, length);
+            execute_java_dynamic_method(ee, itemOb, "setText", 
+                                        "(Ljava/lang/String;)V", textOb);
+            execute_java_dynamic_method(ee, itemOb, "setStatus", 
+                                        "(I)V", status );
+            execute_java_dynamic_method(ee, itemOb, "setDirty", "(Z)V", 1 );
+        }
+
+        /* we have our copy; clear the native cached text */
+        if( JSD_SOURCE_INITED  != status && 
+            JSD_SOURCE_PARTIAL != status &&
+            JSD_SOURCE_CLEARED != status )
+        {
+            JSD_ClearSourceText(context, item);
+        }
+
+        /* set the item clean */
+        JSD_SetSourceDirty(context, item, FALSE );
+
+        /* add the item to the vector */
+        if( itemOb )
+            execute_java_dynamic_method(ee, vec, "addElement", 
+                                        "(Ljava/lang/Object;)V", itemOb );
+    }
+    /* unlock the native subsystem */
+    JSD_UnlockSourceTextSubsystem(context);
+
+    /* set main vector to our new vector */
+
+    unhand(self)->_sourceTextVector = (struct Hnetscape_util_Vector*) vec;
+}    
+
+
+#endif

mozilla/js/jsd/jsd_lock.c

@@ -0,0 +1,236 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Locking and threading support
+ */
+
+/*                                                                           
+* ifdef JSD_USE_NSPR_LOCKS then you musat build and run against NSPR2.       
+* Otherwise, there are stubs that can be filled in with your own locking     
+* code. Also, note that these stubs include a jsd_CurrentThread()            
+* implementation that only works on Win32 - this is needed for the inprocess 
+* Java-based debugger.                                                       
+*/                                                                           
+
+#include "jsd.h"
+
+#ifdef JSD_THREADSAFE
+
+#ifdef JSD_USE_NSPR_LOCKS
+
+#include "prlock.h"
+#include "prthread.h"
+
+#ifdef JSD_ATTACH_THREAD_HACK
+#include "pprthred.h"   /* need this as long as JS_AttachThread is needed */
+#endif
+
+typedef struct JSDStaticLock
+{
+    void*     owner;
+    PRLock*   lock;
+    int       count;
+#ifdef DEBUG
+    uint16    sig;
+#endif
+} JSDStaticLock;
+
+/* 
+ * This exists to wrap non-NSPR theads (e.g. Java threads) in NSPR wrappers.
+ * XXX We ignore the memory leak issue.
+ * It is claimed that future versions of NSPR will automatically wrap on 
+ * the call to PR_GetCurrentThread.
+ *
+ * XXX We ignore the memory leak issue - i.e. we never call PR_DetachThread.
+ *
+ */
+#undef _CURRENT_THREAD
+#ifdef JSD_ATTACH_THREAD_HACK
+#define _CURRENT_THREAD(out)                                                  \
+JS_BEGIN_MACRO                                                                \
+    out = (void*) PR_GetCurrentThread();                                      \
+    if(!out)                                                                  \
+        out = (void*) JS_AttachThread(PR_USER_THREAD,PR_PRIORITY_NORMAL,NULL);\
+    JS_ASSERT(out);                                                           \
+JS_END_MACRO
+#else
+#define _CURRENT_THREAD(out)             \
+JS_BEGIN_MACRO                           \
+    out = (void*) PR_GetCurrentThread(); \
+    JS_ASSERT(out);                      \
+JS_END_MACRO
+#endif
+
+#ifdef DEBUG
+#define JSD_LOCK_SIG 0x10CC10CC
+void ASSERT_VALID_LOCK(JSDStaticLock* lock)
+{
+    JS_ASSERT(lock);
+    JS_ASSERT(lock->lock);
+    JS_ASSERT(lock->count >= 0);
+    JS_ASSERT((! lock->count && ! lock->owner) || (lock->count && lock->owner));
+    JS_ASSERT(lock->sig == (uint16) JSD_LOCK_SIG);
+}    
+#else
+#define ASSERT_VALID_LOCK(x) ((void)0)
+#endif
+
+void*
+jsd_CreateLock()
+{
+    JSDStaticLock* lock;
+
+    if( ! (lock = calloc(1, sizeof(JSDStaticLock))) || 
+        ! (lock->lock = PR_NewLock()) )
+    {
+        if(lock)
+        {
+            free(lock);
+            lock = NULL;
+        }
+    }
+#ifdef DEBUG
+    if(lock) lock->sig = (uint16) JSD_LOCK_SIG;
+#endif
+    return lock;
+}    
+
+void
+jsd_Lock(JSDStaticLock* lock)
+{
+    void* me;
+
+    _CURRENT_THREAD(me);
+
+    ASSERT_VALID_LOCK(lock);
+
+    if(lock->owner == me)
+        lock->count++;
+    else
+    {
+        PR_Lock(lock->lock);            /* this can block... */
+        JS_ASSERT(lock->owner == 0);
+        lock->count = 1;
+        lock->owner = me;
+    }
+    ASSERT_VALID_LOCK(lock);
+}    
+
+void
+jsd_Unlock(JSDStaticLock* lock)
+{
+    void* me;
+
+    ASSERT_VALID_LOCK(lock);
+    _CURRENT_THREAD(me);
+
+    if(lock->owner != me)
+    {
+        JS_ASSERT(0);   /* it's an error to unlock a lock you don't own */
+        return;
+    }
+    if(--lock->count == 0)
+    {
+        lock->owner = NULL;
+        PR_Unlock(lock->lock);
+    }
+    ASSERT_VALID_LOCK(lock);
+}    
+
+#ifdef DEBUG
+JSBool
+jsd_IsLocked(JSDStaticLock* lock)
+{
+    void* me;
+    ASSERT_VALID_LOCK(lock);
+    _CURRENT_THREAD(me);
+    return lock->owner == me ? JS_TRUE : JS_FALSE;
+}    
+#endif /* DEBUG */
+
+void*
+jsd_CurrentThread()
+{
+    void* me;
+    _CURRENT_THREAD(me);
+    return me;
+}    
+
+
+#else  /* ! JSD_USE_NSPR_LOCKS */
+
+#ifdef WIN32    
+#pragma message("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+#pragma message("!! you are compiling the stubbed version of jsd_lock.c !!")
+#pragma message("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
+#endif
+
+/*
+ * NOTE: 'Real' versions of these locks must be reentrant in the sense that 
+ * they support nested calls to lock and unlock. 
+ */
+
+void*
+jsd_CreateLock()
+{
+    return (void*)1;
+}    
+
+void
+jsd_Lock(void* lock)
+{
+}    
+
+void
+jsd_Unlock(void* lock)
+{
+}    
+
+#ifdef DEBUG
+JSBool
+jsd_IsLocked(void* lock)
+{
+    return JS_TRUE;
+}    
+#endif /* DEBUG */
+
+/* 
+ * This Windows only thread id code is here to allow the Java-based 
+ * JSDebugger to work with the single threaded js.c shell (even without 
+ * real locking and threading support).
+ */
+
+#ifdef WIN32    
+/* bogus (but good enough) declaration*/
+extern void* __stdcall GetCurrentThreadId(void);
+#endif
+
+void*
+jsd_CurrentThread()
+{
+#ifdef WIN32    
+    return GetCurrentThreadId();
+#else
+    return (void*)1;
+#endif
+}    
+
+#endif /* JSD_USE_NSPR_LOCKS */
+
+#endif /* JSD_THREADSAFE */

mozilla/js/jsd/jsd_lock.h

@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * Header for JavaScript Debugging support - Locking and threading functions
+ */
+
+#ifndef jsd_lock_h___
+#define jsd_lock_h___
+
+/* 
+ * If you want to support threading and locking, define JSD_THREADSAFE and 
+ * implement the functions below.
+ */
+
+/*
+ * NOTE: These locks must be reentrant in the sense that they support
+ * nested calls to lock and unlock.
+ */
+
+extern void*
+jsd_CreateLock();
+
+extern void
+jsd_Lock(void* lock);
+
+extern void
+jsd_Unlock(void* lock);
+
+#ifdef DEBUG
+extern JSBool
+jsd_IsLocked(void* lock);
+#endif /* DEBUG */
+
+extern void*
+jsd_CurrentThread();
+
+#endif /* jsd_lock_h___ */

mozilla/js/jsd/jsd_obj.c

@@ -0,0 +1,307 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Object support
+ */
+
+#include "jsd.h"
+
+/*
+* #define JSD_TRACE 1
+*/
+
+#ifdef JSD_TRACE
+#define TRACEOBJ(jsdc, jsdobj, which) _traceObj(jsdc, jsdobj, which)
+
+static char *
+_describeObj(JSDContext* jsdc, JSDObject *jsdobj)
+{
+    return
+        JS_smprintf("%0x new'd in %s at line %d using ctor %s in %s at line %d",
+                    (int)jsdobj,
+                    JSD_GetObjectNewURL(jsdc, jsdobj),
+                    JSD_GetObjectNewLineNumber(jsdc, jsdobj),
+                    JSD_GetObjectConstructorName(jsdc, jsdobj),
+                    JSD_GetObjectConstructorURL(jsdc, jsdobj),
+                    JSD_GetObjectConstructorLineNumber(jsdc, jsdobj));
+}
+
+static void
+_traceObj(JSDContext* jsdc, JSDObject* jsdobj, int which)
+{
+    char* description;
+
+    if( !jsdobj )
+        return;
+
+    description = _describeObj(jsdc, jsdobj);
+
+    printf("%s : %s\n",
+           which == 0 ? "new  " :
+           which == 1 ? "final" :
+                        "ctor ",
+           description);
+    if(description)
+        free(description);
+}
+#else
+#define TRACEOBJ(jsdc, jsdobj, which) ((void)0)
+#endif /* JSD_TRACE */
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_OBJECT(JSDObject* jsdobj)
+{
+    JS_ASSERT(jsdobj);
+    JS_ASSERT(!JS_CLIST_IS_EMPTY(&jsdobj->links));
+    JS_ASSERT(jsdobj->obj);
+}
+#endif
+
+
+static void
+_destroyJSDObject(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    JS_ASSERT(JSD_OBJECTS_LOCKED(jsdc));
+
+    JS_REMOVE_LINK(&jsdobj->links);
+    JS_HashTableRemove(jsdc->objectsTable, jsdobj->obj);
+
+    if(jsdobj->newURL)
+        jsd_DropAtom(jsdc, jsdobj->newURL);
+    if(jsdobj->ctorURL)
+        jsd_DropAtom(jsdc, jsdobj->ctorURL);
+    if(jsdobj->ctorName)
+        jsd_DropAtom(jsdc, jsdobj->ctorName);
+    free(jsdobj);
+}
+
+static JSDObject*
+_createJSDObject(JSDContext* jsdc, JSContext *cx, JSObject *obj)
+{
+    JSDObject* jsdobj;
+    JSStackFrame* fp;
+    JSStackFrame* iter = NULL;
+    const char* newURL;
+    jsbytecode* pc;
+
+    JS_ASSERT(JSD_OBJECTS_LOCKED(jsdc));
+
+    jsdobj = (JSDObject*) calloc(1, sizeof(JSDObject));
+    if( jsdobj )
+    {
+        JS_INIT_CLIST(&jsdobj->links);
+        JS_APPEND_LINK(&jsdobj->links, &jsdc->objectsList);
+        jsdobj->obj = obj;
+        JS_HashTableAdd(jsdc->objectsTable, obj, jsdobj);
+
+        /* walk the stack to find js frame (if any) causing creation */
+        while( NULL != (fp = JS_FrameIterator(cx, &iter)) )
+        {
+            if( !JS_IsNativeFrame(cx, fp) )
+            {
+                JSScript* script = JS_GetFrameScript(cx, fp);
+                if( !script )
+                    continue;
+
+                newURL = JS_GetScriptFilename(cx, script);
+                if( newURL )
+                    jsdobj->newURL = jsd_AddAtom(jsdc, newURL);
+
+                pc = JS_GetFramePC(cx, fp);
+                if( pc )
+                    jsdobj->newLineno = JS_PCToLineNumber(cx, script, pc);
+
+                break;
+            }
+        }
+    }
+    return jsdobj;
+}
+
+void JS_DLL_CALLBACK
+jsd_ObjectHook(JSContext *cx, JSObject *obj, JSBool isNew, void *closure)
+{
+    JSDObject* jsdobj;
+    JSDContext* jsdc = (JSDContext*) closure;
+
+    if( ! jsdc || ! jsdc->inited )
+        return;
+
+    JSD_LOCK_OBJECTS(jsdc);
+    if(isNew)
+    {
+        jsdobj = _createJSDObject(jsdc, cx, obj);
+        TRACEOBJ(jsdc, jsdobj, 0);
+    }
+    else
+    {
+        jsdobj = jsd_GetJSDObjectForJSObject(jsdc, obj);
+        if( jsdobj )
+        {
+            TRACEOBJ(jsdc, jsdobj, 1);
+            _destroyJSDObject(jsdc, jsdobj);
+        }
+    }
+    JSD_UNLOCK_OBJECTS(jsdc);
+}
+
+void
+jsd_Constructing(JSDContext* jsdc, JSContext *cx, JSObject *obj,
+                 JSStackFrame *fp)
+{
+    JSDObject* jsdobj;
+    JSScript* script;
+    JSDScript* jsdscript;
+    const char* ctorURL;
+    const char* ctorName;
+
+    JSD_LOCK_OBJECTS(jsdc);
+    jsdobj = jsd_GetJSDObjectForJSObject(jsdc, obj);
+    if( jsdobj && !jsdobj->ctorURL && !JS_IsNativeFrame(cx, fp) )
+    {
+        script = JS_GetFrameScript(cx, fp);
+        if( script )
+        {
+            ctorURL = JS_GetScriptFilename(cx, script);
+            if( ctorURL )
+                jsdobj->ctorURL = jsd_AddAtom(jsdc, ctorURL);
+
+            JSD_LOCK_SCRIPTS(jsdc);
+            jsdscript = jsd_FindJSDScript(jsdc, script);
+            JSD_UNLOCK_SCRIPTS(jsdc);
+            if( jsdscript )
+            {
+                ctorName = jsd_GetScriptFunctionName(jsdc, jsdscript);
+                if( ctorName )
+                    jsdobj->ctorName = jsd_AddAtom(jsdc, ctorName);
+            }
+            jsdobj->ctorLineno = JS_GetScriptBaseLineNumber(cx, script);
+        }
+    }
+    TRACEOBJ(jsdc, jsdobj, 3);
+    JSD_UNLOCK_OBJECTS(jsdc);
+}
+
+JS_STATIC_DLL_CALLBACK(JSHashNumber)
+_hash_root(const void *key)
+{
+    return ((JSHashNumber) key) >> 2; /* help lame MSVC1.5 on Win16 */
+}
+
+JSBool
+jsd_InitObjectManager(JSDContext* jsdc)
+{
+    JS_INIT_CLIST(&jsdc->objectsList);
+    jsdc->objectsTable = JS_NewHashTable(256, _hash_root,
+                                         JS_CompareValues, JS_CompareValues,
+                                         NULL, NULL);
+    return (JSBool) jsdc->objectsTable;
+}
+
+void
+jsd_DestroyObjectManager(JSDContext* jsdc)
+{
+    JSD_LOCK_OBJECTS(jsdc);
+    while( !JS_CLIST_IS_EMPTY(&jsdc->objectsList) )
+        _destroyJSDObject(jsdc, (JSDObject*)JS_NEXT_LINK(&jsdc->objectsList));
+    JS_HashTableDestroy(jsdc->objectsTable);
+    JSD_UNLOCK_OBJECTS(jsdc);
+}
+
+JSDObject*
+jsd_IterateObjects(JSDContext* jsdc, JSDObject** iterp)
+{
+    JSDObject *jsdobj = *iterp;
+
+    JS_ASSERT(JSD_OBJECTS_LOCKED(jsdc));
+
+    if( !jsdobj )
+        jsdobj = (JSDObject *)jsdc->objectsList.next;
+    if( jsdobj == (JSDObject *)&jsdc->objectsList )
+        return NULL;
+    *iterp = (JSDObject*) jsdobj->links.next;
+    return jsdobj;
+}
+
+JSObject*
+jsd_GetWrappedObject(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    return jsdobj->obj;
+}
+
+const char*
+jsd_GetObjectNewURL(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    if( jsdobj->newURL )
+        return JSD_ATOM_TO_STRING(jsdobj->newURL);
+    return NULL;
+}
+
+uintN
+jsd_GetObjectNewLineNumber(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    return jsdobj->newLineno;
+}
+
+const char*
+jsd_GetObjectConstructorURL(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    if( jsdobj->ctorURL )
+        return JSD_ATOM_TO_STRING(jsdobj->ctorURL);
+    return NULL;
+}
+
+uintN
+jsd_GetObjectConstructorLineNumber(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    return jsdobj->ctorLineno;
+}
+
+const char*
+jsd_GetObjectConstructorName(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    if( jsdobj->ctorName )
+        return JSD_ATOM_TO_STRING(jsdobj->ctorName);
+    return NULL;
+}
+
+JSDObject*
+jsd_GetJSDObjectForJSObject(JSDContext* jsdc, JSObject* jsobj)
+{
+    JSDObject* jsdobj;
+
+    JSD_LOCK_OBJECTS(jsdc);
+    jsdobj = (JSDObject*) JS_HashTableLookup(jsdc->objectsTable, jsobj);
+    JSD_UNLOCK_OBJECTS(jsdc);
+    return jsdobj;
+}
+
+JSDObject*
+jsd_GetObjectForValue(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return jsd_GetJSDObjectForJSObject(jsdc, JSVAL_TO_OBJECT(jsdval->val));
+}
+
+JSDValue*
+jsd_GetValueForObject(JSDContext* jsdc, JSDObject* jsdobj)
+{
+    return jsd_NewValue(jsdc, OBJECT_TO_JSVAL(jsdobj->obj));
+}
+
+

mozilla/js/jsd/jsd_scpt.c

@@ -0,0 +1,668 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Script support
+ */
+
+#include "jsd.h"
+
+/* Comment this out to disable (NT specific) dumping as we go */
+/*
+** #ifdef DEBUG      
+** #define JSD_DUMP 1
+** #endif            
+*/
+
+#define NOT_SET_YET -1
+
+/***************************************************************************/
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_SCRIPT(JSDScript* jsdscript)
+{
+    JS_ASSERT(jsdscript);
+    JS_ASSERT(jsdscript->script);
+}
+void JSD_ASSERT_VALID_EXEC_HOOK(JSDExecHook* jsdhook)
+{
+    JS_ASSERT(jsdhook);
+    JS_ASSERT(jsdhook->hook);
+}
+#endif
+
+#ifdef LIVEWIRE
+static JSBool
+HasFileExtention(const char* name, const char* ext)
+{
+    int i;
+    int len = strlen(ext);
+    const char* p = strrchr(name,'.');
+    if( !p )
+        return JS_FALSE;
+    p++;
+    for(i = 0; i < len; i++ )
+    {
+        JS_ASSERT(islower(ext[i]));
+        if( 0 == p[i] || tolower(p[i]) != ext[i] )
+            return JS_FALSE;
+    }
+    if( 0 != p[i] )
+        return JS_FALSE;
+    return JS_TRUE;
+}    
+#endif /* LIVEWIRE */
+
+static JSDScript*
+_newJSDScript(JSDContext*  jsdc,
+              JSContext    *cx,
+              JSScript     *script,
+              JSFunction*  function)
+{
+    JSDScript*  jsdscript;
+    uintN     lineno;
+    const char* raw_filename;
+
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    /* these are inlined javascript: urls and we can't handle them now */
+    lineno = (uintN) JS_GetScriptBaseLineNumber(cx, script);
+    if( lineno == 0 )
+        return NULL;
+
+    jsdscript = (JSDScript*) calloc(1, sizeof(JSDScript));
+    if( ! jsdscript )
+        return NULL;
+
+    raw_filename = JS_GetScriptFilename(cx,script);
+    
+    JS_APPEND_LINK(&jsdscript->links, &jsdc->scripts);
+    jsdscript->jsdc         = jsdc;
+    jsdscript->script       = script;        
+    jsdscript->function     = function;
+    jsdscript->lineBase     = lineno;
+    jsdscript->lineExtent   = (uintN)NOT_SET_YET;
+#ifndef LIVEWIRE
+    jsdscript->url          = (char*) jsd_BuildNormalizedURL(raw_filename);
+#else
+    jsdscript->app = LWDBG_GetCurrentApp();    
+    if( jsdscript->app && raw_filename )
+    {
+        jsdscript->url = jsdlw_BuildAppRelativeFilename(jsdscript->app, raw_filename);
+        if( function )
+        {
+            jsdscript->lwscript = 
+                LWDBG_GetScriptOfFunction(jsdscript->app,
+                                          JS_GetFunctionName(function));
+    
+            /* also, make sure this file is added to filelist if is .js file */
+            if( HasFileExtention(raw_filename,"js") || 
+                HasFileExtention(raw_filename,"sjs") )
+            {
+                jsdlw_PreLoadSource(jsdc, jsdscript->app, raw_filename, JS_FALSE);
+            }
+        }
+        else
+        {
+            jsdscript->lwscript = LWDBG_GetCurrentTopLevelScript();
+        }
+    }
+#endif
+
+    JS_INIT_CLIST(&jsdscript->hooks);
+    
+    return jsdscript;
+}           
+
+static void 
+_destroyJSDScript(JSDContext*  jsdc,
+                  JSDScript*   jsdscript)
+{
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    /* destroy all hooks */
+    jsd_ClearAllExecutionHooksForScript(jsdc, jsdscript);
+
+    JS_REMOVE_LINK(&jsdscript->links);
+    if(jsdscript->url)
+        free(jsdscript->url);
+
+    if(jsdscript)
+        free(jsdscript);
+}
+
+/***************************************************************************/
+
+#ifdef JSD_DUMP
+static void
+_dumpJSDScript(JSDContext* jsdc, JSDScript* jsdscript, const char* leadingtext)
+{
+    const char* name;
+    const char* fun;
+    uintN base;
+    uintN extent;
+    char Buf[256];
+    
+    name   = jsd_GetScriptFilename(jsdc, jsdscript);
+    fun    = jsd_GetScriptFunctionName(jsdc, jsdscript);
+    base   = jsd_GetScriptBaseLineNumber(jsdc, jsdscript);
+    extent = jsd_GetScriptLineExtent(jsdc, jsdscript);
+    
+    sprintf( Buf, "%sscript=%08X, %s, %s, %d-%d\n", 
+             leadingtext,
+             (unsigned) jsdscript->script,
+             name ? name : "no URL", 
+             fun  ? fun  : "no fun", 
+             base, base + extent - 1 );
+    OutputDebugString( Buf );
+}
+
+static void
+_dumpJSDScriptList( JSDContext* jsdc )
+{
+    JSDScript* iterp = NULL;
+    JSDScript* jsdscript = NULL;
+    
+    OutputDebugString( "*** JSDScriptDump\n" );
+    while( NULL != (jsdscript = jsd_IterateScripts(jsdc, &iterp)) )
+        _dumpJSDScript( jsdc, jsdscript, "  script: " );
+}
+#endif /* JSD_DUMP */
+
+/***************************************************************************/
+void 
+jsd_DestroyAllJSDScripts( JSDContext* jsdc )
+{
+    JSDScript *jsdscript;
+    JSDScript *next;
+
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    for( jsdscript = (JSDScript*)jsdc->scripts.next;
+         jsdscript != (JSDScript*)&jsdc->scripts;
+         jsdscript = next )
+    {
+        next = (JSDScript*)jsdscript->links.next;
+        _destroyJSDScript( jsdc, jsdscript );
+    }
+}
+
+JSDScript*
+jsd_FindJSDScript( JSDContext*  jsdc,
+                   JSScript     *script )
+{
+    JSDScript *jsdscript;
+
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    for( jsdscript = (JSDScript *)jsdc->scripts.next;
+         jsdscript != (JSDScript *)&jsdc->scripts;
+         jsdscript = (JSDScript *)jsdscript->links.next )
+    {
+        if (jsdscript->script == script)
+            return jsdscript;
+    }
+    return NULL;
+}               
+
+JSDScript*
+jsd_IterateScripts(JSDContext* jsdc, JSDScript **iterp)
+{
+    JSDScript *jsdscript = *iterp;
+    
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    if( !jsdscript )
+        jsdscript = (JSDScript *)jsdc->scripts.next;
+    if( jsdscript == (JSDScript *)&jsdc->scripts )
+        return NULL;
+    *iterp = (JSDScript*) jsdscript->links.next;
+    return jsdscript;
+}
+
+JSBool
+jsd_IsActiveScript(JSDContext* jsdc, JSDScript *jsdscript)
+{
+    JSDScript *current;
+
+    JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
+
+    for( current = (JSDScript *)jsdc->scripts.next;
+         current != (JSDScript *)&jsdc->scripts;
+         current = (JSDScript *)current->links.next )
+    {
+        if(jsdscript == current)
+            return JS_TRUE;
+    }
+    return JS_FALSE;
+}        
+
+const char*
+jsd_GetScriptFilename(JSDContext* jsdc, JSDScript *jsdscript)
+{
+    return jsdscript->url;
+}
+
+const char*
+jsd_GetScriptFunctionName(JSDContext* jsdc, JSDScript *jsdscript)
+{
+    if( ! jsdscript->function )
+        return NULL;
+    return JS_GetFunctionName(jsdscript->function);
+}
+
+uintN
+jsd_GetScriptBaseLineNumber(JSDContext* jsdc, JSDScript *jsdscript)
+{
+    return jsdscript->lineBase;
+}
+
+uintN
+jsd_GetScriptLineExtent(JSDContext* jsdc, JSDScript *jsdscript)
+{
+    if( NOT_SET_YET == jsdscript->lineExtent )
+        jsdscript->lineExtent = JS_GetScriptLineExtent(jsdc->dumbContext, jsdscript->script);
+    return jsdscript->lineExtent;
+}
+
+jsuword
+jsd_GetClosestPC(JSDContext* jsdc, JSDScript* jsdscript, uintN line)
+{
+#ifdef LIVEWIRE
+    if( jsdscript && jsdscript->lwscript )
+    {
+        uintN newline;
+        jsdlw_RawToProcessedLineNumber(jsdc, jsdscript, line, &newline);
+        if( line != newline )
+            line = newline;
+    }
+#endif
+
+    return (jsuword) JS_LineNumberToPC(jsdc->dumbContext, 
+                                        jsdscript->script, line );
+}
+
+uintN
+jsd_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc)
+{
+    uintN first = jsdscript->lineBase;
+    uintN last = first + jsd_GetScriptLineExtent(jsdc, jsdscript) - 1;
+    uintN line = JS_PCToLineNumber(jsdc->dumbContext, 
+                                     jsdscript->script, (jsbytecode*)pc);
+
+    if( line < first )
+        return first;
+    if( line > last )
+        return last;
+
+#ifdef LIVEWIRE
+    if( jsdscript && jsdscript->lwscript )
+    {
+        uintN newline;
+        jsdlw_ProcessedToRawLineNumber(jsdc, jsdscript, line, &newline);
+        line = newline;
+    }
+#endif
+
+    return line;    
+}
+
+JSBool
+jsd_SetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc hook, void* callerdata)
+{
+    JSD_LOCK();
+    jsdc->scriptHook = hook;
+    jsdc->scriptHookData = callerdata;
+    JSD_UNLOCK();
+    return JS_TRUE;
+}
+
+JSBool
+jsd_GetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc* hook, void** callerdata)
+{
+    JSD_LOCK();
+    if( hook )
+        *hook = jsdc->scriptHook;
+    if( callerdata )
+        *callerdata = jsdc->scriptHookData;
+    JSD_UNLOCK();
+    return JS_TRUE;
+}    
+
+/***************************************************************************/
+
+void JS_DLL_CALLBACK
+jsd_NewScriptHookProc( 
+                JSContext   *cx,
+                const char  *filename,      /* URL this script loads from */
+                uintN       lineno,         /* line where this script starts */
+                JSScript    *script,
+                JSFunction  *fun,                
+                void*       callerdata )
+{
+    JSDScript* jsdscript = NULL;
+    JSDContext* jsdc = (JSDContext*) callerdata;
+    JSD_ScriptHookProc      hook;
+    void*                   hookData;
+    
+    JSD_ASSERT_VALID_CONTEXT(jsdc);
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return;
+    
+#ifdef LIVEWIRE
+    if( 1 == lineno )
+        jsdlw_PreLoadSource(jsdc, LWDBG_GetCurrentApp(), filename, JS_TRUE );
+#endif
+    
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = _newJSDScript(jsdc, cx, script, fun);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    if( ! jsdscript )
+        return;
+
+#ifdef JSD_DUMP
+    JSD_LOCK_SCRIPTS(jsdc);
+    _dumpJSDScript(jsdc, jsdscript, "***NEW Script: ");
+    _dumpJSDScriptList( jsdc );
+    JSD_UNLOCK_SCRIPTS(jsdc);
+#endif /* JSD_DUMP */
+
+    /* local in case jsdc->scriptHook gets cleared on another thread */
+    JSD_LOCK();
+    hook = jsdc->scriptHook;
+    hookData = jsdc->scriptHookData;
+    JSD_UNLOCK();
+
+    if( hook )
+        hook(jsdc, jsdscript, JS_TRUE, hookData);
+}                
+
+void JS_DLL_CALLBACK
+jsd_DestroyScriptHookProc( 
+                JSContext   *cx,
+                JSScript    *script,
+                void*       callerdata )
+{
+    JSDScript* jsdscript = NULL;
+    JSDContext* jsdc = (JSDContext*) callerdata;
+    JSD_ScriptHookProc      hook;
+    void*                   hookData;
+    
+    JSD_ASSERT_VALID_CONTEXT(jsdc);
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return;
+    
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+
+    if( ! jsdscript )
+        return;
+
+#ifdef JSD_DUMP
+    JSD_LOCK_SCRIPTS(jsdc);
+    _dumpJSDScript(jsdc, jsdscript, "***DESTROY Script: ");
+    JSD_UNLOCK_SCRIPTS(jsdc);
+#endif /* JSD_DUMP */
+
+    /* local in case hook gets cleared on another thread */
+    JSD_LOCK();
+    hook = jsdc->scriptHook;
+    hookData = jsdc->scriptHookData;
+    JSD_UNLOCK();
+
+    if( hook )
+        hook(jsdc, jsdscript, JS_FALSE, hookData);
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    _destroyJSDScript(jsdc, jsdscript);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+
+#ifdef JSD_DUMP
+    JSD_LOCK_SCRIPTS(jsdc);
+    _dumpJSDScriptList(jsdc);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+#endif /* JSD_DUMP */
+}                
+
+
+/***************************************************************************/
+
+static JSDExecHook*
+_findHook(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc)
+{
+    JSDExecHook* jsdhook;
+    JSCList* list = &jsdscript->hooks;
+
+    for( jsdhook = (JSDExecHook*)list->next;
+         jsdhook != (JSDExecHook*)list;
+         jsdhook = (JSDExecHook*)jsdhook->links.next )
+    {
+        if (jsdhook->pc == pc)
+            return jsdhook;
+    }
+    return NULL;
+}
+
+static JSBool
+_isActiveHook(JSDContext* jsdc, JSScript *script, JSDExecHook* jsdhook)
+{
+    JSDExecHook* current;
+    JSCList* list;
+    JSDScript* jsdscript;
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    if( ! jsdscript)
+    {
+        JSD_UNLOCK_SCRIPTS(jsdc);
+        return JS_FALSE;
+    }
+
+    list = &jsdscript->hooks;
+
+    for( current = (JSDExecHook*)list->next;
+         current != (JSDExecHook*)list;
+         current = (JSDExecHook*)current->links.next )
+    {
+        if(current == jsdhook)
+        {
+            JSD_UNLOCK_SCRIPTS(jsdc);
+            return JS_TRUE;
+        }
+    }
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    return JS_FALSE;
+}
+
+
+JSTrapStatus JS_DLL_CALLBACK
+jsd_TrapHandler(JSContext *cx, JSScript *script, jsbytecode *pc, jsval *rval,
+                void *closure)
+{
+    JSDExecHook* jsdhook = (JSDExecHook*) closure;
+    JSD_ExecutionHookProc hook;
+    void* hookData;
+    JSDContext*  jsdc;
+    JSDScript* jsdscript;
+
+    JSD_LOCK();
+
+    if( NULL == (jsdc = jsd_JSDContextForJSContext(cx)) ||
+        ! _isActiveHook(jsdc, script, jsdhook) )
+    {
+        JSD_UNLOCK();
+        return JSTRAP_CONTINUE;
+    }
+
+    JSD_ASSERT_VALID_EXEC_HOOK(jsdhook);
+    JS_ASSERT(jsdhook->pc == (jsuword)pc);
+    JS_ASSERT(jsdhook->jsdscript->script == script);
+    JS_ASSERT(jsdhook->jsdscript->jsdc == jsdc);
+
+    hook = jsdhook->hook;
+    hookData = jsdhook->callerdata;
+    jsdscript = jsdhook->jsdscript;
+
+    /* do not use jsdhook-> after this point */
+    JSD_UNLOCK();
+
+    if( ! jsdc || ! jsdc->inited )
+        return JSTRAP_CONTINUE;
+
+    if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+        return JSTRAP_CONTINUE;
+
+#ifdef LIVEWIRE
+    if( ! jsdlw_UserCodeAtPC(jsdc, jsdscript, (jsuword)pc) )
+        return JSTRAP_CONTINUE;
+#endif
+
+    return jsd_CallExecutionHook(jsdc, cx, JSD_HOOK_BREAKPOINT,
+                                 hook, hookData, rval);
+}
+
+
+
+JSBool
+jsd_SetExecutionHook(JSDContext*           jsdc, 
+                     JSDScript*            jsdscript,
+                     jsuword               pc,
+                     JSD_ExecutionHookProc hook,
+                     void*                 callerdata)
+{
+    JSDExecHook* jsdhook;
+
+    JSD_LOCK();
+    if( ! hook )
+    {
+        jsd_ClearExecutionHook(jsdc, jsdscript, pc);
+        JSD_UNLOCK();
+        return JS_TRUE;
+    }
+
+    jsdhook = _findHook(jsdc, jsdscript, pc);
+    if( jsdhook )
+    {
+        jsdhook->hook       = hook;
+        jsdhook->callerdata = callerdata;
+        return JS_TRUE;
+    }
+    /* else... */
+
+    jsdhook = (JSDExecHook*)calloc(1, sizeof(JSDExecHook));
+    if( ! jsdhook )
+        return JS_FALSE;
+    jsdhook->jsdscript  = jsdscript;
+    jsdhook->pc         = pc;
+    jsdhook->hook       = hook;
+    jsdhook->callerdata = callerdata;
+
+    if( ! JS_SetTrap(jsdc->dumbContext, jsdscript->script, 
+                     (jsbytecode*)pc, jsd_TrapHandler, (void*) jsdhook) )
+    {
+        free(jsdhook);
+        return JS_FALSE;
+    }
+
+    JS_APPEND_LINK(&jsdhook->links, &jsdscript->hooks);
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearExecutionHook(JSDContext*           jsdc, 
+                       JSDScript*            jsdscript,
+                       jsuword               pc)
+{
+    JSDExecHook* jsdhook;
+
+    JSD_LOCK();
+
+    jsdhook = _findHook(jsdc, jsdscript, pc);
+    if( ! jsdhook )
+    {
+        JS_ASSERT(0);
+        JSD_UNLOCK();
+        return JS_FALSE;
+    }
+
+    JS_ClearTrap(jsdc->dumbContext, jsdscript->script, 
+                 (jsbytecode*)pc, NULL, NULL );
+
+    JS_REMOVE_LINK(&jsdhook->links);
+    free(jsdhook);
+
+    JSD_UNLOCK();
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearAllExecutionHooksForScript(JSDContext* jsdc, JSDScript* jsdscript)
+{
+    JSDExecHook* jsdhook;
+    JSCList* list = &jsdscript->hooks;
+
+    JSD_LOCK();
+
+    while( (JSDExecHook*)list != (jsdhook = (JSDExecHook*)list->next) )
+    {
+        JS_REMOVE_LINK(&jsdhook->links);
+        free(jsdhook);
+    }
+
+    JS_ClearScriptTraps(jsdc->dumbContext, jsdscript->script);
+    JSD_UNLOCK();
+
+    return JS_TRUE;
+}
+
+JSBool
+jsd_ClearAllExecutionHooks(JSDContext* jsdc)
+{
+    JSDScript* jsdscript;
+    JSDScript* iterp = NULL;
+
+    JSD_LOCK();
+    while( NULL != (jsdscript = jsd_IterateScripts(jsdc, &iterp)) )
+        jsd_ClearAllExecutionHooksForScript(jsdc, jsdscript);
+    JSD_UNLOCK();
+    return JS_TRUE;
+}
+
+void
+jsd_ScriptCreated(JSDContext* jsdc,
+                  JSContext   *cx,
+                  const char  *filename,    /* URL this script loads from */
+                  uintN       lineno,       /* line where this script starts */
+                  JSScript    *script,
+                  JSFunction  *fun)
+{
+    jsd_NewScriptHookProc(cx, filename, lineno, script, fun, jsdc);
+}
+
+void
+jsd_ScriptDestroyed(JSDContext* jsdc,
+                    JSContext   *cx,
+                    JSScript    *script)
+{
+    jsd_DestroyScriptHookProc(cx, script, jsdc);
+}

mozilla/js/jsd/jsd_stak.c

@@ -0,0 +1,429 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Call stack support
+ */
+
+#include "jsd.h"
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_THREAD_STATE(JSDThreadState* jsdthreadstate)
+{
+    JS_ASSERT(jsdthreadstate);
+    JS_ASSERT(jsdthreadstate->stackDepth > 0);
+}
+
+void JSD_ASSERT_VALID_STACK_FRAME(JSDStackFrameInfo* jsdframe)
+{
+    JS_ASSERT(jsdframe);
+    JS_ASSERT(jsdframe->jsdthreadstate);
+}
+#endif
+
+static JSDStackFrameInfo* 
+_addNewFrame(JSDContext*        jsdc,
+             JSDThreadState*    jsdthreadstate,
+             JSScript*          script,
+             jsuword            pc,
+             JSStackFrame*      fp)
+{
+    JSDStackFrameInfo* jsdframe;
+    JSDScript*         jsdscript;
+
+    JSD_LOCK_SCRIPTS(jsdc);
+    jsdscript = jsd_FindJSDScript(jsdc, script);
+    JSD_UNLOCK_SCRIPTS(jsdc);
+    if( ! jsdscript )
+        return NULL;
+
+    jsdframe = (JSDStackFrameInfo*) calloc(1, sizeof(JSDStackFrameInfo));
+    if( ! jsdframe )
+        return NULL;
+
+    jsdframe->jsdthreadstate = jsdthreadstate;
+    jsdframe->jsdscript      = jsdscript     ;
+    jsdframe->pc             = pc            ;
+    jsdframe->fp             = fp            ;
+
+    JS_APPEND_LINK(&jsdframe->links, &jsdthreadstate->stack);
+    jsdthreadstate->stackDepth++;
+
+    return jsdframe;
+}
+
+static void
+_destroyFrame(JSDStackFrameInfo* jsdframe)
+{
+    /* kill any alloc'd objects in frame here... */
+
+    if( jsdframe )
+        free(jsdframe);
+}
+
+
+JSDThreadState*
+jsd_NewThreadState(JSDContext* jsdc, JSContext *cx )
+{
+    JSDThreadState* jsdthreadstate;
+    JSStackFrame *  iter = NULL;
+    JSStackFrame *  fp;
+
+    jsdthreadstate = (JSDThreadState*)calloc(1, sizeof(JSDThreadState));
+    if( ! jsdthreadstate )
+        return NULL;
+
+    jsdthreadstate->context = cx;
+    jsdthreadstate->thread = JSD_CURRENT_THREAD();
+    JS_INIT_CLIST(&jsdthreadstate->stack);
+    jsdthreadstate->stackDepth = 0;
+
+    while( NULL != (fp = JS_FrameIterator(cx, &iter)) )
+    {
+        JSScript* script = JS_GetFrameScript(cx, fp);
+        jsuword  pc = (jsuword) JS_GetFramePC(cx, fp);
+
+        if( ! script || ! pc || JS_IsNativeFrame(cx, fp) )
+            continue;
+
+        _addNewFrame( jsdc, jsdthreadstate, script, pc, fp );
+    }
+    
+    /* if there is no stack, then this threadstate can not be constructed */
+    if( 0 == jsdthreadstate->stackDepth )
+    {
+        free(jsdthreadstate);
+        return NULL;
+    }
+
+    JSD_LOCK_THREADSTATES(jsdc);
+    JS_APPEND_LINK(&jsdthreadstate->links, &jsdc->threadsStates);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdthreadstate;
+}
+
+void
+jsd_DestroyThreadState(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
+{
+    JSDStackFrameInfo* jsdframe;
+    JSCList* list;
+
+    JSD_ASSERT_VALID_THREAD_STATE(jsdthreadstate);
+    JS_ASSERT(JSD_CURRENT_THREAD() == jsdthreadstate->thread);
+
+    JSD_LOCK_THREADSTATES(jsdc);
+    JS_REMOVE_LINK(&jsdthreadstate->links);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    list = &jsdthreadstate->stack;
+    while( (JSDStackFrameInfo*)list != (jsdframe = (JSDStackFrameInfo*)list->next) )
+    {
+        JS_REMOVE_LINK(&jsdframe->links);
+        _destroyFrame(jsdframe);
+    }
+    free(jsdthreadstate);
+}
+
+uintN
+jsd_GetCountOfStackFrames(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
+{
+    uintN count = 0;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidThreadState(jsdc, jsdthreadstate) )
+        count = jsdthreadstate->stackDepth;
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return count;
+}
+
+JSDStackFrameInfo*
+jsd_GetStackFrame(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
+{
+    JSDStackFrameInfo* jsdframe = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidThreadState(jsdc, jsdthreadstate) )
+        jsdframe = (JSDStackFrameInfo*) JS_LIST_HEAD(&jsdthreadstate->stack);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdframe;
+}
+
+JSDStackFrameInfo*
+jsd_GetCallingStackFrame(JSDContext* jsdc, 
+                         JSDThreadState* jsdthreadstate,
+                         JSDStackFrameInfo* jsdframe)
+{
+    JSDStackFrameInfo* nextjsdframe = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+        if( JS_LIST_HEAD(&jsdframe->links) != &jsdframe->jsdthreadstate->stack )
+            nextjsdframe = (JSDStackFrameInfo*) JS_LIST_HEAD(&jsdframe->links);
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return nextjsdframe;
+}
+
+JSDScript*
+jsd_GetScriptForStackFrame(JSDContext* jsdc, 
+                           JSDThreadState* jsdthreadstate,
+                           JSDStackFrameInfo* jsdframe)
+{
+    JSDScript* jsdscript = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+        jsdscript = jsdframe->jsdscript;
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdscript;
+}
+
+jsuword
+jsd_GetPCForStackFrame(JSDContext* jsdc, 
+                       JSDThreadState* jsdthreadstate,
+                       JSDStackFrameInfo* jsdframe)
+{
+    jsuword pc = 0;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+        pc = jsdframe->pc;
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return pc;
+}
+
+JSDValue*
+jsd_GetCallObjectForStackFrame(JSDContext* jsdc, 
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe)
+{
+    JSObject* obj;
+    JSDValue* jsdval = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+    {
+        obj = JS_GetFrameCallObject(jsdthreadstate->context, jsdframe->fp); 
+        if(obj)                                                             
+            jsdval = JSD_NewValue(jsdc, OBJECT_TO_JSVAL(obj));              
+    }
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdval;
+}
+
+JSDValue*
+jsd_GetScopeChainForStackFrame(JSDContext* jsdc, 
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe)
+{
+    JSObject* obj;
+    JSDValue* jsdval = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+    {
+        obj = JS_GetFrameScopeChain(jsdthreadstate->context, jsdframe->fp); 
+        if(obj)                                                             
+            jsdval = JSD_NewValue(jsdc, OBJECT_TO_JSVAL(obj));              
+    }
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdval;
+}
+
+JSDValue*
+jsd_GetThisForStackFrame(JSDContext* jsdc, 
+                         JSDThreadState* jsdthreadstate,
+                         JSDStackFrameInfo* jsdframe)
+{
+    JSObject* obj;
+    JSDValue* jsdval = NULL;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+
+    if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
+    {
+        obj = JS_GetFrameThis(jsdthreadstate->context, jsdframe->fp);
+        if(obj)
+            jsdval = JSD_NewValue(jsdc, OBJECT_TO_JSVAL(obj));
+    }
+
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    return jsdval;
+}
+
+
+JSBool
+jsd_EvaluateScriptInStackFrame(JSDContext* jsdc, 
+                               JSDThreadState* jsdthreadstate,
+                               JSDStackFrameInfo* jsdframe,
+                               const char *bytes, uintN length,
+                               const char *filename, uintN lineno, jsval *rval)
+{
+    JSBool retval;
+    JSBool valid;
+    JSExceptionState* exceptionState;
+    JSContext* cx;
+
+    JS_ASSERT(JSD_CURRENT_THREAD() == jsdthreadstate->thread);
+
+    JSD_LOCK_THREADSTATES(jsdc);
+    valid = jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    if( ! valid )
+        return JS_FALSE;
+
+    cx = jsdthreadstate->context;
+    JS_ASSERT(cx);
+
+    exceptionState = JS_SaveExceptionState(cx);
+    jsd_StartingEvalUsingFilename(jsdc, filename);
+    retval = JS_EvaluateInStackFrame(cx, jsdframe->fp, bytes, length, 
+                                     filename, lineno, rval);
+    jsd_FinishedEvalUsingFilename(jsdc, filename);
+    JS_RestoreExceptionState(cx, exceptionState);
+
+    return retval;
+}
+
+JSString*
+jsd_ValToStringInStackFrame(JSDContext* jsdc, 
+                            JSDThreadState* jsdthreadstate,
+                            JSDStackFrameInfo* jsdframe,
+                            jsval val)
+{
+    JSBool valid;
+    JSString* retval;
+    JSExceptionState* exceptionState;
+    JSContext* cx;
+
+    JSD_LOCK_THREADSTATES(jsdc);
+    valid = jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+
+    if( ! valid )
+        return NULL;
+
+    cx = jsdthreadstate->context;
+    JS_ASSERT(cx);
+
+    exceptionState = JS_SaveExceptionState(cx);
+    retval = JS_ValueToString(cx, val);
+    JS_RestoreExceptionState(cx, exceptionState);
+
+    return retval;
+}
+
+JSBool
+jsd_IsValidThreadState(JSDContext*        jsdc, 
+                       JSDThreadState*    jsdthreadstate)
+{
+    JSDThreadState *cur;
+
+    JS_ASSERT( JSD_THREADSTATES_LOCKED(jsdc) );
+
+    for( cur = (JSDThreadState*)jsdc->threadsStates.next;
+         cur != (JSDThreadState*)&jsdc->threadsStates;
+         cur = (JSDThreadState*)cur->links.next ) 
+    {
+        if( cur == jsdthreadstate )
+            return JS_TRUE;
+    }
+    return JS_FALSE;
+}    
+
+JSBool
+jsd_IsValidFrameInThreadState(JSDContext*        jsdc, 
+                              JSDThreadState*    jsdthreadstate,
+                              JSDStackFrameInfo* jsdframe)
+{
+    JS_ASSERT(JSD_THREADSTATES_LOCKED(jsdc));
+
+    if( ! jsd_IsValidThreadState(jsdc, jsdthreadstate) )
+        return JS_FALSE;
+    if( jsdframe->jsdthreadstate != jsdthreadstate )
+        return JS_FALSE;
+
+    JSD_ASSERT_VALID_THREAD_STATE(jsdthreadstate);
+    JSD_ASSERT_VALID_STACK_FRAME(jsdframe);
+    
+    return JS_TRUE;
+}
+
+static JSContext*
+_getContextForThreadState(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
+{
+    JSBool valid;
+    JSD_LOCK_THREADSTATES(jsdc);
+    valid = jsd_IsValidThreadState(jsdc, jsdthreadstate);
+    JSD_UNLOCK_THREADSTATES(jsdc);
+    if( valid )
+        return jsdthreadstate->context;
+    return NULL;
+}        
+
+JSDValue*
+jsd_GetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
+{
+    JSContext* cx;
+    jsval val;
+
+    if(!(cx = _getContextForThreadState(jsdc, jsdthreadstate)))
+        return NULL;
+
+    if(JS_GetPendingException(cx, &val))
+        return jsd_NewValue(jsdc, val);
+    return NULL;
+}        
+
+JSBool
+jsd_SetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate, 
+                 JSDValue* jsdval)
+{
+    JSContext* cx;
+
+    if(!(cx = _getContextForThreadState(jsdc, jsdthreadstate)))
+        return JS_FALSE;
+
+    if(jsdval)
+        JS_SetPendingException(cx, JSD_GetValueWrappedJSVal(jsdc, jsdval));
+    else
+        JS_ClearPendingException(cx);
+    return JS_TRUE;
+}

mozilla/js/jsd/jsd_step.c

@@ -0,0 +1,116 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Stepping support
+ */
+
+#include "jsd.h"
+
+/*
+* #define JSD_TRACE 1
+*/
+
+#ifdef JSD_TRACE
+
+static char*
+_indentSpaces(int i)
+{
+#define MAX_INDENT 63
+    static char* p = NULL;
+    if(!p)
+    {
+        p = calloc(1, MAX_INDENT+1);
+        if(!p) return "";
+        memset(p, ' ', MAX_INDENT);
+    }
+    if(i > MAX_INDENT) return p;
+    return p + MAX_INDENT-i;
+}
+
+static void
+_interpreterTrace(JSDContext* jsdc, JSContext *cx, JSStackFrame *fp,
+                  JSBool before, JSBool *ok)
+{
+    JSDScript* jsdscript = NULL;
+    JSScript * script;
+    static indent = 0;
+    char* buf;
+    const char* funName = NULL;
+
+    script = JS_GetFrameScript(cx, fp);
+    if(script)
+    {
+        JSD_LOCK_SCRIPTS(jsdc);
+        jsdscript = jsd_FindJSDScript(jsdc, script);
+        JSD_UNLOCK_SCRIPTS(jsdc);
+        if(jsdscript)
+            funName = JSD_GetScriptFunctionName(jsdc, jsdscript);
+    }
+    if(!funName)
+        funName = "TOP_LEVEL";
+
+    if(before)
+    {
+        buf = JS_smprintf("%sentering %s %s this: %0x\n",
+                _indentSpaces(indent++),
+                funName,
+                JS_IsContructorFrame(cx, fp) ? "constructing":"",
+                (int)JS_GetFrameThis(cx, fp));
+    }
+    else
+    {
+        buf = JS_smprintf("%sleaving %s\n",
+                _indentSpaces(--indent),
+                funName);
+    }
+    JS_ASSERT(indent >= 0);
+
+    if(!buf)
+        return;
+
+    printf(buf);
+    free(buf);
+}
+#endif
+
+void * JS_DLL_CALLBACK
+jsd_InterpreterHook(JSContext *cx, JSStackFrame *fp, JSBool before,
+                    JSBool *ok, void *closure)
+{
+    JSDContext*     jsdc = (JSDContext*) closure;
+
+    if( ! jsdc || ! jsdc->inited )
+        return NULL;
+
+    if(before && JS_IsContructorFrame(cx, fp))
+        jsd_Constructing(jsdc, cx, JS_GetFrameThis(cx, fp), fp);
+
+#ifdef JSD_TRACE
+    _interpreterTrace(jsdc, cx, fp, before, ok);
+    return closure;
+#else
+    return NULL;
+#endif
+/*
+*   use this before calling any hook...
+*     if( JSD_IS_DANGEROUS_THREAD(jsdc) )
+*         return NULL;
+*/
+
+}

mozilla/js/jsd/jsd_text.c

@@ -0,0 +1,547 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Source Text functions
+ */
+
+#include "jsd.h"
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_SOURCE_TEXT(JSDSourceText* jsdsrc)
+{
+    JS_ASSERT(jsdsrc);
+    JS_ASSERT(jsdsrc->url);
+}
+#endif
+
+/***************************************************************************/
+/* XXX add notification */
+
+static void
+_clearText(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    if( jsdsrc->text )
+        free(jsdsrc->text);
+    jsdsrc->text        = NULL;
+    jsdsrc->textLength  = 0;
+    jsdsrc->textSpace   = 0;
+    jsdsrc->status      = JSD_SOURCE_CLEARED;
+    jsdsrc->dirty       = JS_TRUE;
+    jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
+    jsdsrc->doingEval   = JS_FALSE;
+}    
+
+static JSBool
+_appendText(JSDContext* jsdc, JSDSourceText* jsdsrc, 
+            const char* text, size_t length)
+{
+#define MEMBUF_GROW 1000
+
+    uintN neededSize = jsdsrc->textLength + length;
+
+    if( neededSize > jsdsrc->textSpace )
+    {
+        char* newBuf;
+        uintN iNewSize;
+
+        /* if this is the first alloc, the req might be all that's needed*/
+        if( ! jsdsrc->textSpace )
+            iNewSize = length;
+        else
+            iNewSize = (neededSize * 5 / 4) + MEMBUF_GROW;
+
+        newBuf = (char*) realloc(jsdsrc->text, iNewSize);
+        if( ! newBuf )
+        {
+            /* try again with the minimal size really asked for */
+            iNewSize = neededSize;
+            newBuf = (char*) realloc(jsdsrc->text, iNewSize);
+            if( ! newBuf )
+            {
+                /* out of memory */
+                _clearText( jsdc, jsdsrc );
+                jsdsrc->status = JSD_SOURCE_FAILED;
+                return JS_FALSE;
+            }
+        }
+
+        jsdsrc->text = newBuf;
+        jsdsrc->textSpace = iNewSize;
+    }
+
+    memcpy(jsdsrc->text + jsdsrc->textLength, text, length);
+    jsdsrc->textLength += length;
+    return JS_TRUE;
+}
+
+static JSDSourceText*
+_newSource(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText* jsdsrc = (JSDSourceText*)calloc(1,sizeof(JSDSourceText));
+    if( ! jsdsrc )
+        return NULL;
+    
+    jsdsrc->url        = (char*) url; /* already a copy */
+    jsdsrc->status     = JSD_SOURCE_INITED;
+    jsdsrc->dirty      = JS_TRUE;
+    jsdsrc->alterCount = jsdc->sourceAlterCount++ ;
+            
+    return jsdsrc;
+}
+
+static void
+_destroySource(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    JS_ASSERT(NULL == jsdsrc->text);  /* must _clearText() first */
+    free(jsdsrc->url);
+    free(jsdsrc);
+}
+
+static void
+_removeSource(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    JS_REMOVE_LINK(&jsdsrc->links);
+    _clearText(jsdc, jsdsrc);
+    _destroySource(jsdc, jsdsrc);
+}
+
+static JSDSourceText*
+_addSource(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText* jsdsrc = _newSource(jsdc, url);
+    if( ! jsdsrc )
+        return NULL;
+    JS_INSERT_LINK(&jsdsrc->links, &jsdc->sources);
+    return jsdsrc;
+}
+
+static void
+_moveSourceToFront(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    JS_REMOVE_LINK(&jsdsrc->links);
+    JS_INSERT_LINK(&jsdsrc->links, &jsdc->sources);
+}
+
+static void
+_moveSourceToRemovedList(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    _clearText(jsdc, jsdsrc);
+    JS_REMOVE_LINK(&jsdsrc->links);
+    JS_INSERT_LINK(&jsdsrc->links, &jsdc->removedSources);
+}
+
+static void
+_removeSourceFromRemovedList( JSDContext* jsdc, JSDSourceText* jsdsrc )
+{
+    JS_REMOVE_LINK(&jsdsrc->links);
+    _destroySource( jsdc, jsdsrc );
+}
+
+static JSBool
+_isSourceInSourceList(JSDContext* jsdc, JSDSourceText* jsdsrcToFind)
+{
+    JSDSourceText *jsdsrc;
+
+    for( jsdsrc = (JSDSourceText*)jsdc->sources.next;
+         jsdsrc != (JSDSourceText*)&jsdc->sources;
+         jsdsrc = (JSDSourceText*)jsdsrc->links.next ) 
+    {
+        if( jsdsrc == jsdsrcToFind )
+            return JS_TRUE;
+    }
+    return JS_FALSE;
+}
+
+/*  compare strings in a case insensitive manner with a length limit
+*/
+
+static int 
+strncasecomp (const char* one, const char * two, int n)
+{
+    const char *pA;
+    const char *pB;
+    
+    for(pA=one, pB=two;; pA++, pB++) 
+    {
+        int tmp;
+        if (pA == one+n) 
+            return 0;   
+        if (!(*pA && *pB)) 
+            return *pA - *pB;
+        tmp = tolower(*pA) - tolower(*pB);
+        if (tmp) 
+            return tmp;
+    }
+}
+
+static char file_url_prefix[]    = "file:";
+#define FILE_URL_PREFIX_LEN     (sizeof file_url_prefix - 1)
+
+const char*
+jsd_BuildNormalizedURL( const char* url_string )
+{
+    char *new_url_string;
+
+    if( ! url_string )
+        return NULL;
+
+    if (!strncasecomp(url_string, file_url_prefix, FILE_URL_PREFIX_LEN) &&
+        url_string[FILE_URL_PREFIX_LEN + 0] == '/' &&
+        url_string[FILE_URL_PREFIX_LEN + 1] == '/') {
+        new_url_string = JS_smprintf("%s%s",
+                                     file_url_prefix,
+                                     url_string + FILE_URL_PREFIX_LEN + 2);
+    } else {
+        new_url_string = strdup(url_string);
+    }
+    return new_url_string;
+}
+
+/***************************************************************************/
+
+void
+jsd_DestroyAllSources( JSDContext* jsdc )
+{
+    JSDSourceText *jsdsrc;
+    JSDSourceText *next;
+
+    for( jsdsrc = (JSDSourceText*)jsdc->sources.next;
+         jsdsrc != (JSDSourceText*)&jsdc->sources;
+         jsdsrc = next ) 
+    {
+        next = (JSDSourceText*)jsdsrc->links.next;
+        _removeSource( jsdc, jsdsrc );
+    }
+
+    for( jsdsrc = (JSDSourceText*)jsdc->removedSources.next;
+         jsdsrc != (JSDSourceText*)&jsdc->removedSources;
+         jsdsrc = next ) 
+    {
+        next = (JSDSourceText*)jsdsrc->links.next;
+        _removeSourceFromRemovedList( jsdc, jsdsrc );
+    }
+
+}
+
+JSDSourceText*
+jsd_IterateSources(JSDContext* jsdc, JSDSourceText **iterp)
+{
+    JSDSourceText *jsdsrc = *iterp;
+    
+    if( !jsdsrc )
+        jsdsrc = (JSDSourceText *)jsdc->sources.next;
+    if( jsdsrc == (JSDSourceText *)&jsdc->sources )
+        return NULL;
+    *iterp = (JSDSourceText *)jsdsrc->links.next;
+    return jsdsrc;
+}
+
+JSDSourceText*
+jsd_FindSourceForURL(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText *jsdsrc;
+
+    for( jsdsrc = (JSDSourceText *)jsdc->sources.next;
+         jsdsrc != (JSDSourceText *)&jsdc->sources;
+         jsdsrc = (JSDSourceText *)jsdsrc->links.next )
+    {
+        if( 0 == strcmp(jsdsrc->url, url) )
+            return jsdsrc;
+    }
+    return NULL;
+}
+
+const char*
+jsd_GetSourceURL(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    return jsdsrc->url;
+}
+
+JSBool
+jsd_GetSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc,
+                  const char** ppBuf, intN* pLen )
+{
+    *ppBuf = jsdsrc->text;
+    *pLen  = jsdsrc->textLength;
+    return JS_TRUE;
+}
+
+void
+jsd_ClearSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    if( JSD_SOURCE_INITED  != jsdsrc->status &&
+        JSD_SOURCE_PARTIAL != jsdsrc->status )
+    {
+        _clearText(jsdc, jsdsrc);
+    }
+}
+
+JSDSourceStatus
+jsd_GetSourceStatus(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    return jsdsrc->status;
+}
+
+JSBool
+jsd_IsSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    return jsdsrc->dirty;
+}
+
+void
+jsd_SetSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc, JSBool dirty)
+{
+    jsdsrc->dirty = dirty;
+}
+
+uintN
+jsd_GetSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    return jsdsrc->alterCount;
+}
+
+uintN
+jsd_IncrementSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc)
+{
+    return jsdsrc->alterCount = jsdc->sourceAlterCount++;
+}
+
+/***************************************************************************/
+
+#if defined(DEBUG) && 0
+void DEBUG_ITERATE_SOURCES( JSDContext* jsdc )
+{
+    JSDSourceText* iterp = NULL;
+    JSDSourceText* jsdsrc = NULL;
+    int dummy;
+    
+    while( NULL != (jsdsrc = jsd_IterateSources(jsdc, &iterp)) )
+    {
+        const char*     url;
+        const char*     text;
+        int             len;
+        JSBool          dirty;
+        JSDStreamStatus status;
+        JSBool          gotSrc;
+
+        url     = JSD_GetSourceURL(jsdc, jsdsrc);
+        dirty   = JSD_IsSourceDirty(jsdc, jsdsrc);
+        status  = JSD_GetSourceStatus(jsdc, jsdsrc);
+        gotSrc  = JSD_GetSourceText(jsdc, jsdsrc, &text, &len );
+        
+        dummy = 0;  /* gives us a line to set breakpoint... */
+    }
+}
+#else
+#define DEBUG_ITERATE_SOURCES(x) ((void)x)
+#endif
+
+/***************************************************************************/
+
+JSDSourceText*
+jsd_NewSourceText(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText* jsdsrc;
+    const char* new_url_string;
+
+    JSD_LOCK_SOURCE_TEXT(jsdc);
+
+#ifdef LIVEWIRE
+    new_url_string = url; /* we take ownership of alloc'd string */
+#else
+    new_url_string = jsd_BuildNormalizedURL(url);
+#endif
+    if( ! new_url_string )
+        return NULL;
+
+    jsdsrc = jsd_FindSourceForURL(jsdc, new_url_string);
+
+    if( jsdsrc )
+    {
+        if( jsdsrc->doingEval )
+        {
+#ifdef LIVEWIRE
+            free((char*)new_url_string);
+#endif
+            JSD_UNLOCK_SOURCE_TEXT(jsdc);
+            return NULL;
+        }
+        else    
+            _moveSourceToRemovedList(jsdc, jsdsrc);
+    }
+
+    jsdsrc = _addSource( jsdc, new_url_string );
+
+    JSD_UNLOCK_SOURCE_TEXT(jsdc);
+
+    return jsdsrc;
+}
+
+JSDSourceText*
+jsd_AppendSourceText(JSDContext* jsdc, 
+                     JSDSourceText* jsdsrc,
+                     const char* text,       /* *not* zero terminated */
+                     size_t length,
+                     JSDSourceStatus status)
+{
+    JSD_LOCK_SOURCE_TEXT(jsdc);
+
+    if( jsdsrc->doingEval )
+    {
+        JSD_UNLOCK_SOURCE_TEXT(jsdc);
+        return NULL;
+    }
+
+    if( ! _isSourceInSourceList( jsdc, jsdsrc ) )
+    {
+        _removeSourceFromRemovedList( jsdc, jsdsrc );
+        JSD_UNLOCK_SOURCE_TEXT(jsdc);
+        return NULL;
+    }
+
+    if( text && length && ! _appendText( jsdc, jsdsrc, text, length ) )
+    {
+        jsdsrc->dirty  = JS_TRUE;
+        jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
+        jsdsrc->status = JSD_SOURCE_FAILED;
+        _moveSourceToRemovedList(jsdc, jsdsrc);
+        JSD_UNLOCK_SOURCE_TEXT(jsdc);
+        return NULL;    
+    }
+
+    jsdsrc->dirty  = JS_TRUE;
+    jsdsrc->alterCount  = jsdc->sourceAlterCount++ ;
+    jsdsrc->status = status;
+    DEBUG_ITERATE_SOURCES(jsdc);
+    JSD_UNLOCK_SOURCE_TEXT(jsdc);
+    return jsdsrc;
+}
+
+JSDSourceText*
+jsd_AppendUCSourceText(JSDContext* jsdc,
+                       JSDSourceText* jsdsrc,
+                       const jschar* text,       /* *not* zero terminated */
+                       size_t length,
+                       JSDSourceStatus status)
+{
+#define UNICODE_TRUNCATE_BUF_SIZE 1024
+    static char* buf = NULL;
+    int remaining = length;
+
+    if(!text || !length)
+        return jsd_AppendSourceText(jsdc, jsdsrc, NULL, 0, status);
+
+    JSD_LOCK_SOURCE_TEXT(jsdc);
+    if(!buf)
+    {
+        buf = malloc(UNICODE_TRUNCATE_BUF_SIZE);
+        if(!buf)
+        {
+            JSD_UNLOCK_SOURCE_TEXT(jsdc);
+            return NULL;
+        }
+    }
+    while(remaining && jsdsrc) {
+        int bytes = JS_MIN(remaining, UNICODE_TRUNCATE_BUF_SIZE);
+        int i;
+        for(i = 0; i < bytes; i++)
+            buf[i] = (const char) *(text++);
+        jsdsrc = jsd_AppendSourceText(jsdc,jsdsrc,
+                                      buf, bytes,
+                                      JSD_SOURCE_PARTIAL);
+        remaining -= bytes;
+    }
+    if(jsdsrc && status != JSD_SOURCE_PARTIAL)
+        jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc, NULL, 0, status);
+
+    JSD_UNLOCK_SOURCE_TEXT(jsdc);
+    return jsdsrc;
+}
+
+/* convienence function for adding complete source of url in one call */
+JSBool
+jsd_AddFullSourceText(JSDContext* jsdc, 
+                      const char* text,       /* *not* zero terminated */
+                      size_t      length,
+                      const char* url)
+{
+    JSDSourceText* jsdsrc;
+
+    JSD_LOCK_SOURCE_TEXT(jsdc);
+
+    jsdsrc = jsd_NewSourceText(jsdc, url);
+    if( jsdsrc )
+        jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
+                                      text, length, JSD_SOURCE_PARTIAL );
+    if( jsdsrc )
+        jsdsrc = jsd_AppendSourceText(jsdc, jsdsrc,
+                                      NULL, 0, JSD_SOURCE_COMPLETED );
+
+    JSD_UNLOCK_SOURCE_TEXT(jsdc);
+
+    return jsdsrc ? JS_TRUE : JS_FALSE;
+}
+
+/***************************************************************************/
+
+void
+jsd_StartingEvalUsingFilename(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText* jsdsrc;
+
+    /* NOTE: We leave it locked! */
+    JSD_LOCK_SOURCE_TEXT(jsdc); 
+
+    jsdsrc = jsd_FindSourceForURL(jsdc, url);
+    if(jsdsrc)
+    {
+#if 0
+#ifndef JSD_LOWLEVEL_SOURCE
+        JS_ASSERT(! jsdsrc->doingEval);
+#endif
+#endif
+        jsdsrc->doingEval = JS_TRUE;
+    }
+}    
+
+void
+jsd_FinishedEvalUsingFilename(JSDContext* jsdc, const char* url)
+{
+    JSDSourceText* jsdsrc;
+
+    /* NOTE: We ASSUME it is locked! */
+
+    jsdsrc = jsd_FindSourceForURL(jsdc, url);
+    if(jsdsrc)
+    {
+#if 0
+#ifndef JSD_LOWLEVEL_SOURCE
+        /*
+        * when using this low level source addition, this jsdsrc might 
+        * not have existed before the eval, but does exist now (without
+        * this flag set!)
+        */
+        JS_ASSERT(jsdsrc->doingEval);
+#endif
+#endif
+        jsdsrc->doingEval = JS_FALSE;
+    }
+
+    JSD_UNLOCK_SOURCE_TEXT(jsdc);
+}    

mozilla/js/jsd/jsd_val.c

@@ -0,0 +1,601 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * JavaScript Debugging support - Value and Property support
+ */
+
+#include "jsd.h"
+
+#ifdef DEBUG
+void JSD_ASSERT_VALID_VALUE(JSDValue* jsdval)
+{
+    JS_ASSERT(jsdval);
+    JS_ASSERT(jsdval->nref > 0);
+    if(!JS_CLIST_IS_EMPTY(&jsdval->props))
+    {
+        JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS));
+        JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
+    }
+
+    if(jsdval->proto)
+    {
+        JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO));
+        JS_ASSERT(jsdval->proto->nref > 0);
+    }
+    if(jsdval->parent)
+    {
+        JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT));
+        JS_ASSERT(jsdval->parent->nref > 0);
+    }
+    if(jsdval->ctor)
+    {
+        JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR));
+        JS_ASSERT(jsdval->ctor->nref > 0);
+    }
+}
+
+void JSD_ASSERT_VALID_PROPERTY(JSDProperty* jsdprop)
+{
+    JS_ASSERT(jsdprop);
+    JS_ASSERT(jsdprop->name);
+    JS_ASSERT(jsdprop->name->nref > 0);
+    JS_ASSERT(jsdprop->val);
+    JS_ASSERT(jsdprop->val->nref > 0);
+    if(jsdprop->alias)
+        JS_ASSERT(jsdprop->alias->nref > 0);
+}
+#endif
+
+
+JSBool
+jsd_IsValueObject(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_OBJECT(jsdval->val);
+}
+
+JSBool
+jsd_IsValueNumber(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_NUMBER(jsdval->val);
+}
+
+JSBool
+jsd_IsValueInt(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_INT(jsdval->val);
+}
+
+JSBool
+jsd_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_DOUBLE(jsdval->val);
+}
+
+JSBool
+jsd_IsValueString(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_STRING(jsdval->val);
+}
+
+JSBool
+jsd_IsValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_BOOLEAN(jsdval->val);
+}
+
+JSBool
+jsd_IsValueNull(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_NULL(jsdval->val);
+}
+
+JSBool
+jsd_IsValueVoid(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_VOID(jsdval->val);
+}
+
+JSBool
+jsd_IsValuePrimitive(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_PRIMITIVE(jsdval->val);
+}
+
+JSBool
+jsd_IsValueFunction(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return JSVAL_IS_FUNCTION(jsdc->dumbContext, jsdval->val);
+}
+
+JSBool
+jsd_IsValueNative(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSContext* cx = jsdc->dumbContext;
+    jsval val = jsdval->val;
+    JSFunction* fun;
+    JSExceptionState* exceptionState;
+
+    if(!JSVAL_IS_OBJECT(val))
+        return JS_FALSE;
+
+    if(JSVAL_IS_FUNCTION(cx, val))
+    {
+        exceptionState = JS_SaveExceptionState(cx);
+        fun = JS_ValueToFunction(cx, val);
+        JS_RestoreExceptionState(cx, exceptionState);
+        if(!fun)
+        {
+            JS_ASSERT(0);
+            return JS_FALSE;
+        }
+        return JS_GetFunctionScript(cx, fun) ? JS_FALSE : JS_TRUE;
+    }
+    return JSVAL_TO_OBJECT(val) && OBJ_IS_NATIVE(JSVAL_TO_OBJECT(val));
+}
+
+/***************************************************************************/
+
+JSBool
+jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
+{
+    jsval val = jsdval->val;
+    if(!JSVAL_IS_BOOLEAN(val))
+        return JS_FALSE;
+    return JSVAL_TO_BOOLEAN(val);
+}
+
+int32
+jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval)
+{
+    jsval val = jsdval->val;
+    if(!JSVAL_IS_INT(val))
+        return 0;
+    return JSVAL_TO_INT(val);
+}
+
+jsdouble*
+jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval)
+{
+    jsval val = jsdval->val;
+    if(!JSVAL_IS_DOUBLE(val))
+        return 0;
+    return JSVAL_TO_DOUBLE(val);
+}
+
+JSString*
+jsd_GetValueString(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSContext* cx = jsdc->dumbContext;
+    JSExceptionState* exceptionState;
+
+    if(!jsdval->string)
+    {
+        /* if the jsval is a string, then we don't need to double root it */
+        if(JSVAL_IS_STRING(jsdval->val))
+            jsdval->string = JSVAL_TO_STRING(jsdval->val);
+        else
+        {
+            exceptionState = JS_SaveExceptionState(cx);
+            jsdval->string = JS_ValueToString(cx, jsdval->val);
+            JS_RestoreExceptionState(cx, exceptionState);
+            if(jsdval->string)
+            {
+                if(!JS_AddRoot(cx, &jsdval->string))
+                jsdval->string = NULL;
+            }
+        }
+    }
+    return jsdval->string;
+}
+
+const char*
+jsd_GetValueFunctionName(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSContext* cx = jsdc->dumbContext;
+    jsval val = jsdval->val;
+    JSFunction* fun;
+    JSExceptionState* exceptionState;
+
+    if(!jsdval->funName && JSVAL_IS_FUNCTION(cx, val))
+    {
+        exceptionState = JS_SaveExceptionState(cx);
+        fun = JS_ValueToFunction(cx, val);
+        JS_RestoreExceptionState(cx, exceptionState);
+        if(!fun)
+            return NULL;
+        jsdval->funName = JS_GetFunctionName(fun);
+    }
+    return jsdval->funName;
+}
+
+/***************************************************************************/
+
+JSDValue*
+jsd_NewValue(JSDContext* jsdc, jsval val)
+{
+    JSDValue* jsdval;
+
+    if(!(jsdval = (JSDValue*) calloc(1, sizeof(JSDValue))))
+        return NULL;
+
+    if(JSVAL_IS_GCTHING(val))
+    {
+        if(!JS_AddRoot(jsdc->dumbContext, &jsdval->val))
+        {
+            free(jsdval);
+            return NULL;
+        }
+    }
+    jsdval->val  = val;
+    jsdval->nref = 1;
+    JS_INIT_CLIST(&jsdval->props);
+
+    return jsdval;
+}
+
+void
+jsd_DropValue(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JS_ASSERT(jsdval->nref > 0);
+    if(0 == --jsdval->nref)
+    {
+        jsd_RefreshValue(jsdc, jsdval);
+        if(JSVAL_IS_GCTHING(jsdval->val))
+            JS_RemoveRoot(jsdc->dumbContext, &jsdval->val);
+        free(jsdval);
+    }
+}
+
+jsval
+jsd_GetValueWrappedJSVal(JSDContext* jsdc, JSDValue* jsdval)
+{
+    return jsdval->val;
+}
+
+static JSDProperty* _newProperty(JSDContext* jsdc, JSPropertyDesc* pd,
+                                 uintN additionalFlags)
+{
+    JSDProperty* jsdprop;
+
+    if(!(jsdprop = (JSDProperty*) calloc(1, sizeof(JSDProperty))))
+        return NULL;
+
+    JS_INIT_CLIST(&jsdprop->links);
+    jsdprop->nref = 1;
+    jsdprop->flags = pd->flags | additionalFlags;
+    jsdprop->slot = pd->slot;
+
+    if(!(jsdprop->name = jsd_NewValue(jsdc, pd->id)))
+        goto new_prop_fail;
+
+    if(!(jsdprop->val = jsd_NewValue(jsdc, pd->value)))
+        goto new_prop_fail;
+
+    if((jsdprop->flags & JSDPD_ALIAS) &&
+       !(jsdprop->alias = jsd_NewValue(jsdc, pd->alias)))
+        goto new_prop_fail;
+
+    return jsdprop;
+new_prop_fail:
+    jsd_DropProperty(jsdc, jsdprop);
+    return NULL;
+}
+
+static void _freeProps(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSDProperty* jsdprop;
+
+    while(jsdprop = (JSDProperty*)jsdval->props.next,
+          jsdprop != (JSDProperty*)&jsdval->props)
+    {
+        JS_REMOVE_AND_INIT_LINK(&jsdprop->links);
+        jsd_DropProperty(jsdc, jsdprop);
+    }
+    JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
+    CLEAR_BIT_FLAG(jsdval->flags, GOT_PROPS);
+}
+
+static JSBool _buildProps(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSContext* cx = jsdc->dumbContext;
+    JSPropertyDescArray pda;
+    uintN i;
+
+    JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
+    JS_ASSERT(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)));
+    JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
+
+    if(!JSVAL_IS_OBJECT(jsdval->val) || JSVAL_IS_NULL(jsdval->val))
+        return JS_FALSE;
+
+    if(!JS_GetPropertyDescArray(cx, JSVAL_TO_OBJECT(jsdval->val), &pda))
+        return JS_FALSE;
+
+    for(i = 0; i < pda.length; i++)
+    {
+        JSDProperty* prop = _newProperty(jsdc, &pda.array[i], 0);
+        if(!prop)
+        {
+            _freeProps(jsdc, jsdval);
+            break;
+        }
+        JS_APPEND_LINK(&prop->links, &jsdval->props);
+    }
+    JS_PutPropertyDescArray(cx, &pda);
+    SET_BIT_FLAG(jsdval->flags, GOT_PROPS);
+    return !JS_CLIST_IS_EMPTY(&jsdval->props);
+}
+
+#undef  DROP_CLEAR_VALUE
+#define DROP_CLEAR_VALUE(jsdc, x) if(x){jsd_DropValue(jsdc,x); x = NULL;}
+
+void
+jsd_RefreshValue(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSContext* cx = jsdc->dumbContext;
+
+    if(jsdval->string)
+    {
+        /* if the jsval is a string, then we didn't need to root the string */
+        if(!JSVAL_IS_STRING(jsdval->val))
+            JS_RemoveRoot(cx, &jsdval->string);
+        jsdval->string = NULL;
+    }
+
+    jsdval->funName = NULL;
+    jsdval->className = NULL;
+    DROP_CLEAR_VALUE(jsdc, jsdval->proto);
+    DROP_CLEAR_VALUE(jsdc, jsdval->parent);
+    DROP_CLEAR_VALUE(jsdc, jsdval->ctor);
+    _freeProps(jsdc, jsdval);
+    jsdval->flags = 0;
+}
+
+/***************************************************************************/
+
+uintN
+jsd_GetCountOfProperties(JSDContext* jsdc, JSDValue* jsdval)
+{
+    JSDProperty* jsdprop;
+    uintN count = 0;
+
+    if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
+        if(!_buildProps(jsdc, jsdval))
+            return 0;
+
+    for(jsdprop = (JSDProperty*)jsdval->props.next;
+        jsdprop != (JSDProperty*)&jsdval->props;
+        jsdprop = (JSDProperty*)jsdprop->links.next)
+    {
+        count++;
+    }
+    return count;
+}
+
+JSDProperty*
+jsd_IterateProperties(JSDContext* jsdc, JSDValue* jsdval, JSDProperty **iterp)
+{
+    JSDProperty* jsdprop = *iterp;
+    if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
+    {
+        JS_ASSERT(!jsdprop);
+        if(!_buildProps(jsdc, jsdval))
+            return NULL;
+    }
+
+    if(!jsdprop)
+        jsdprop = (JSDProperty*)jsdval->props.next;
+    if(jsdprop == (JSDProperty*)&jsdval->props)
+        return NULL;
+    *iterp = (JSDProperty*)jsdprop->links.next;
+
+    JS_ASSERT(jsdprop);
+    jsdprop->nref++;
+    return jsdprop;
+}
+
+JSDProperty*
+jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name)
+{
+    JSContext* cx = jsdc->dumbContext;
+    JSDProperty* jsdprop;
+    JSDProperty* iter = NULL;
+    JSObject* obj;
+    uintN  attrs = 0;
+    JSBool found;
+    JSPropertyDesc pd;
+    const jschar * nameChars;
+    size_t nameLen;
+    jsval val;
+
+    if(!jsd_IsValueObject(jsdc, jsdval))
+        return NULL;
+
+    /* If we already have the prop, then return it */
+    while(NULL != (jsdprop = jsd_IterateProperties(jsdc, jsdval, &iter)))
+    {
+        JSString* propName = jsd_GetValueString(jsdc, jsdprop->name);
+        if(propName && !JS_CompareStrings(propName, name))
+            return jsdprop;
+        JSD_DropProperty(jsdc, jsdprop);
+    }
+    /* Not found in property list, look it up explicitly */
+
+    if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
+        return NULL;
+
+    nameChars = JS_GetStringChars(name);
+    nameLen   = JS_GetStringLength(name);
+
+    /* It's OK if this fails - we just don't get attribs */
+    JS_GetUCPropertyAttributes(cx, obj, nameChars, nameLen, &attrs, &found);
+
+    if(!JS_GetUCProperty(cx, obj, nameChars, nameLen, &val))
+        return NULL;
+
+    /* XXX screwy! no good way to detect that property does not exist at all */
+    if(!found && JSVAL_IS_VOID(val))
+        return NULL;
+
+    pd.id = STRING_TO_JSVAL(name);
+    pd.value = val;
+    pd.alias = pd.slot = pd.spare = 0;
+    pd.flags = 0
+        | (attrs & JSPROP_ENUMERATE) ? JSPD_ENUMERATE : 0
+        | (attrs & JSPROP_READONLY)  ? JSPD_READONLY  : 0
+        | (attrs & JSPROP_PERMANENT) ? JSPD_PERMANENT : 0;
+
+    return _newProperty(jsdc, &pd, JSDPD_HINTED);
+}
+
+
+JSDValue*
+jsd_GetValuePrototype(JSDContext* jsdc, JSDValue* jsdval)
+{
+    if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO)))
+    {
+        JSObject* obj;
+        JSObject* proto;
+        JS_ASSERT(!jsdval->proto);
+        SET_BIT_FLAG(jsdval->flags, GOT_PROTO);
+        if(!JSVAL_IS_OBJECT(jsdval->val))
+            return NULL;
+        if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
+            return NULL;
+        if(!(proto = OBJ_GET_PROTO(jsdc->dumbContext,obj)))
+            return NULL;
+        jsdval->proto = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(proto));
+    }
+    if(jsdval->proto)
+        jsdval->proto->nref++;
+    return jsdval->proto;
+}
+
+JSDValue*
+jsd_GetValueParent(JSDContext* jsdc, JSDValue* jsdval)
+{
+    if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT)))
+    {
+        JSObject* obj;
+        JSObject* parent;
+        JS_ASSERT(!jsdval->parent);
+        SET_BIT_FLAG(jsdval->flags, GOT_PARENT);
+        if(!JSVAL_IS_OBJECT(jsdval->val))
+            return NULL;
+        if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
+            return NULL;
+        if(!(parent = OBJ_GET_PARENT(jsdc->dumbContext,obj)))
+            return NULL;
+        jsdval->parent = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(parent));
+    }
+    if(jsdval->parent)
+        jsdval->parent->nref++;
+    return jsdval->parent;
+}
+
+JSDValue*
+jsd_GetValueConstructor(JSDContext* jsdc, JSDValue* jsdval)
+{
+    if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR)))
+    {
+        JSObject* obj;
+        JSObject* proto;
+        JSObject* ctor;
+        JS_ASSERT(!jsdval->ctor);
+        SET_BIT_FLAG(jsdval->flags, GOT_CTOR);
+        if(!JSVAL_IS_OBJECT(jsdval->val))
+            return NULL;
+        if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
+            return NULL;
+        if(!(proto = OBJ_GET_PROTO(jsdc->dumbContext,obj)))
+            return NULL;
+        if(!(ctor = JS_GetConstructor(jsdc->dumbContext,proto)))
+            return NULL;
+        jsdval->ctor = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(ctor));
+    }
+    if(jsdval->ctor)
+        jsdval->ctor->nref++;
+    return jsdval->ctor;
+}
+
+const char*
+jsd_GetValueClassName(JSDContext* jsdc, JSDValue* jsdval)
+{
+    jsval val = jsdval->val;
+    if(!jsdval->className && JSVAL_IS_OBJECT(val))
+    {
+        JSObject* obj;
+        if(!(obj = JSVAL_TO_OBJECT(val)))
+            return NULL;
+        if(OBJ_GET_CLASS(jsdc->dumbContext, obj))
+            jsdval->className = OBJ_GET_CLASS(jsdc->dumbContext, obj)->name;
+    }
+    return jsdval->className;
+}
+
+/***************************************************************************/
+/***************************************************************************/
+
+JSDValue*
+jsd_GetPropertyName(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    jsdprop->name->nref++;
+    return jsdprop->name;
+}
+
+JSDValue*
+jsd_GetPropertyValue(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    jsdprop->val->nref++;
+    return jsdprop->val;
+}
+
+JSDValue*
+jsd_GetPropertyAlias(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    if(jsdprop->alias)
+        jsdprop->alias->nref++;
+    return jsdprop->alias;
+}
+
+JSDPropertyFlags
+jsd_GetPropertyFlags(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    return jsdprop->flags;
+}
+
+uintN
+jsd_GetPropertyVarArgSlot(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    return jsdprop->slot;
+}
+
+void
+jsd_DropProperty(JSDContext* jsdc, JSDProperty* jsdprop)
+{
+    JS_ASSERT(jsdprop->nref > 0);
+    if(0 == --jsdprop->nref)
+    {
+        JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdprop->links));
+        DROP_CLEAR_VALUE(jsdc, jsdprop->val);
+        DROP_CLEAR_VALUE(jsdc, jsdprop->name);
+        DROP_CLEAR_VALUE(jsdc, jsdprop->alias);
+        free(jsdprop);
+    }
+}

mozilla/js/jsd/jsdb/README

@@ -0,0 +1,12 @@
+/* jband - 10/26/98 -  */
+
+js/jsd/jsdb is a console debugger using only native code. It is experimental.
+The only makefile supplied is for Win32.
+
+jsdb.mak will build a debugger enabled js/src/js.c shell. The debugger is
+implemented by reflecting the JSD api into JavaScript. The actual debugger 
+logic is fully implemented in debugger.js. The debugger can debug itself. It
+can also be modified and reloaded at runtime.
+
+The JavaScript keyword 'debugger' is used to break into the debugger. A 'help()'
+command is supplied to show available commands when exectution is stopped.

mozilla/js/jsd/jsdb/f.js

@@ -0,0 +1,46 @@
+
+/**
+* for(var p in Script.scripts) {
+*
+*     var script = Script.scripts[p];
+*     var handle = script.handle;
+*     var base   = script.base;
+*     var limit  = base + script.extent;
+*
+*     print(script+"\n");
+*
+*     for(var i = base; i < limit; i++) {
+*         var pc = jsd.GetClosestPC(handle,i)
+*         var hascode = String(pc).length && i == jsd.GetClosestLine(handle,pc);
+*         print("line "+i+" "+ (hascode ? "has code" : "has NO code"));
+*     }
+*     print("...............................\n");
+* }
+*/
+
+function rlocals()
+{
+    var retval = "";
+    var name = "___UNIQUE_NAME__";
+    var fun = ""+
+        "var text = \\\"\\\";"+
+        "for(var p in ob)"+
+        "{"+
+        "    if(text != \\\"\\\")"+
+        "       text += \\\",\\\";"+
+        "    text += p;"+
+        "}"+
+        "return text;";
+
+    reval(name+" = new Function(\"ob\",\""+fun+"\")");
+//    show(name);
+    retval = _reval([name+"("+"arguments.callee"+")"]);
+    reval("delete "+name);
+
+    return retval;
+}
+
+function e(a)
+{
+    return eval(a);
+}

mozilla/js/jsd/jsdb/jsdb.c

@@ -0,0 +1,449 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+* JSDB public and callback functions
+*/
+
+#include "jsdbpriv.h"
+
+
+/***************************************************************************/
+
+JS_STATIC_DLL_CALLBACK(void)
+_ErrorReporter(JSContext *cx, const char *message, JSErrorReport *report)
+{
+    int i, j, k, n;
+
+    fputs("jsdb: ", stderr);
+    if (!report) {
+        fprintf(stderr, "%s\n", message);
+        return;
+    }
+
+    if (report->filename)
+        fprintf(stderr, "%s, ", report->filename);
+    if (report->lineno)
+        fprintf(stderr, "line %u: ", report->lineno);
+    fputs(message, stderr);
+    if (!report->linebuf) {
+        putc('\n', stderr);
+        return;
+    }
+
+    fprintf(stderr, ":\n%s\n", report->linebuf);
+    n = report->tokenptr - report->linebuf;
+    for (i = j = 0; i < n; i++) {
+        if (report->linebuf[i] == '\t') {
+            for (k = (j + 8) & ~7; j < k; j++)
+                putc('.', stderr);
+            continue;
+        }
+        putc('.', stderr);
+        j++;
+    }
+    fputs("^\n", stderr);
+}
+
+JS_STATIC_DLL_CALLBACK(void)
+jsdb_ScriptHookProc(JSDContext* jsdc,
+                    JSDScript*  jsdscript,
+                    JSBool      creating,
+                    void*       callerdata)
+{
+    JSDB_Data* data = (JSDB_Data*) callerdata;
+    JSFunction* fun;
+
+    if(data->jsScriptHook &&
+       NULL != (fun = JS_ValueToFunction(data->cxDebugger, data->jsScriptHook)))
+    {
+        jsval result;
+        jsval args[2] = {P2H_SCRIPT(data->cxDebugger, jsdscript),
+                         creating ? JSVAL_TRUE : JSVAL_FALSE };
+        JS_CallFunction(data->cxDebugger, NULL, fun, 2, args, &result);
+    }
+}
+
+uintN JS_DLL_CALLBACK
+jsdb_ExecHookHandler(JSDContext*     jsdc,
+                     JSDThreadState* jsdthreadstate,
+                     uintN           type,
+                     void*           callerdata,
+                     jsval*          rval)
+{
+    uintN ourRetVal = JSD_HOOK_RETURN_CONTINUE;
+    jsval result;
+    JSFunction* fun;
+    int answer;
+    JSDB_Data* data = (JSDB_Data*) callerdata;
+    JS_ASSERT(data);
+
+    /* if we're already stopped, then don't stop */
+    if(data->jsdthreadstate)
+        return JSD_HOOK_RETURN_CONTINUE;
+
+    if(!jsdb_SetThreadState(data, jsdthreadstate))
+        goto label_bail;
+
+    if(data->jsExecutionHook &&
+       NULL != (fun = JS_ValueToFunction(data->cxDebugger, data->jsExecutionHook)))
+    {
+        jsval arg = INT_TO_JSVAL((int)type);
+        if(!JS_CallFunction(data->cxDebugger, NULL, fun, 1, &arg, &result))
+            goto label_bail;
+        if(!JSVAL_IS_INT(result))
+            goto label_bail;
+        answer = JSVAL_TO_INT(result);
+
+
+        if((answer == JSD_HOOK_RETURN_RET_WITH_VAL ||
+            answer == JSD_HOOK_RETURN_THROW_WITH_VAL) &&
+           !jsdb_EvalReturnExpression(data, rval))          
+        {
+            goto label_bail;
+        }
+
+        if(answer >= JSD_HOOK_RETURN_HOOK_ERROR &&
+           answer <= JSD_HOOK_RETURN_CONTINUE_THROW)
+            ourRetVal = answer;
+        else
+            ourRetVal = JSD_HOOK_RETURN_CONTINUE;
+    }
+
+label_bail:
+    jsdb_SetThreadState(data, NULL);
+    return ourRetVal;
+}
+
+typedef enum
+{
+    ARG_MSG = 0,
+    ARG_FILENAME,
+    ARG_LINENO,
+    ARG_LINEBUF,
+    ARG_TOKEN_OFFSET,
+    ARG_LIMIT
+} ER_ARGS;
+
+uintN JS_DLL_CALLBACK
+jsdb_ErrorReporter(JSDContext*     jsdc,
+                   JSContext*      cx,
+                   const char*     message,
+                   JSErrorReport*  report,
+                   void*           callerdata)
+{
+    uintN ourRetVal = JSD_ERROR_REPORTER_PASS_ALONG;
+    jsval result;
+    JSFunction* fun;
+    int32 answer;
+    JSDB_Data* data = (JSDB_Data*) callerdata;
+    JS_ASSERT(data);
+
+    if(data->jsErrorReporterHook &&
+       NULL != (fun = JS_ValueToFunction(data->cxDebugger,
+                                         data->jsErrorReporterHook)))
+    {
+        jsval args[ARG_LIMIT] = {JSVAL_NULL};
+
+        if(message)
+            args[ARG_MSG] =
+                    STRING_TO_JSVAL(JS_NewStringCopyZ(cx, message));
+        if(report && report->filename)
+            args[ARG_FILENAME] =
+                    STRING_TO_JSVAL(JS_NewStringCopyZ(cx, report->filename));
+        if(report && report->linebuf)
+            args[ARG_LINEBUF] =
+                    STRING_TO_JSVAL(JS_NewStringCopyZ(cx, report->linebuf));
+        if(report)
+            args[ARG_LINENO] =
+                    INT_TO_JSVAL(report->lineno);
+        if(report && report->linebuf && report->tokenptr)
+            args[ARG_TOKEN_OFFSET] =
+                    INT_TO_JSVAL((int)(report->tokenptr - report->linebuf));
+
+        if(!JS_CallFunction(data->cxDebugger, NULL, fun, ARG_LIMIT, args, &result))
+            return ourRetVal;
+
+        if(JS_ValueToInt32(data->cxDebugger, result, &answer))
+            ourRetVal = (uintN) answer;
+    }
+    return ourRetVal;
+}
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+Load(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    uintN i;
+    JSString *str;
+    const char *filename;
+    JSScript *script;
+    JSBool ok;
+    jsval result;
+
+    ok = JS_TRUE;
+    for (i = 0; i < argc; i++) {
+        str = JS_ValueToString(cx, argv[i]);
+        if (!str) {
+            ok = JS_FALSE;
+            break;
+        }
+        argv[i] = STRING_TO_JSVAL(str);
+        filename = JS_GetStringBytes(str);
+        errno = 0;
+        script = JS_CompileFile(cx, obj, filename);
+        if (!script)
+            continue;
+        ok = JS_ExecuteScript(cx, obj, script, &result);
+        JS_DestroyScript(cx, script);
+        if (!ok)
+            break;
+    }
+    JS_GC(cx);
+    *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx,""));
+    return ok;
+}
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+Write(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    JSString *str = JS_ValueToString(cx, argv[0]);
+    if (!str)
+        return JS_FALSE;
+    printf(JS_GetStringBytes(str));
+    *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx,""));
+    return JS_TRUE;
+}
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+Gets(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    char buf[1024];
+    if(! gets(buf))
+        return JS_FALSE;
+    *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, buf));
+    return JS_TRUE;
+}
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+Version(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    if (argc > 0 && JSVAL_IS_INT(argv[0]))
+        *rval = INT_TO_JSVAL(JS_SetVersion(cx, JSVAL_TO_INT(argv[0])));
+    else
+        *rval = INT_TO_JSVAL(JS_GetVersion(cx));
+    return JS_TRUE;
+}
+
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+SafeEval(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+    static char default_filename[] = "jsdb_eval";
+/*     JSContext *cx2; */
+    JSString* textJSString;
+    char* filename;
+    int32 lineno;
+    JSDB_Data* data = (JSDB_Data*) JS_GetContextPrivate(cx);
+    JS_ASSERT(data);
+
+    if(argc < 1 || !(textJSString = JS_ValueToString(cx, argv[0])))
+    {
+        JS_ReportError(cx, "safeEval requires source text as a first argument");
+        return JS_FALSE;
+    }
+
+    if(argc < 2)
+        filename = default_filename;
+    else
+    {
+        JSString* filenameJSString;
+        if(!(filenameJSString = JS_ValueToString(cx, argv[1])))
+        {
+            JS_ReportError(cx, "safeEval passed non-string filename as 2nd param");
+            return JS_FALSE;
+        }
+        filename = JS_GetStringBytes(filenameJSString);
+    }
+
+    if(argc < 3)
+        lineno = 1;
+    else
+    {
+        if(!JS_ValueToInt32(cx, argv[2], &lineno))
+        {
+            JS_ReportError(cx, "safeEval passed non-int lineno as 3rd param");
+            return JS_FALSE;
+        }
+    }
+
+    if(! JS_EvaluateScript(cx, obj,
+                           JS_GetStringBytes(textJSString),
+                           JS_GetStringLength(textJSString),
+                           filename, lineno, rval))
+        *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx,""));
+
+    return JS_TRUE;
+}
+
+JS_STATIC_DLL_CALLBACK(JSBool)
+NativeBreak(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
+{
+#ifdef _WINDOWS
+    _asm int 3;
+    *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx,"did _asm int 3;"));
+#else
+    *rval = STRING_TO_JSVAL(JS_NewStringCopyZ(cx,"only supported for Windows"));
+#endif
+    return JS_TRUE;
+}
+
+static JSFunctionSpec debugger_functions[] = {
+    {"version",         Version,        0},
+    {"load",            Load,           1},
+    {"write",           Write,          0},
+    {"gets",            Gets,           0},
+    {"safeEval",        SafeEval,       3},
+    {"nativeBreak",     NativeBreak,    0},
+    {0}
+};
+
+static JSClass debugger_global_class = {
+    "debugger_global", 0,
+    JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
+    JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub
+};
+
+/***************************************************************************/
+
+#ifdef JSD_LOWLEVEL_SOURCE
+/*
+ * This facilitates sending source to JSD (the debugger system) in the shell
+ * where the source is loaded using the JSFILE hack in jsscan. The function
+ * below is used as a callback for the jsdbgapi JS_SetSourceHandler hook.
+ * A more normal embedding (e.g. mozilla) loads source itself and can send
+ * source directly to JSD without using this hook scheme.
+ */
+static void
+SendSourceToJSDebugger(const char *filename, uintN lineno,
+                       jschar *str, size_t length,
+                       void **listenerTSData, JSDContext* jsdc)
+{
+    JSDSourceText *jsdsrc = (JSDSourceText *) *listenerTSData;
+
+    if (!jsdsrc) {
+        if (!filename)
+            filename = "typein";
+        if (1 == lineno) {
+            jsdsrc = JSD_NewSourceText(jsdc, filename);
+        } else {
+            jsdsrc = JSD_FindSourceForURL(jsdc, filename);
+            if (jsdsrc && JSD_SOURCE_PARTIAL !=
+                JSD_GetSourceStatus(jsdc, jsdsrc)) {
+                jsdsrc = NULL;
+            }
+        }
+    }
+    if (jsdsrc) {
+        jsdsrc = JSD_AppendUCSourceText(jsdc,jsdsrc, str, length,
+                                        JSD_SOURCE_PARTIAL);
+    }
+    *listenerTSData = jsdsrc;
+}
+#endif /* JSD_LOWLEVEL_SOURCE */
+
+static JSBool
+_initReturn(const char* str, JSBool retval)
+{
+    if(str)
+        printf("%s\n", str);
+    if(retval)
+        ; /* printf("debugger initialized\n"); */
+    else
+    {
+        JS_ASSERT(0);
+        printf("debugger FAILED to initialize\n");
+    }
+    return retval;
+}
+
+#define MAX_DEBUGGER_DEPTH 3
+
+JS_EXPORT_API(JSBool)
+JSDB_InitDebugger(JSRuntime* rt, JSDContext* jsdc, int depth)
+{
+    jsval rvalIgnore;
+    static char load_deb[] = "load('debugger.js')";
+
+    JSDB_Data* data = (JSDB_Data*) calloc(1, sizeof(JSDB_Data));
+    if(!data)
+        return _initReturn("memory alloc error", JS_FALSE);
+
+    data->rtTarget   = rt;
+    data->jsdcTarget = jsdc;
+    data->debuggerDepth = depth+1;
+
+    if(!(data->rtDebugger = JS_NewRuntime(8L * 1024L * 1024L)))
+        return _initReturn("debugger runtime creation error", JS_FALSE);
+
+    if(!(data->cxDebugger = JS_NewContext(data->rtDebugger, 8192)))
+        return _initReturn("debugger creation error", JS_FALSE);
+
+    JS_SetContextPrivate(data->cxDebugger, data);
+
+    JS_SetErrorReporter(data->cxDebugger, _ErrorReporter);
+
+    if(!(data->globDebugger =
+            JS_NewObject(data->cxDebugger, &debugger_global_class, NULL, NULL)))
+        return _initReturn("debugger global object creation error", JS_FALSE);
+
+    if(!JS_InitStandardClasses(data->cxDebugger, data->globDebugger))
+        return _initReturn("debugger InitStandardClasses error", JS_FALSE);
+
+    if(!JS_DefineFunctions(data->cxDebugger, data->globDebugger, debugger_functions))
+        return _initReturn("debugger DefineFunctions error", JS_FALSE);
+
+    if(!jsdb_ReflectJSD(data))
+        return _initReturn("debugger reflection of JSD API error", JS_FALSE);
+
+    if(data->debuggerDepth < MAX_DEBUGGER_DEPTH)
+    {
+        JSDContext* jsdc;
+        if(!(jsdc = JSD_DebuggerOnForUser(data->rtDebugger, NULL, NULL)))
+            return _initReturn("failed to create jsdc for nested debugger", JS_FALSE);
+        JSD_JSContextInUse(jsdc, data->cxDebugger);
+        if(!JSDB_InitDebugger(data->rtDebugger, jsdc, data->debuggerDepth))
+            return _initReturn("failed to init nested debugger", JS_FALSE);
+    }
+
+    JSD_SetScriptHook(jsdc, jsdb_ScriptHookProc, data);
+    JSD_SetDebuggerHook(jsdc, jsdb_ExecHookHandler, data);
+    JSD_SetThrowHook(jsdc, jsdb_ExecHookHandler, data);
+    JSD_SetDebugBreakHook(jsdc, jsdb_ExecHookHandler, data);
+    JSD_SetErrorReporter(jsdc, jsdb_ErrorReporter, data);
+
+#ifdef JSD_LOWLEVEL_SOURCE
+    JS_SetSourceHandler(data->rtDebugger, SendSourceToJSDebugger, jsdc);
+#endif /* JSD_LOWLEVEL_SOURCE */
+
+    JS_EvaluateScript(data->cxDebugger, data->globDebugger,
+                      load_deb, sizeof(load_deb)-1, "jsdb_autoload", 1,
+                      &rvalIgnore);
+
+    return _initReturn(NULL, JS_TRUE);
+}
+

mozilla/js/jsd/jsdb/jsdb.h

@@ -0,0 +1,50 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*                        
+* Public headers for JSDB 
+*/                        
+
+#ifndef jsdb_h___
+#define jsdb_h___
+
+/* Get jstypes.h included first. After that we can use PR macros for doing
+*  this extern "C" stuff!
+*/ 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include "jstypes.h"
+#ifdef __cplusplus
+}
+#endif
+
+JS_BEGIN_EXTERN_C
+#include "jsapi.h"
+#include "jsdebug.h"
+JS_END_EXTERN_C
+
+JS_BEGIN_EXTERN_C
+
+extern JS_EXPORT_API(JSBool)
+JSDB_InitDebugger(JSRuntime* rt, JSDContext* jsdc, int depth);
+
+JS_END_EXTERN_C
+
+#endif /* jsdb_h___ */

mozilla/js/jsd/jsdb/jsdb.mak

@@ -0,0 +1,102 @@
+
+PROJ = jsdb
+JSDB = .
+JSD = $(JSDB)\..
+JSSRC = $(JSD)\..\src
+
+!IF "$(BUILD_OPT)" != ""
+OBJ = Release
+CC_FLAGS = /DNDEBUG
+!ELSE
+OBJ = Debug
+CC_FLAGS = /DDEBUG
+LINK_FLAGS = /DEBUG
+!ENDIF 
+
+CFLAGS = /nologo /MDd /W3 /Gm /GX /Zi /Od\
+         /I $(JSSRC)\
+         /I $(JSD)\
+         /I $(JSDB)\
+         $(CC_FLAGS)\
+         /DWIN32 /DXP_PC /D_WINDOWS /D_WIN32\
+         /DJSDEBUGGER\
+         /DJSDEBUGGER_C_UI\
+         /DJSD_LOWLEVEL_SOURCE\
+         /DJSFILE\
+         /c /Fp$(OBJ)\$(PROJ).pch /Fd$(OBJ)\$(PROJ).pdb /YX -Fo$@ $<
+
+LFLAGS = /nologo /subsystem:console /incremental:no /machine:I386 $(LINK_FLAGS)\
+         /pdb:$(OBJ)\$(PROJ).pdb -out:$(OBJ)\$(PROJ).exe
+
+LLIBS = kernel32.lib advapi32.lib $(JSSRC)\$(OBJ)\js32.lib $(JSD)\$(OBJ)\jsd.lib
+
+CPP=cl.exe
+LINK32=link.exe
+
+all: $(OBJ) dlls $(OBJ)\$(PROJ).exe $(OBJ)\debugger.js
+
+
+HEADERS =   $(JSDB)\jsdb.h      \
+            $(JSDB)\jsdbpriv.h
+
+
+OBJECTS =   $(OBJ)\js.obj       \
+            $(OBJ)\jsdb.obj     \
+            $(OBJ)\jsdrefl.obj  
+
+
+$(OBJECTS) : $(HEADERS)
+
+
+$(OBJ)\$(PROJ).exe: $(OBJECTS)
+  $(LINK32) $(LFLAGS) $** $(LLIBS)
+
+.c{$(OBJ)}.obj:
+  $(CPP) $(CFLAGS)
+
+{$(JSSRC)}.c.obj:
+  $(CPP) $(CFLAGS)
+
+$(OBJ) :
+    mkdir $(OBJ)
+
+$(OBJ)\js32.dll :
+    @cd ..\..\src
+    @nmake -f js.mak CFG="js - Win32 Debug"
+    @cd ..\jsd\jsdb
+    @echo Copying dll from js/src
+    @copy $(JSSRC)\$(OBJ)\js32.dll  $(OBJ)  >NUL
+    @copy $(JSSRC)\$(OBJ)\js32.pdb  $(OBJ)  >NUL
+
+$(OBJ)\jsd.dll :
+    @cd ..
+    @nmake -f jsd.mak JSD_THREADSAFE=1
+    @cd jsdb
+    @echo Copying dll from js/jsd
+    @copy $(JSD)\$(OBJ)\jsd.dll  $(OBJ)  >NUL
+    @copy $(JSD)\$(OBJ)\jsd.pdb  $(OBJ)  >NUL
+
+dlls : $(OBJ)\js32.dll $(OBJ)\jsd.dll
+
+$(OBJ)\debugger.js: *.js
+    @echo Copying *.js
+    @copy *.js  $(OBJ) >NUL
+    
+clean:
+    @echo Deleting built files
+    @del $(OBJ)\*.pch >NUL
+    @del $(OBJ)\*.obj >NUL
+    @del $(OBJ)\*.exp >NUL
+    @del $(OBJ)\*.lib >NUL
+    @del $(OBJ)\*.idb >NUL
+    @del $(OBJ)\*.pdb >NUL
+    @del $(OBJ)\*.dll >NUL
+    @del $(OBJ)\*.exe >NUL
+
+deep_clean: clean
+    @cd ..\..\src
+    @nmake -f js.mak CFG="js - Win32 Debug" clean
+    @cd ..\jsd\jsdb
+    @cd ..
+    @nmake -f jsd.mak clean
+    @cd jsdb

mozilla/js/jsd/jsdb/jsdbpriv.h

@@ -0,0 +1,117 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+* Private Headers for JSDB
+*/
+
+#ifndef jsdbpriv_h___
+#define jsdbpriv_h___
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "jstypes.h"
+#include "jsutil.h" /* Added by JSIFY */
+#include "jsprf.h"
+#include "jsdbgapi.h"
+#include "jsdb.h"
+
+/***************************************************************************/
+
+typedef struct JSDB_Data
+{
+    JSDContext*     jsdcTarget;
+    JSRuntime*      rtTarget;
+    JSRuntime*      rtDebugger;
+    JSContext*      cxDebugger;
+    JSObject*       globDebugger;
+    JSObject*       jsdOb;
+    jsval           jsScriptHook;
+    jsval           jsExecutionHook;
+    jsval           jsErrorReporterHook;
+    JSDThreadState* jsdthreadstate;
+    int             debuggerDepth;
+
+} JSDB_Data;
+
+extern JSBool
+jsdb_ReflectJSD(JSDB_Data* data);
+
+/***********************************/
+/*
+*  System to store JSD_xxx handles in jsvals. This supports tracking the
+*  handle's type - both for debugging and for automatic 'dropping' of
+*  reference counted handle types (e.g. JSDValue).
+*/
+
+typedef enum
+{
+    JSDB_GENERIC = 0,
+    JSDB_CONTEXT,
+    JSDB_SCRIPT,
+    JSDB_SOURCETEXT,
+    JSDB_THREADSTATE,
+    JSDB_STACKFRAMEINFO,
+    JSDB_VALUE,
+    JSDB_PROPERTY,
+    JSDB_OBJECT
+} JSDBHandleType;
+
+#define H2P_GENERIC(cx,val)        (void*)              jsdb_HandleValToPointer((cx),(val),JSDB_GENERIC)
+#define H2P_CONTEXT(cx,val)        (JSDContext*)        jsdb_HandleValToPointer((cx),(val),JSDB_CONTEXT)
+#define H2P_SCRIPT(cx,val)         (JSDScript*)         jsdb_HandleValToPointer((cx),(val),JSDB_SCRIPT)
+#define H2P_SOURCETEXT(cx,val)     (JSDSourceText*)     jsdb_HandleValToPointer((cx),(val),JSDB_SOURCETEXT)
+#define H2P_THREADSTATE(cx,val)    (JSDThreadState*)    jsdb_HandleValToPointer((cx),(val),JSDB_THREADSTATE)
+#define H2P_STACKFRAMEINFO(cx,val) (JSDStackFrameInfo*) jsdb_HandleValToPointer((cx),(val),JSDB_STACKFRAMEINFO)
+#define H2P_VALUE(cx,val)          (JSDValue*)          jsdb_HandleValToPointer((cx),(val),JSDB_VALUE)
+#define H2P_PROPERTY(cx,val)       (JSDProperty*)       jsdb_HandleValToPointer((cx),(val),JSDB_PROPERTY)
+#define H2P_OBJECT(cx,val)         (JSDObject*)         jsdb_HandleValToPointer((cx),(val),JSDB_OBJECT)
+
+#define P2H_GENERIC(cx,ptr)        jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_GENERIC)
+#define P2H_CONTEXT(cx,ptr)        jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_CONTEXT)
+#define P2H_SCRIPT(cx,ptr)         jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_SCRIPT)
+#define P2H_SOURCETEXT(cx,ptr)     jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_SOURCETEXT)
+#define P2H_THREADSTATE(cx,ptr)    jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_THREADSTATE)
+#define P2H_STACKFRAMEINFO(cx,ptr) jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_STACKFRAMEINFO)
+#define P2H_VALUE(cx,ptr)          jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_VALUE)
+#define P2H_PROPERTY(cx,ptr)       jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_PROPERTY)
+#define P2H_OBJECT(cx,ptr)         jsdb_PointerToNewHandleVal((cx),(ptr),JSDB_OBJECT)
+
+extern jsval
+jsdb_PointerToNewHandleVal(JSContext *cx, void* ptr, JSDBHandleType type);
+
+extern void*
+jsdb_HandleValToPointer(JSContext *cx, jsval val, JSDBHandleType type);
+
+/***********************************/
+
+extern JSBool
+jsdb_SetThreadState(JSDB_Data* data, JSDThreadState* jsdthreadstate);
+
+extern uintN JS_DLL_CALLBACK
+jsdb_ExecHookHandler(JSDContext*     jsdc,
+                     JSDThreadState* jsdthreadstate,
+                     uintN           type,
+                     void*           callerdata,
+                     jsval*          rval);
+
+extern JSBool
+jsdb_EvalReturnExpression(JSDB_Data* data, jsval* rval);
+
+#endif /* jsdbpriv_h___ */

mozilla/js/jsd/jsdb/mk.bat

@@ -0,0 +1 @@
+nmake -f jsdb.mak %1 %2 %3 %4 %5 %6 %7 %8 %9

mozilla/js/jsd/jsdb/objects.js

@@ -0,0 +1,56 @@
+// some tests...
+
+function set_a(a) {this.a = a;}
+function set_b(b) {this.b = b;}
+function set_c(c) {this.c = c;}
+
+function f_ctor(a,b,c)
+{
+    this.set_a = set_a;
+    this.set_b = set_b;
+    this.set_c = set_c;
+
+// NOTE: these break JSD_LOWLEVEL_SOURCE in shell debugger
+    this.get_a = new Function("return this.a;");
+//    this.get_b = new Function("return this.b;");
+//    this.get_c = new Function("return this.c;");
+
+//    this.get_a = function() {return this.a;};
+    this.get_b = function() {return this.b;};
+    this.get_c = function() {return this.c;};
+
+    this.set_a(a);
+    this.set_b(b);
+    this.set_c(c);
+}
+
+function f2_ctor(param)
+{
+    this.A = new f_ctor(1,2,3);
+    this.b = new f_ctor("A","B","C");
+    this.number = param;
+}
+
+function callMe()
+{
+    var A = new f2_ctor(1);
+    debugger;
+    var b = new f2_ctor(5);
+}    
+
+function foo(a,b,c,d,e,f)
+{
+    var g;
+    var h;
+    var i;
+    var j;
+    debugger;
+}    
+
+A = new f2_ctor(0);
+AA = new f2_ctor(100);
+callMe();
+foo(1,2,3,4,5);
+
+A.A.set_b(8);
+print(A.A.get_b());

mozilla/js/jsd/jsdb/test.js

@@ -0,0 +1 @@
+load('objects.js')