removed obsolete svn folder from hg tree

--HG--
extra : convert_revision : svn%3Ab2ef00c0-3703-41da-baef-cfe82387ac0c/trunk%408

23 files changed, 11033 insertions, 0 deletions

diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/ToolErrorReporter.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/ToolErrorReporter.java
new file mode 100644
index 0000000..938f5f2
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/ToolErrorReporter.java
@@ -0,0 +1,225 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Norris Boyd
+ *   Kurt Westerfeld
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools;
+
+import org.mozilla.javascript.*;
+
+import java.text.MessageFormat;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Error reporter for tools.
+ *
+ * Currently used by both the shell and the compiler.
+ */
+public class ToolErrorReporter implements ErrorReporter {
+
+    public ToolErrorReporter(boolean reportWarnings) {
+        this(reportWarnings, System.err);
+    }
+
+    public ToolErrorReporter(boolean reportWarnings, PrintStream err) {
+        this.reportWarnings = reportWarnings;
+        this.err = err;
+    }
+
+    /**
+     * Look up the message corresponding to messageId in the
+     * org.mozilla.javascript.tools.shell.resources.Messages property file.
+     * For internationalization support.
+     */
+    public static String getMessage(String messageId) {
+        return getMessage(messageId, (Object []) null);
+    }
+
+    public static String getMessage(String messageId, String argument) {
+        Object[] args = { argument };
+        return getMessage(messageId, args);
+    }
+
+    public static String getMessage(String messageId, Object arg1, Object arg2)
+    {
+        Object[] args = { arg1, arg2 };
+        return getMessage(messageId, args);
+    }
+
+    public static String getMessage(String messageId, Object[] args) {
+        Context cx = Context.getCurrentContext();
+        Locale locale = cx == null ? Locale.getDefault() : cx.getLocale();
+
+        // ResourceBundle does cacheing.
+        ResourceBundle rb = ResourceBundle.getBundle
+            ("org.mozilla.javascript.tools.resources.Messages", locale);
+
+        String formatString;
+        try {
+            formatString = rb.getString(messageId);
+        } catch (java.util.MissingResourceException mre) {
+            throw new RuntimeException("no message resource found for message property "
+                                       + messageId);
+        }
+
+        if (args == null) {
+            return formatString;
+        } else {
+            MessageFormat formatter = new MessageFormat(formatString);
+            return formatter.format(args);
+        }
+    }
+
+    private static String getExceptionMessage(RhinoException ex)
+    {
+        String msg;
+        if (ex instanceof JavaScriptException) {
+            msg = getMessage("msg.uncaughtJSException", ex.details());
+        } else if (ex instanceof EcmaError) {
+            msg = getMessage("msg.uncaughtEcmaError", ex.details());
+        } else if (ex instanceof EvaluatorException) {
+            msg = ex.details();
+        } else {
+            msg = ex.toString();
+        }
+        return msg;
+    }
+
+    public void warning(String message, String sourceName, int line,
+                        String lineSource, int lineOffset)
+    {
+        if (!reportWarnings)
+            return;
+        reportErrorMessage(message, sourceName, line, lineSource, lineOffset,
+                           true);
+    }
+
+    public void error(String message, String sourceName, int line,
+                      String lineSource, int lineOffset)
+    {
+        hasReportedErrorFlag = true;
+        reportErrorMessage(message, sourceName, line, lineSource, lineOffset,
+                           false);
+    }
+
+    public EvaluatorException runtimeError(String message, String sourceName,
+                                           int line, String lineSource,
+                                           int lineOffset)
+    {
+        return new EvaluatorException(message, sourceName, line,
+                                      lineSource, lineOffset);
+    }
+
+    public boolean hasReportedError() {
+        return hasReportedErrorFlag;
+    }
+
+    public boolean isReportingWarnings() {
+        return this.reportWarnings;
+    }
+
+    public void setIsReportingWarnings(boolean reportWarnings) {
+        this.reportWarnings = reportWarnings;
+    }
+
+    public static void reportException(ErrorReporter er, RhinoException ex)
+    {
+        if (er instanceof ToolErrorReporter) {
+            ((ToolErrorReporter)er).reportException(ex);
+        } else {
+            String msg = getExceptionMessage(ex);
+            er.error(msg, ex.sourceName(), ex.lineNumber(),
+                     ex.lineSource(), ex.columnNumber());
+        }
+    }
+
+    public void reportException(RhinoException ex)
+    {
+        if (ex instanceof WrappedException) {
+            WrappedException we = (WrappedException)ex;
+            we.printStackTrace(err);
+        } else {
+            String lineSeparator =
+                SecurityUtilities.getSystemProperty("line.separator");
+            String msg = getExceptionMessage(ex) + lineSeparator +
+                ex.getScriptStackTrace();
+            reportErrorMessage(msg, ex.sourceName(), ex.lineNumber(),
+                               ex.lineSource(), ex.columnNumber(), false);
+        }
+    }
+
+    private void reportErrorMessage(String message, String sourceName, int line,
+                                    String lineSource, int lineOffset,
+                                    boolean justWarning)
+    {
+        if (line > 0) {
+            String lineStr = String.valueOf(line);
+            if (sourceName != null) {
+                Object[] args = { sourceName, lineStr, message };
+                message = getMessage("msg.format3", args);
+            } else {
+                Object[] args = { lineStr, message };
+                message = getMessage("msg.format2", args);
+            }
+        } else {
+            Object[] args = { message };
+            message = getMessage("msg.format1", args);
+        }
+        if (justWarning) {
+            message = getMessage("msg.warning", message);
+        }
+        err.println(messagePrefix + message);
+        if (null != lineSource) {
+            err.println(messagePrefix + lineSource);
+            err.println(messagePrefix + buildIndicator(lineOffset));
+        }
+    }
+
+    private String buildIndicator(int offset){
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < offset-1; i++)
+            sb.append(".");
+        sb.append("^");
+        return sb.toString();
+    }
+
+    private final String messagePrefix = "js: ";
+    private boolean hasReportedErrorFlag;
+    private boolean reportWarnings;
+    private PrintStream err;
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Dim.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Dim.java
new file mode 100644
index 0000000..de8fcde
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Dim.java
@@ -0,0 +1,1560 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * SeeBeyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Matt Gould
+ *   Christopher Oliver
+ *   Cameron McCormack
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.debugger;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.debug.*;
+import java.util.*;
+import java.io.*;
+import java.net.URL;
+
+/**
+ * Dim or Debugger Implementation for Rhino.
+ */
+public class Dim {
+
+    // Constants for instructing the debugger what action to perform
+    // to end interruption.  Used by 'returnValue'.
+    public static final int STEP_OVER = 0;
+    public static final int STEP_INTO = 1;
+    public static final int STEP_OUT = 2;
+    public static final int GO = 3;
+    public static final int BREAK = 4;
+    public static final int EXIT = 5;
+
+    // Constants for the DimIProxy interface implementation class.
+    private static final int IPROXY_DEBUG = 0;
+    private static final int IPROXY_LISTEN = 1;
+    private static final int IPROXY_COMPILE_SCRIPT = 2;
+    private static final int IPROXY_EVAL_SCRIPT = 3;
+    private static final int IPROXY_STRING_IS_COMPILABLE = 4;
+    private static final int IPROXY_OBJECT_TO_STRING = 5;
+    private static final int IPROXY_OBJECT_PROPERTY = 6;
+    private static final int IPROXY_OBJECT_IDS = 7;
+
+    /**
+     * Interface to the debugger GUI.
+     */
+    private GuiCallback callback;
+
+    /**
+     * Whether the debugger should break.
+     */
+    private boolean breakFlag;
+
+    /**
+     * The ScopeProvider object that provides the scope in which to
+     * evaluate script.
+     */
+    private ScopeProvider scopeProvider;
+
+    /**
+     * The index of the current stack frame.
+     */
+    private int frameIndex = -1;
+
+    /**
+     * Information about the current stack at the point of interruption.
+     */
+    private volatile ContextData interruptedContextData;
+
+    /**
+     * The ContextFactory to listen to for debugging information.
+     */
+    private ContextFactory contextFactory;
+
+    /**
+     * Synchronization object used to allow script evaluations to
+     * happen when a thread is resumed.
+     */
+    private Object monitor = new Object();
+
+    /**
+     * Synchronization object used to wait for valid
+     * {@link #interruptedContextData}.
+     */
+    private Object eventThreadMonitor = new Object();
+
+    /**
+     * The action to perform to end the interruption loop.
+     */
+    private volatile int returnValue = -1;
+
+    /**
+     * Whether the debugger is inside the interruption loop.
+     */
+    private boolean insideInterruptLoop;
+
+    /**
+     * The requested script string to be evaluated when the thread
+     * has been resumed.
+     */
+    private String evalRequest;
+
+    /**
+     * The stack frame in which to evaluate {@link #evalRequest}.
+     */
+    private StackFrame evalFrame;
+
+    /**
+     * The result of evaluating {@link #evalRequest}.
+     */
+    private String evalResult;
+
+    /**
+     * Whether the debugger should break when a script exception is thrown.
+     */
+    private boolean breakOnExceptions;
+
+    /**
+     * Whether the debugger should break when a script function is entered.
+     */
+    private boolean breakOnEnter;
+
+    /**
+     * Whether the debugger should break when a script function is returned
+     * from.
+     */
+    private boolean breakOnReturn;
+
+    /**
+     * Table mapping URLs to information about the script source.
+     */
+    private final Hashtable urlToSourceInfo = new Hashtable();
+
+    /**
+     * Table mapping function names to information about the function.
+     */
+    private final Hashtable functionNames = new Hashtable();
+
+    /**
+     * Table mapping functions to information about the function.
+     */
+    private final Hashtable functionToSource = new Hashtable();
+
+    /**
+     * ContextFactory.Listener instance attached to {@link #contextFactory}.
+     */
+    private DimIProxy listener;
+
+    /**
+     * Sets the GuiCallback object to use.
+     */
+    public void setGuiCallback(GuiCallback callback) {
+        this.callback = callback;
+    }
+
+    /**
+     * Tells the debugger to break at the next opportunity.
+     */
+    public void setBreak() {
+        this.breakFlag = true;
+    }
+
+    /**
+     * Sets the ScopeProvider to be used.
+     */
+    public void setScopeProvider(ScopeProvider scopeProvider) {
+        this.scopeProvider = scopeProvider;
+    }
+
+    /**
+     * Switches context to the stack frame with the given index.
+     */
+    public void contextSwitch(int frameIndex) {
+        this.frameIndex = frameIndex;
+    }
+
+    /**
+     * Sets whether the debugger should break on exceptions.
+     */
+    public void setBreakOnExceptions(boolean breakOnExceptions) {
+        this.breakOnExceptions = breakOnExceptions;
+    }
+
+    /**
+     * Sets whether the debugger should break on function entering.
+     */
+    public void setBreakOnEnter(boolean breakOnEnter) {
+        this.breakOnEnter = breakOnEnter;
+    }
+
+    /**
+     * Sets whether the debugger should break on function return.
+     */
+    public void setBreakOnReturn(boolean breakOnReturn) {
+        this.breakOnReturn = breakOnReturn;
+    }
+
+    /**
+     * Attaches the debugger to the given ContextFactory.
+     */
+    public void attachTo(ContextFactory factory) {
+        detach();
+        this.contextFactory = factory;
+        this.listener = new DimIProxy(this, IPROXY_LISTEN);
+        factory.addListener(this.listener);
+    }
+
+    /**
+     * Detaches the debugger from the current ContextFactory.
+     */
+    public void detach() {
+        if (listener != null) {
+            contextFactory.removeListener(listener);
+            contextFactory = null;
+            listener = null;
+        }
+    }
+
+    /**
+     * Releases resources associated with this debugger.
+     */
+    public void dispose() {
+        detach();
+    }
+
+    /**
+     * Returns the FunctionSource object for the given script or function.
+     */
+    private FunctionSource getFunctionSource(DebuggableScript fnOrScript) {
+        FunctionSource fsource = functionSource(fnOrScript);
+        if (fsource == null) {
+            String url = getNormalizedUrl(fnOrScript);
+            SourceInfo si = sourceInfo(url);
+            if (si == null) {
+                if (!fnOrScript.isGeneratedScript()) {
+                    // Not eval or Function, try to load it from URL
+                    String source = loadSource(url);
+                    if (source != null) {
+                        DebuggableScript top = fnOrScript;
+                        for (;;) {
+                            DebuggableScript parent = top.getParent();
+                            if (parent == null) {
+                                break;
+                            }
+                            top = parent;
+                        }
+                        registerTopScript(top, source);
+                        fsource = functionSource(fnOrScript);
+                    }
+                }
+            }
+        }
+        return fsource;
+    }
+
+    /**
+     * Loads the script at the given URL.
+     */
+    private String loadSource(String sourceUrl) {
+        String source = null;
+        int hash = sourceUrl.indexOf('#');
+        if (hash >= 0) {
+            sourceUrl = sourceUrl.substring(0, hash);
+        }
+        try {
+            InputStream is;
+          openStream:
+            {
+                if (sourceUrl.indexOf(':') < 0) {
+                    // Can be a file name
+                    try {
+                        if (sourceUrl.startsWith("~/")) {
+                            String home = SecurityUtilities.getSystemProperty("user.home");
+                            if (home != null) {
+                                String pathFromHome = sourceUrl.substring(2);
+                                File f = new File(new File(home), pathFromHome);
+                                if (f.exists()) {
+                                    is = new FileInputStream(f);
+                                    break openStream;
+                                }
+                            }
+                        }
+                        File f = new File(sourceUrl);
+                        if (f.exists()) {
+                            is = new FileInputStream(f);
+                            break openStream;
+                        }
+                    } catch (SecurityException ex) { }
+                    // No existing file, assume missed http://
+                    if (sourceUrl.startsWith("//")) {
+                        sourceUrl = "http:" + sourceUrl;
+                    } else if (sourceUrl.startsWith("/")) {
+                        sourceUrl = "http://127.0.0.1" + sourceUrl;
+                    } else {
+                        sourceUrl = "http://" + sourceUrl;
+                    }
+                }
+
+                is = (new URL(sourceUrl)).openStream();
+            }
+
+            try {
+                source = Kit.readReader(new InputStreamReader(is));
+            } finally {
+                is.close();
+            }
+        } catch (IOException ex) {
+            System.err.println
+                ("Failed to load source from "+sourceUrl+": "+ ex);
+        }
+        return source;
+    }
+
+    /**
+     * Registers the given script as a top-level script in the debugger.
+     */
+    private void registerTopScript(DebuggableScript topScript, String source) {
+        if (!topScript.isTopLevel()) {
+            throw new IllegalArgumentException();
+        }
+        String url = getNormalizedUrl(topScript);
+        DebuggableScript[] functions = getAllFunctions(topScript);
+        final SourceInfo sourceInfo = new SourceInfo(source, functions, url);
+
+        synchronized (urlToSourceInfo) {
+            SourceInfo old = (SourceInfo)urlToSourceInfo.get(url);
+            if (old != null) {
+                sourceInfo.copyBreakpointsFrom(old);
+            }
+            urlToSourceInfo.put(url, sourceInfo);
+            for (int i = 0; i != sourceInfo.functionSourcesTop(); ++i) {
+                FunctionSource fsource = sourceInfo.functionSource(i);
+                String name = fsource.name();
+                if (name.length() != 0) {
+                    functionNames.put(name, fsource);
+                }
+            }
+        }
+
+        synchronized (functionToSource) {
+            for (int i = 0; i != functions.length; ++i) {
+                FunctionSource fsource = sourceInfo.functionSource(i);
+                functionToSource.put(functions[i], fsource);
+            }
+        }
+
+        callback.updateSourceText(sourceInfo);
+    }
+
+    /**
+     * Returns the FunctionSource object for the given function or script.
+     */
+    private FunctionSource functionSource(DebuggableScript fnOrScript) {
+        return (FunctionSource)functionToSource.get(fnOrScript);
+    }
+
+    /**
+     * Returns an array of all function names.
+     */
+    public String[] functionNames() {
+        String[] a;
+        synchronized (urlToSourceInfo) {
+            Enumeration e = functionNames.keys();
+            a = new String[functionNames.size()];
+            int i = 0;
+            while (e.hasMoreElements()) {
+                a[i++] = (String)e.nextElement();
+            }
+        }
+        return a;
+    }
+
+    /**
+     * Returns the FunctionSource object for the function with the given name.
+     */
+    public FunctionSource functionSourceByName(String functionName) {
+        return (FunctionSource)functionNames.get(functionName);
+    }
+
+    /**
+     * Returns the SourceInfo object for the given URL.
+     */
+    public SourceInfo sourceInfo(String url) {
+        return (SourceInfo)urlToSourceInfo.get(url);
+    }
+
+    /**
+     * Returns the source URL for the given script or function.
+     */
+    private String getNormalizedUrl(DebuggableScript fnOrScript) {
+        String url = fnOrScript.getSourceName();
+        if (url == null) { url = "<stdin>"; }
+        else {
+            // Not to produce window for eval from different lines,
+            // strip line numbers, i.e. replace all #[0-9]+\(eval\) by
+            // (eval)
+            // Option: similar teatment for Function?
+            char evalSeparator = '#';
+            StringBuffer sb = null;
+            int urlLength = url.length();
+            int cursor = 0;
+            for (;;) {
+                int searchStart = url.indexOf(evalSeparator, cursor);
+                if (searchStart < 0) {
+                    break;
+                }
+                String replace = null;
+                int i = searchStart + 1;
+                while (i != urlLength) {
+                    int c = url.charAt(i);
+                    if (!('0' <= c && c <= '9')) {
+                        break;
+                    }
+                    ++i;
+                }
+                if (i != searchStart + 1) {
+                    // i points after #[0-9]+
+                    if ("(eval)".regionMatches(0, url, i, 6)) {
+                        cursor = i + 6;
+                        replace = "(eval)";
+                    }
+                }
+                if (replace == null) {
+                    break;
+                }
+                if (sb == null) {
+                    sb = new StringBuffer();
+                    sb.append(url.substring(0, searchStart));
+                }
+                sb.append(replace);
+            }
+            if (sb != null) {
+                if (cursor != urlLength) {
+                    sb.append(url.substring(cursor));
+                }
+                url = sb.toString();
+            }
+        }
+        return url;
+    }
+
+    /**
+     * Returns an array of all functions in the given script.
+     */
+    private static DebuggableScript[] getAllFunctions
+            (DebuggableScript function) {
+        ObjArray functions = new ObjArray();
+        collectFunctions_r(function, functions);
+        DebuggableScript[] result = new DebuggableScript[functions.size()];
+        functions.toArray(result);
+        return result;
+    }
+
+    /**
+     * Helper function for {@link #getAllFunctions(DebuggableScript)}.
+     */
+    private static void collectFunctions_r(DebuggableScript function,
+                                             ObjArray array) {
+        array.add(function);
+        for (int i = 0; i != function.getFunctionCount(); ++i) {
+            collectFunctions_r(function.getFunction(i), array);
+        }
+    }
+
+    /**
+     * Clears all breakpoints.
+     */
+    public void clearAllBreakpoints() {
+        Enumeration e = urlToSourceInfo.elements();
+        while (e.hasMoreElements()) {
+            SourceInfo si = (SourceInfo)e.nextElement();
+            si.removeAllBreakpoints();
+        }
+    }
+
+    /**
+     * Called when a breakpoint has been hit.
+     */
+    private void handleBreakpointHit(StackFrame frame, Context cx) {
+        breakFlag = false;
+        interrupted(cx, frame, null);
+    }
+
+    /**
+     * Called when a script exception has been thrown.
+     */
+    private void handleExceptionThrown(Context cx, Throwable ex,
+                                         StackFrame frame) {
+        if (breakOnExceptions) {
+            ContextData cd = frame.contextData();
+            if (cd.lastProcessedException != ex) {
+                interrupted(cx, frame, ex);
+                cd.lastProcessedException = ex;
+            }
+        }
+    }
+
+    /**
+     * Returns the current ContextData object.
+     */
+    public ContextData currentContextData() {
+        return interruptedContextData;
+    }
+
+    /**
+     * Sets the action to perform to end interruption.
+     */
+    public void setReturnValue(int returnValue) {
+        synchronized (monitor) {
+            this.returnValue = returnValue;
+            monitor.notify();
+        }
+    }
+
+    /**
+     * Resumes execution of script.
+     */
+    public void go() {
+        synchronized (monitor) {
+            this.returnValue = GO;
+            monitor.notifyAll();
+        }
+    }
+
+    /**
+     * Evaluates the given script.
+     */
+    public String eval(String expr) {
+        String result = "undefined";
+        if (expr == null) {
+            return result;
+        }
+        ContextData contextData = currentContextData();
+        if (contextData == null || frameIndex >= contextData.frameCount()) {
+            return result;
+        }
+        StackFrame frame = contextData.getFrame(frameIndex);
+        if (contextData.eventThreadFlag) {
+            Context cx = Context.getCurrentContext();
+            result = do_eval(cx, frame, expr);
+        } else {
+            synchronized (monitor) {
+                if (insideInterruptLoop) {
+                    evalRequest = expr;
+                    evalFrame = frame;
+                    monitor.notify();
+                    do {
+                        try {
+                            monitor.wait();
+                        } catch (InterruptedException exc) {
+                            Thread.currentThread().interrupt();
+                            break;
+                        }
+                    } while (evalRequest != null);
+                    result = evalResult;
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Compiles the given script.
+     */
+    public void compileScript(String url, String text) {
+        DimIProxy action = new DimIProxy(this, IPROXY_COMPILE_SCRIPT);
+        action.url = url;
+        action.text = text;
+        action.withContext();
+    }
+
+    /**
+     * Evaluates the given script.
+     */
+    public void evalScript(final String url, final String text) {
+        DimIProxy action = new DimIProxy(this, IPROXY_EVAL_SCRIPT);
+        action.url = url;
+        action.text = text;
+        action.withContext();
+    }
+
+    /**
+     * Converts the given script object to a string.
+     */
+    public String objectToString(Object object) {
+        DimIProxy action = new DimIProxy(this, IPROXY_OBJECT_TO_STRING);
+        action.object = object;
+        action.withContext();
+        return action.stringResult;
+    }
+
+    /**
+     * Returns whether the given string is syntactically valid script.
+     */
+    public boolean stringIsCompilableUnit(String str) {
+        DimIProxy action = new DimIProxy(this, IPROXY_STRING_IS_COMPILABLE);
+        action.text = str;
+        action.withContext();
+        return action.booleanResult;
+    }
+
+    /**
+     * Returns the value of a property on the given script object.
+     */
+    public Object getObjectProperty(Object object, Object id) {
+        DimIProxy action = new DimIProxy(this, IPROXY_OBJECT_PROPERTY);
+        action.object = object;
+        action.id = id;
+        action.withContext();
+        return action.objectResult;
+    }
+
+    /**
+     * Returns an array of the property names on the given script object.
+     */
+    public Object[] getObjectIds(Object object) {
+        DimIProxy action = new DimIProxy(this, IPROXY_OBJECT_IDS);
+        action.object = object;
+        action.withContext();
+        return action.objectArrayResult;
+    }
+
+    /**
+     * Returns the value of a property on the given script object.
+     */
+    private Object getObjectPropertyImpl(Context cx, Object object,
+                                           Object id) {
+        Scriptable scriptable = (Scriptable)object;
+        Object result;
+        if (id instanceof String) {
+            String name = (String)id;
+            if (name.equals("this")) {
+                result = scriptable;
+            } else if (name.equals("__proto__")) {
+                result = scriptable.getPrototype();
+            } else if (name.equals("__parent__")) {
+                result = scriptable.getParentScope();
+            } else {
+                result = ScriptableObject.getProperty(scriptable, name);
+                if (result == ScriptableObject.NOT_FOUND) {
+                    result = Undefined.instance;
+                }
+            }
+        } else {
+            int index = ((Integer)id).intValue();
+            result = ScriptableObject.getProperty(scriptable, index);
+            if (result == ScriptableObject.NOT_FOUND) {
+                result = Undefined.instance;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Returns an array of the property names on the given script object.
+     */
+    private Object[] getObjectIdsImpl(Context cx, Object object) {
+        if (!(object instanceof Scriptable) || object == Undefined.instance) {
+            return Context.emptyArgs;
+        }
+
+        Object[] ids;
+        Scriptable scriptable = (Scriptable)object;
+        if (scriptable instanceof DebuggableObject) {
+            ids = ((DebuggableObject)scriptable).getAllIds();
+        } else {
+            ids = scriptable.getIds();
+        }
+
+        Scriptable proto = scriptable.getPrototype();
+        Scriptable parent = scriptable.getParentScope();
+        int extra = 0;
+        if (proto != null) {
+            ++extra;
+        }
+        if (parent != null) {
+            ++extra;
+        }
+        if (extra != 0) {
+            Object[] tmp = new Object[extra + ids.length];
+            System.arraycopy(ids, 0, tmp, extra, ids.length);
+            ids = tmp;
+            extra = 0;
+            if (proto != null) {
+                ids[extra++] = "__proto__";
+            }
+            if (parent != null) {
+                ids[extra++] = "__parent__";
+            }
+        }
+
+        return ids;
+    }
+
+    /**
+     * Interrupts script execution.
+     */
+    private void interrupted(Context cx, final StackFrame frame,
+                               Throwable scriptException) {
+        ContextData contextData = frame.contextData();
+        boolean eventThreadFlag = callback.isGuiEventThread();
+        contextData.eventThreadFlag = eventThreadFlag;
+
+        boolean recursiveEventThreadCall = false;
+
+interruptedCheck:
+        synchronized (eventThreadMonitor) {
+            if (eventThreadFlag) {
+                if (interruptedContextData != null) {
+                    recursiveEventThreadCall = true;
+                    break interruptedCheck;
+                }
+            } else {
+                while (interruptedContextData != null) {
+                    try {
+                        eventThreadMonitor.wait();
+                    } catch (InterruptedException exc) {
+                        return;
+                    }
+                }
+            }
+            interruptedContextData = contextData;
+        }
+
+        if (recursiveEventThreadCall) {
+            // XXX: For now the following is commented out as on Linux
+            // too deep recursion of dispatchNextGuiEvent causes GUI lockout.
+            // Note: it can make GUI unresponsive if long-running script
+            // will be called on GUI thread while processing another interrupt
+            if (false) {
+               // Run event dispatch until gui sets a flag to exit the initial
+               // call to interrupted.
+                while (this.returnValue == -1) {
+                    try {
+                        callback.dispatchNextGuiEvent();
+                    } catch (InterruptedException exc) {
+                    }
+                }
+            }
+            return;
+        }
+
+        if (interruptedContextData == null) Kit.codeBug();
+
+        try {
+            do {
+                int frameCount = contextData.frameCount();
+                this.frameIndex = frameCount -1;
+
+                final String threadTitle = Thread.currentThread().toString();
+                final String alertMessage;
+                if (scriptException == null) {
+                    alertMessage = null;
+                } else {
+                    alertMessage = scriptException.toString();
+                }
+
+                int returnValue = -1;
+                if (!eventThreadFlag) {
+                    synchronized (monitor) {
+                        if (insideInterruptLoop) Kit.codeBug();
+                        this.insideInterruptLoop = true;
+                        this.evalRequest = null;
+                        this.returnValue = -1;
+                        callback.enterInterrupt(frame, threadTitle,
+                                                alertMessage);
+                        try {
+                            for (;;) {
+                                try {
+                                    monitor.wait();
+                                } catch (InterruptedException exc) {
+                                    Thread.currentThread().interrupt();
+                                    break;
+                                }
+                                if (evalRequest != null) {
+                                    this.evalResult = null;
+                                    try {
+                                        evalResult = do_eval(cx, evalFrame,
+                                                             evalRequest);
+                                    } finally {
+                                        evalRequest = null;
+                                        evalFrame = null;
+                                        monitor.notify();
+                                    }
+                                    continue;
+                                }
+                                if (this.returnValue != -1) {
+                                    returnValue = this.returnValue;
+                                    break;
+                                }
+                            }
+                        } finally {
+                            insideInterruptLoop = false;
+                        }
+                    }
+                } else {
+                    this.returnValue = -1;
+                    callback.enterInterrupt(frame, threadTitle, alertMessage);
+                    while (this.returnValue == -1) {
+                        try {
+                            callback.dispatchNextGuiEvent();
+                        } catch (InterruptedException exc) {
+                        }
+                    }
+                    returnValue = this.returnValue;
+                }
+                switch (returnValue) {
+                case STEP_OVER:
+                    contextData.breakNextLine = true;
+                    contextData.stopAtFrameDepth = contextData.frameCount();
+                    break;
+                case STEP_INTO:
+                    contextData.breakNextLine = true;
+                    contextData.stopAtFrameDepth = -1;
+                    break;
+                case STEP_OUT:
+                    if (contextData.frameCount() > 1) {
+                        contextData.breakNextLine = true;
+                        contextData.stopAtFrameDepth
+                            = contextData.frameCount() -1;
+                    }
+                    break;
+                }
+            } while (false);
+        } finally {
+            synchronized (eventThreadMonitor) {
+                interruptedContextData = null;
+                eventThreadMonitor.notifyAll();
+            }
+        }
+
+    }
+
+    /**
+     * Evaluates script in the given stack frame.
+     */
+    private static String do_eval(Context cx, StackFrame frame, String expr) {
+        String resultString;
+        Debugger saved_debugger = cx.getDebugger();
+        Object saved_data = cx.getDebuggerContextData();
+        int saved_level = cx.getOptimizationLevel();
+
+        cx.setDebugger(null, null);
+        cx.setOptimizationLevel(-1);
+        cx.setGeneratingDebug(false);
+        try {
+            Callable script = (Callable)cx.compileString(expr, "", 0, null);
+            Object result = script.call(cx, frame.scope, frame.thisObj,
+                                        ScriptRuntime.emptyArgs);
+            if (result == Undefined.instance) {
+                resultString = "";
+            } else {
+                resultString = ScriptRuntime.toString(result);
+            }
+        } catch (Exception exc) {
+            resultString = exc.getMessage();
+        } finally {
+            cx.setGeneratingDebug(true);
+            cx.setOptimizationLevel(saved_level);
+            cx.setDebugger(saved_debugger, saved_data);
+        }
+        if (resultString == null) {
+            resultString = "null";
+        }
+        return resultString;
+    }
+
+    /**
+     * Proxy class to implement debug interfaces without bloat of class
+     * files.
+     */
+    private static class DimIProxy
+        implements ContextAction, ContextFactory.Listener, Debugger {
+
+        /**
+         * The debugger.
+         */
+        private Dim dim;
+
+        /**
+         * The interface implementation type.  One of the IPROXY_* constants
+         * defined in {@link Dim}.
+         */
+        private int type;
+
+        /**
+         * The URL origin of the script to compile or evaluate.
+         */
+        private String url;
+
+        /**
+         * The text of the script to compile, evaluate or test for compilation.
+         */
+        private String text;
+
+        /**
+         * The object to convert, get a property from or enumerate.
+         */
+        private Object object;
+
+        /**
+         * The property to look up in {@link #object}.
+         */
+        private Object id;
+
+        /**
+         * The boolean result of the action.
+         */
+        private boolean booleanResult;
+
+        /**
+         * The String result of the action.
+         */
+        private String stringResult;
+
+        /**
+         * The Object result of the action.
+         */
+        private Object objectResult;
+
+        /**
+         * The Object[] result of the action.
+         */
+        private Object[] objectArrayResult;
+
+        /**
+         * Creates a new DimIProxy.
+         */
+        private DimIProxy(Dim dim, int type) {
+            this.dim = dim;
+            this.type = type;
+        }
+
+        // ContextAction
+
+        /**
+         * Performs the action given by {@link #type}.
+         */
+        public Object run(Context cx) {
+            switch (type) {
+              case IPROXY_COMPILE_SCRIPT:
+                cx.compileString(text, url, 1, null);
+                break;
+
+              case IPROXY_EVAL_SCRIPT:
+                {
+                    Scriptable scope = null;
+                    if (dim.scopeProvider != null) {
+                        scope = dim.scopeProvider.getScope();
+                    }
+                    if (scope == null) {
+                        scope = new ImporterTopLevel(cx);
+                    }
+                    cx.evaluateString(scope, text, url, 1, null);
+                }
+                break;
+
+              case IPROXY_STRING_IS_COMPILABLE:
+                booleanResult = cx.stringIsCompilableUnit(text);
+                break;
+
+              case IPROXY_OBJECT_TO_STRING:
+                if (object == Undefined.instance) {
+                    stringResult = "undefined";
+                } else if (object == null) {
+                    stringResult = "null";
+                } else if (object instanceof NativeCall) {
+                    stringResult = "[object Call]";
+                } else {
+                    stringResult = Context.toString(object);
+                }
+                break;
+
+              case IPROXY_OBJECT_PROPERTY:
+                objectResult = dim.getObjectPropertyImpl(cx, object, id);
+                break;
+
+              case IPROXY_OBJECT_IDS:
+                objectArrayResult = dim.getObjectIdsImpl(cx, object);
+                break;
+
+              default:
+                throw Kit.codeBug();
+            }
+            return null;
+        }
+
+        /**
+         * Performs the action given by {@link #type} with the attached
+         * {@link ContextFactory}.
+         */
+        private void withContext() {
+            dim.contextFactory.call(this);
+        }
+
+        // ContextFactory.Listener
+
+        /**
+         * Called when a Context is created.
+         */
+        public void contextCreated(Context cx) {
+            if (type != IPROXY_LISTEN) Kit.codeBug();
+            ContextData contextData = new ContextData();
+            Debugger debugger = new DimIProxy(dim, IPROXY_DEBUG);
+            cx.setDebugger(debugger, contextData);
+            cx.setGeneratingDebug(true);
+            cx.setOptimizationLevel(-1);
+        }
+
+        /**
+         * Called when a Context is destroyed.
+         */
+        public void contextReleased(Context cx) {
+            if (type != IPROXY_LISTEN) Kit.codeBug();
+        }
+
+        // Debugger
+
+        /**
+         * Returns a StackFrame for the given function or script.
+         */
+        public DebugFrame getFrame(Context cx, DebuggableScript fnOrScript) {
+            if (type != IPROXY_DEBUG) Kit.codeBug();
+
+            FunctionSource item = dim.getFunctionSource(fnOrScript);
+            if (item == null) {
+                // Can not debug if source is not available
+                return null;
+            }
+            return new StackFrame(cx, dim, item);
+        }
+
+        /**
+         * Called when compilation is finished.
+         */
+        public void handleCompilationDone(Context cx,
+                                          DebuggableScript fnOrScript,
+                                          String source) {
+            if (type != IPROXY_DEBUG) Kit.codeBug();
+
+            if (!fnOrScript.isTopLevel()) {
+                return;
+            }
+            dim.registerTopScript(fnOrScript, source);
+        }
+    }
+
+    /**
+     * Class to store information about a stack.
+     */
+    public static class ContextData {
+
+        /**
+         * The stack frames.
+         */
+        private ObjArray frameStack = new ObjArray();
+
+        /**
+         * Whether the debugger should break at the next line in this context.
+         */
+        private boolean breakNextLine;
+
+        /**
+         * The frame depth the debugger should stop at.  Used to implement
+         * "step over" and "step out".
+         */
+        private int stopAtFrameDepth = -1;
+
+        /**
+         * Whether this context is in the event thread.
+         */
+        private boolean eventThreadFlag;
+
+        /**
+         * The last exception that was processed.
+         */
+        private Throwable lastProcessedException;
+
+        /**
+         * Returns the ContextData for the given Context.
+         */
+        public static ContextData get(Context cx) {
+            return (ContextData) cx.getDebuggerContextData();
+        }
+
+        /**
+         * Returns the number of stack frames.
+         */
+        public int frameCount() {
+            return frameStack.size();
+        }
+
+        /**
+         * Returns the stack frame with the given index.
+         */
+        public StackFrame getFrame(int frameNumber) {
+            int num = frameStack.size() - frameNumber - 1;
+            return (StackFrame) frameStack.get(num);
+        }
+
+        /**
+         * Pushes a stack frame on to the stack.
+         */
+        private void pushFrame(StackFrame frame) {
+            frameStack.push(frame);
+        }
+
+        /**
+         * Pops a stack frame from the stack.
+         */
+        private void popFrame() {
+            frameStack.pop();
+        }
+    }
+
+    /**
+     * Object to represent one stack frame.
+     */
+    public static class StackFrame implements DebugFrame {
+
+        /**
+         * The debugger.
+         */
+        private Dim dim;
+
+        /**
+         * The ContextData for the Context being debugged.
+         */
+        private ContextData contextData;
+
+        /**
+         * The scope.
+         */
+        private Scriptable scope;
+
+        /**
+         * The 'this' object.
+         */
+        private Scriptable thisObj;
+
+        /**
+         * Information about the function.
+         */
+        private FunctionSource fsource;
+
+        /**
+         * Array of breakpoint state for each source line.
+         */
+        private boolean[] breakpoints;
+
+        /**
+         * Current line number.
+         */
+        private int lineNumber;
+
+        /**
+         * Creates a new StackFrame.
+         */
+        private StackFrame(Context cx, Dim dim, FunctionSource fsource) {
+            this.dim = dim;
+            this.contextData = ContextData.get(cx);
+            this.fsource = fsource;
+            this.breakpoints = fsource.sourceInfo().breakpoints;
+            this.lineNumber = fsource.firstLine();
+        }
+
+        /**
+         * Called when the stack frame is entered.
+         */
+        public void onEnter(Context cx, Scriptable scope,
+                            Scriptable thisObj, Object[] args) {
+            contextData.pushFrame(this);
+            this.scope = scope;
+            this.thisObj = thisObj;
+            if (dim.breakOnEnter) {
+                dim.handleBreakpointHit(this, cx);
+            }
+        }
+
+        /**
+         * Called when the current position has changed.
+         */
+        public void onLineChange(Context cx, int lineno) {
+            this.lineNumber = lineno;
+
+            if (!breakpoints[lineno] && !dim.breakFlag) {
+                boolean lineBreak = contextData.breakNextLine;
+                if (lineBreak && contextData.stopAtFrameDepth >= 0) {
+                    lineBreak = (contextData.frameCount()
+                                 <= contextData.stopAtFrameDepth);
+                }
+                if (!lineBreak) {
+                    return;
+                }
+                contextData.stopAtFrameDepth = -1;
+                contextData.breakNextLine = false;
+            }
+
+            dim.handleBreakpointHit(this, cx);
+        }
+
+        /**
+         * Called when an exception has been thrown.
+         */
+        public void onExceptionThrown(Context cx, Throwable exception) {
+            dim.handleExceptionThrown(cx, exception, this);
+        }
+
+        /**
+         * Called when the stack frame has been left.
+         */
+        public void onExit(Context cx, boolean byThrow,
+                           Object resultOrException) {
+            if (dim.breakOnReturn && !byThrow) {
+                dim.handleBreakpointHit(this, cx);
+            }
+            contextData.popFrame();
+        }
+
+        /**
+         * Called when a 'debugger' statement is executed.
+         */
+        public void onDebuggerStatement(Context cx) {
+            dim.handleBreakpointHit(this, cx);
+        }
+
+        /**
+         * Returns the SourceInfo object for the function.
+         */
+        public SourceInfo sourceInfo() {
+            return fsource.sourceInfo();
+        }
+
+        /**
+         * Returns the ContextData object for the Context.
+         */
+        public ContextData contextData() {
+            return contextData;
+        }
+
+        /**
+         * Returns the scope object for this frame.
+         */
+        public Object scope() {
+            return scope;
+        }
+
+        /**
+         * Returns the 'this' object for this frame.
+         */
+        public Object thisObj() {
+            return thisObj;
+        }
+
+        /**
+         * Returns the source URL.
+         */
+        public String getUrl() {
+            return fsource.sourceInfo().url();
+        }
+
+        /**
+         * Returns the current line number.
+         */
+        public int getLineNumber() {
+            return lineNumber;
+        }
+    }
+
+    /**
+     * Class to store information about a function.
+     */
+    public static class FunctionSource {
+
+        /**
+         * Information about the source of the function.
+         */
+        private SourceInfo sourceInfo;
+
+        /**
+         * Line number of the first line of the function.
+         */
+        private int firstLine;
+
+        /**
+         * The function name.
+         */
+        private String name;
+
+        /**
+         * Creates a new FunctionSource.
+         */
+        private FunctionSource(SourceInfo sourceInfo, int firstLine,
+                                 String name) {
+            if (name == null) throw new IllegalArgumentException();
+            this.sourceInfo = sourceInfo;
+            this.firstLine = firstLine;
+            this.name = name;
+        }
+
+        /**
+         * Returns the SourceInfo object that describes the source of the
+         * function.
+         */
+        public SourceInfo sourceInfo() {
+            return sourceInfo;
+        }
+
+        /**
+         * Returns the line number of the first line of the function.
+         */
+        public int firstLine() {
+            return firstLine;
+        }
+
+        /**
+         * Returns the name of the function.
+         */
+        public String name() {
+            return name;
+        }
+    }
+
+    /**
+     * Class to store information about a script source.
+     */
+    public static class SourceInfo {
+
+        /**
+         * An empty array of booleans.
+         */
+        private static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
+
+        /**
+         * The script.
+         */
+        private String source;
+
+        /**
+         * The URL of the script.
+         */
+        private String url;
+
+        /**
+         * Array indicating which lines can have breakpoints set.
+         */
+        private boolean[] breakableLines;
+        
+        /**
+         * Array indicating whether a breakpoint is set on the line.
+         */
+        private boolean[] breakpoints;
+
+        /**
+         * Array of FunctionSource objects for the functions in the script.
+         */
+        private FunctionSource[] functionSources;
+
+        /**
+         * Creates a new SourceInfo object.
+         */
+        private SourceInfo(String source, DebuggableScript[] functions,
+                             String normilizedUrl) {
+            this.source = source;
+            this.url = normilizedUrl;
+
+            int N = functions.length;
+            int[][] lineArrays = new int[N][];
+            for (int i = 0; i != N; ++i) {
+                lineArrays[i] = functions[i].getLineNumbers();
+            }
+
+            int minAll = 0, maxAll = -1;
+            int[] firstLines = new int[N];
+            for (int i = 0; i != N; ++i) {
+                int[] lines = lineArrays[i];
+                if (lines == null || lines.length == 0) {
+                    firstLines[i] = -1;
+                } else {
+                    int min, max;
+                    min = max = lines[0];
+                    for (int j = 1; j != lines.length; ++j) {
+                        int line = lines[j];
+                        if (line < min) {
+                            min = line;
+                        } else if (line > max) {
+                            max = line;
+                        }
+                    }
+                    firstLines[i] = min;
+                    if (minAll > maxAll) {
+                        minAll = min;
+                        maxAll = max;
+                    } else {
+                        if (min < minAll) {
+                            minAll = min;
+                        }
+                        if (max > maxAll) {
+                            maxAll = max;
+                        }
+                    }
+                }
+            }
+
+            if (minAll > maxAll) {
+                // No line information
+                this.breakableLines = EMPTY_BOOLEAN_ARRAY;
+                this.breakpoints = EMPTY_BOOLEAN_ARRAY;
+            } else {
+                if (minAll < 0) {
+                    // Line numbers can not be negative
+                    throw new IllegalStateException(String.valueOf(minAll));
+                }
+                int linesTop = maxAll + 1;
+                this.breakableLines = new boolean[linesTop];
+                this.breakpoints = new boolean[linesTop];
+                for (int i = 0; i != N; ++i) {
+                    int[] lines = lineArrays[i];
+                    if (lines != null && lines.length != 0) {
+                        for (int j = 0; j != lines.length; ++j) {
+                            int line = lines[j];
+                            this.breakableLines[line] = true;
+                        }
+                    }
+                }
+            }
+            this.functionSources = new FunctionSource[N];
+            for (int i = 0; i != N; ++i) {
+                String name = functions[i].getFunctionName();
+                if (name == null) {
+                    name = "";
+                }
+                this.functionSources[i]
+                    = new FunctionSource(this, firstLines[i], name);
+            }
+        }
+
+        /**
+         * Returns the source text.
+         */
+        public String source() {
+            return this.source;
+        }
+
+        /**
+         * Returns the script's origin URL.
+         */
+        public String url() {
+            return this.url;
+        }
+
+        /**
+         * Returns the number of FunctionSource objects stored in this object.
+         */
+        public int functionSourcesTop() {
+            return functionSources.length;
+        }
+
+        /**
+         * Returns the FunctionSource object with the given index.
+         */
+        public FunctionSource functionSource(int i) {
+            return functionSources[i];
+        }
+
+        /**
+         * Copies the breakpoints from the given SourceInfo object into this
+         * one.
+         */
+        private void copyBreakpointsFrom(SourceInfo old) {
+            int end = old.breakpoints.length;
+            if (end > this.breakpoints.length) {
+                end = this.breakpoints.length;
+            }
+            for (int line = 0; line != end; ++line) {
+                if (old.breakpoints[line]) {
+                    this.breakpoints[line] = true;
+                }
+            }
+        }
+
+        /**
+         * Returns whether the given line number can have a breakpoint set on
+         * it.
+         */
+        public boolean breakableLine(int line) {
+            return (line < this.breakableLines.length)
+                   && this.breakableLines[line];
+        }
+
+        /**
+         * Returns whether there is a breakpoint set on the given line.
+         */
+        public boolean breakpoint(int line) {
+            if (!breakableLine(line)) {
+                throw new IllegalArgumentException(String.valueOf(line));
+            }
+            return line < this.breakpoints.length && this.breakpoints[line];
+        }
+
+        /**
+         * Sets or clears the breakpoint flag for the given line.
+         */
+        public boolean breakpoint(int line, boolean value) {
+            if (!breakableLine(line)) {
+                throw new IllegalArgumentException(String.valueOf(line));
+            }
+            boolean changed;
+            synchronized (breakpoints) {
+                if (breakpoints[line] != value) {
+                    breakpoints[line] = value;
+                    changed = true;
+                } else {
+                    changed = false;
+                }
+            }
+            return changed;
+        }
+
+        /**
+         * Removes all breakpoints from the script.
+         */
+        public void removeAllBreakpoints() {
+            synchronized (breakpoints) {
+                for (int line = 0; line != breakpoints.length; ++line) {
+                    breakpoints[line] = false;
+                }
+            }
+        }
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/GuiCallback.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/GuiCallback.java
new file mode 100644
index 0000000..f9762ec
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/GuiCallback.java
@@ -0,0 +1,71 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov, igor@fastmail.fm
+ *   Cameron McCormack
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.debugger;
+
+/**
+ * Interface for communication between the debugger and its GUI.  This
+ * should be implemented by the GUI.
+ */
+public interface GuiCallback {
+
+    /**
+     * Called when the source text of some script has been changed.
+     */
+    void updateSourceText(Dim.SourceInfo sourceInfo);
+
+    /**
+     * Called when the interrupt loop has been entered.
+     */
+    void enterInterrupt(Dim.StackFrame lastFrame,
+                        String threadTitle,
+                        String alertMessage);
+
+    /**
+     * Returns whether the current thread is the GUI's event thread.
+     * This information is required to avoid blocking the event thread
+     * from the debugger.
+     */
+    boolean isGuiEventThread();
+
+    /**
+     * Processes the next GUI event.  This manual pumping of GUI events
+     * is necessary when the GUI event thread itself has been stopped.
+     */
+    void dispatchNextGuiEvent() throws InterruptedException;
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Main.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Main.java
new file mode 100644
index 0000000..3f90915
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/Main.java
@@ -0,0 +1,431 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * SeeBeyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Matt Gould
+ *   Christopher Oliver
+ *   Cameron McCormack
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.debugger;
+
+import java.io.InputStream;
+import java.io.PrintStream;
+
+import javax.swing.JFrame;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.tools.shell.Global;
+
+/**
+ * Rhino script debugger main class.  This class links together a
+ * debugger object ({@link Dim}) and a debugger GUI object ({@link SwingGui}).
+ */
+public class Main {
+
+    /**
+     * The debugger.
+     */
+    private Dim dim;
+
+    /**
+     * The debugger frame.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * Creates a new Main.
+     */
+    public Main(String title) {
+        dim = new Dim();
+        debugGui = new SwingGui(dim, title);
+    }
+
+    /**
+     * Returns the debugger window {@link JFrame}.
+     */
+    public JFrame getDebugFrame() {
+        return debugGui;
+    }
+
+    /**
+     * Breaks execution of the script.
+     */
+    public void doBreak() {
+        dim.setBreak();
+    }
+
+    /**
+     * Sets whether execution should break when a script exception is thrown.
+     */
+    public void setBreakOnExceptions(boolean value) {
+        dim.setBreakOnExceptions(value);
+        debugGui.getMenubar().getBreakOnExceptions().setSelected(value);
+    }
+
+    /**
+     * Sets whether execution should break when a function is entered.
+     */
+    public void setBreakOnEnter(boolean value) {
+        dim.setBreakOnEnter(value);
+        debugGui.getMenubar().getBreakOnEnter().setSelected(value);
+    }
+
+    /**
+     * Sets whether execution should break when a function is left.
+     */
+    public void setBreakOnReturn(boolean value) {
+        dim.setBreakOnReturn(value);
+        debugGui.getMenubar().getBreakOnReturn().setSelected(value);
+    }
+
+    /**
+     * Removes all breakpoints.
+     */
+    public void clearAllBreakpoints() {
+        dim.clearAllBreakpoints();
+    }
+
+    /**
+     * Resumes execution of the script.
+     */
+    public void go() {
+        dim.go();
+    }
+
+    /**
+     * Sets the scope to be used for script evaluation.
+     */
+    public void setScope(Scriptable scope) {
+        setScopeProvider(IProxy.newScopeProvider(scope));
+    }
+
+    /**
+     * Sets the {@link ScopeProvider} that provides a scope to be used
+     * for script evaluation.
+     */
+    public void setScopeProvider(ScopeProvider p) {
+        dim.setScopeProvider(p);
+    }
+
+    /**
+     * Assign a Runnable object that will be invoked when the user
+     * selects "Exit..." or closes the Debugger main window.
+     */
+    public void setExitAction(Runnable r) {
+        debugGui.setExitAction(r);
+    }
+
+    /**
+     * Returns an {@link InputStream} for stdin from the debugger's internal
+     * Console window.
+     */
+    public InputStream getIn() {
+        return debugGui.getConsole().getIn();
+    }
+
+    /**
+     * Returns a {@link PrintStream} for stdout to the debugger's internal
+     * Console window.
+     */
+    public PrintStream getOut() {
+        return debugGui.getConsole().getOut();
+    }
+
+    /**
+     * Returns a {@link PrintStream} for stderr in the Debugger's internal
+     * Console window.
+     */
+    public PrintStream getErr() {
+        return debugGui.getConsole().getErr();
+    }
+
+    /**
+     * Packs the debugger GUI frame.
+     */
+    public void pack() {
+        debugGui.pack();
+    }
+
+    /**
+     * Sets the debugger GUI frame dimensions.
+     */
+    public void setSize(int w, int h) {
+        debugGui.setSize(w, h);
+    }
+
+    /**
+     * Sets the visibility of the debugger GUI frame.
+     */
+    public void setVisible(boolean flag) {
+        debugGui.setVisible(flag);
+    }
+
+    /**
+     * Returns whether the debugger GUI frame is visible.
+     */
+    public boolean isVisible() {
+        return debugGui.isVisible();
+    }
+
+    /**
+     * Frees any resources held by the debugger.
+     */
+    public void dispose() {
+        clearAllBreakpoints();
+        dim.go();
+        debugGui.dispose();
+        dim = null;
+    }
+
+    /**
+     * Attaches the debugger to the given {@link ContextFactory}.
+     */
+    public void attachTo(ContextFactory factory) {
+        dim.attachTo(factory);
+    }
+
+    /**
+     * Detaches from the current {@link ContextFactory}.
+     */
+    public void detach() {
+        dim.detach();
+    }
+
+    /**
+     * Main entry point.  Creates a debugger attached to a Rhino
+     * {@link org.mozilla.javascript.tools.shell.Main} shell session.
+     */
+    public static void main(String[] args) {
+        Main main = new Main("Rhino JavaScript Debugger");
+        main.doBreak();
+        main.setExitAction(new IProxy(IProxy.EXIT_ACTION));
+
+        System.setIn(main.getIn());
+        System.setOut(main.getOut());
+        System.setErr(main.getErr());
+
+        Global global = org.mozilla.javascript.tools.shell.Main.getGlobal();
+        global.setIn(main.getIn());
+        global.setOut(main.getOut());
+        global.setErr(main.getErr());
+
+        main.attachTo(
+            org.mozilla.javascript.tools.shell.Main.shellContextFactory);
+
+        main.setScope(global);
+
+        main.pack();
+        main.setSize(600, 460);
+        main.setVisible(true);
+
+        org.mozilla.javascript.tools.shell.Main.exec(args);
+    }
+
+    /**
+     * Entry point for embedded applications.  This method attaches
+     * to the global {@link ContextFactory} with a scope of a newly
+     * created {@link Global} object.  No I/O redirection is performed
+     * as with {@link #main(String[])}.
+     */
+    public static void mainEmbedded(String title) {
+        ContextFactory factory = ContextFactory.getGlobal();
+        Global global = new Global();
+        global.init(factory);
+        mainEmbedded(factory, global, title);
+    }
+
+    /**
+     * Entry point for embedded applications.  This method attaches
+     * to the given {@link ContextFactory} with the given scope.  No
+     * I/O redirection is performed as with {@link #main(String[])}.
+     */
+    public static void mainEmbedded(ContextFactory factory,
+                                    Scriptable scope,
+                                    String title) {
+        mainEmbeddedImpl(factory, scope, title);
+    }
+
+    /**
+     * Entry point for embedded applications.  This method attaches
+     * to the given {@link ContextFactory} with the given scope.  No
+     * I/O redirection is performed as with {@link #main(String[])}.
+     */
+    public static void mainEmbedded(ContextFactory factory,
+                                    ScopeProvider scopeProvider,
+                                    String title) {
+        mainEmbeddedImpl(factory, scopeProvider, title);
+    }
+
+    /**
+     * Helper method for {@link #mainEmbedded(String)}, etc.
+     */
+    private static void mainEmbeddedImpl(ContextFactory factory,
+                                         Object scopeProvider,
+                                         String title) {
+        if (title == null) {
+            title = "Rhino JavaScript Debugger (embedded usage)";
+        }
+        Main main = new Main(title);
+        main.doBreak();
+        main.setExitAction(new IProxy(IProxy.EXIT_ACTION));
+
+        main.attachTo(factory);
+        if (scopeProvider instanceof ScopeProvider) {
+            main.setScopeProvider((ScopeProvider)scopeProvider);
+        } else {
+            Scriptable scope = (Scriptable)scopeProvider;
+            if (scope instanceof Global) {
+                Global global = (Global)scope;
+                global.setIn(main.getIn());
+                global.setOut(main.getOut());
+                global.setErr(main.getErr());
+            }
+            main.setScope(scope);
+        }
+
+        main.pack();
+        main.setSize(600, 460);
+        main.setVisible(true);
+    }
+
+    // Deprecated methods
+
+    /**
+     * @deprecated Use {@link #setSize(int, int)} instead.
+     */
+    public void setSize(java.awt.Dimension dimension) {
+        debugGui.setSize(dimension.width, dimension.height);
+    }
+
+    /**
+     * @deprecated
+     * The method does nothing and is only present for compatibility.
+     */
+    public void setOptimizationLevel(int level) {
+    }
+
+    /**
+     * @deprecated
+     * The method is only present for compatibility and should not be called.
+     */
+    public void contextEntered(Context cx) {
+        throw new IllegalStateException();
+    }
+
+    /**
+     * @deprecated
+     * The method is only present for compatibility and should not be called.
+     */
+    public void contextExited(Context cx) {
+        throw new IllegalStateException();
+    }
+
+    /**
+     * @deprecated
+     * The method is only present for compatibility and should not be called.
+     */
+    public void contextCreated(Context cx) {
+        throw new IllegalStateException();
+    }
+
+    /**
+     * @deprecated
+     * The method is only present for compatibility and should not be called.
+     */
+    public void contextReleased(Context cx)
+    {
+        throw new IllegalStateException();
+    }
+
+    /**
+     * Class to consolidate all internal implementations of interfaces
+     * to avoid class generation bloat.
+     */
+    private static class IProxy implements Runnable, ScopeProvider {
+
+        // Constants for 'type'.
+        public static final int EXIT_ACTION = 1;
+        public static final int SCOPE_PROVIDER = 2;
+
+        /**
+         * The type of interface.
+         */
+        private final int type;
+
+        /**
+         * The scope object to expose when {@link #type} =
+         * {@link #SCOPE_PROVIDER}.
+         */
+        private Scriptable scope;
+
+        /**
+         * Creates a new IProxy.
+         */
+        public IProxy(int type) {
+            this.type = type;
+        }
+
+        /**
+         * Creates a new IProxy that acts as a {@link ScopeProvider}.
+         */
+        public static ScopeProvider newScopeProvider(Scriptable scope) {
+            IProxy scopeProvider = new IProxy(SCOPE_PROVIDER);
+            scopeProvider.scope = scope;
+            return scopeProvider;
+        }
+
+        // ContextAction
+
+        /**
+         * Exit action.
+         */
+        public void run() {
+            if (type != EXIT_ACTION) Kit.codeBug();
+            System.exit(0);
+        }
+
+        // ScopeProvider
+
+        /**
+         * Returns the scope for script evaluations.
+         */
+        public Scriptable getScope() {
+            if (type != SCOPE_PROVIDER) Kit.codeBug();
+            if (scope == null) Kit.codeBug();
+            return scope;
+        }
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/ScopeProvider.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/ScopeProvider.java
new file mode 100644
index 0000000..d8f65b9
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/ScopeProvider.java
@@ -0,0 +1,52 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * See Beyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Christopher Oliver
+ *   Cameron McCormack
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.debugger;
+
+import org.mozilla.javascript.Scriptable;
+
+/**
+ * Interface to provide a scope object for script evaluation to the debugger.
+ */
+public interface ScopeProvider {
+
+    /**
+     * Returns the scope object to be used for script evaluation.
+     */
+    Scriptable getScope();
+}
\ No newline at end of file
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/SwingGui.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/SwingGui.java
new file mode 100644
index 0000000..61dc065
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/SwingGui.java
@@ -0,0 +1,3547 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * SeeBeyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Matt Gould
+ *   Cameron McCormack
+ *   Christopher Oliver
+ *   Hannes Wallnoefer
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.debugger;
+
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.event.*;
+import javax.swing.table.*;
+import java.awt.*;
+import java.awt.event.*;
+
+import java.util.*;
+import java.io.*;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.TreePath;
+import java.lang.reflect.Method;
+
+import org.mozilla.javascript.Kit;
+import org.mozilla.javascript.SecurityUtilities;
+
+import org.mozilla.javascript.tools.shell.ConsoleTextArea;
+
+import org.mozilla.javascript.tools.debugger.downloaded.JTreeTable;
+import org.mozilla.javascript.tools.debugger.downloaded.TreeTableModel;
+import org.mozilla.javascript.tools.debugger.downloaded.TreeTableModelAdapter;
+
+/**
+ * GUI for the Rhino debugger.
+ */
+public class SwingGui extends JFrame implements GuiCallback {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -8217029773456711621L;
+
+    /**
+     * The debugger.
+     */
+    Dim dim;
+
+    /**
+     * The action to run when the 'Exit' menu item is chosen or the
+     * frame is closed.
+     */
+    private Runnable exitAction;
+
+    /**
+     * The {@link JDesktopPane} that holds the script windows.
+     */
+    private JDesktopPane desk;
+
+    /**
+     * The {@link JPanel} that shows information about the context.
+     */
+    private ContextWindow context;
+
+    /**
+     * The menu bar.
+     */
+    private Menubar menubar;
+
+    /**
+     * The tool bar.
+     */
+    private JToolBar toolBar;
+
+    /**
+     * The console that displays I/O from the script.
+     */
+    private JSInternalConsole console;
+
+    /**
+     * The {@link JSplitPane} that separates {@link #desk} from
+     * {@link org.mozilla.javascript.Context}.
+     */
+    private JSplitPane split1;
+
+    /**
+     * The status bar.
+     */
+    private JLabel statusBar;
+
+    /**
+     * Hash table of internal frame names to the internal frames themselves.
+     */
+    private Hashtable toplevels = new Hashtable();
+
+    /**
+     * Hash table of script URLs to their internal frames.
+     */
+    private Hashtable fileWindows = new Hashtable();
+
+    /**
+     * The {@link FileWindow} that last had the focus.
+     */
+    private FileWindow currentWindow;
+
+    /**
+     * File choose dialog for loading a script.
+     */
+    JFileChooser dlg;
+
+    /**
+     * The AWT EventQueue.  Used for manually pumping AWT events from
+     * {@link #dispatchNextGuiEvent()}.
+     */
+    private EventQueue awtEventQueue;
+
+    /**
+     * Creates a new SwingGui.
+     */
+    public SwingGui(Dim dim, String title) {
+        super(title);
+        this.dim = dim;
+        init();
+        dim.setGuiCallback(this);
+    }
+
+    /**
+     * Returns the Menubar of this debugger frame.
+     */
+    public Menubar getMenubar() {
+        return menubar;
+    }
+
+    /**
+     * Sets the {@link Runnable} that will be run when the "Exit" menu
+     * item is chosen.
+     */
+    public void setExitAction(Runnable r) {
+        exitAction = r;
+    }
+
+    /**
+     * Returns the debugger console component.
+     */
+    public JSInternalConsole getConsole() {
+        return console;
+    }
+
+    /**
+     * Sets the visibility of the debugger GUI.
+     */
+    public void setVisible(boolean b) {
+        super.setVisible(b);
+        if (b) {
+            // this needs to be done after the window is visible
+            console.consoleTextArea.requestFocus();
+            context.split.setDividerLocation(0.5);
+            try {
+                console.setMaximum(true);
+                console.setSelected(true);
+                console.show();
+                console.consoleTextArea.requestFocus();
+            } catch (Exception exc) {
+            }
+        }
+    }
+
+    /**
+     * Records a new internal frame.
+     */
+    void addTopLevel(String key, JFrame frame) {
+        if (frame != this) {
+            toplevels.put(key, frame);
+        }
+    }
+
+    /**
+     * Constructs the debugger GUI.
+     */
+    private void init() {
+        menubar = new Menubar(this);
+        setJMenuBar(menubar);
+        toolBar = new JToolBar();
+        JButton button;
+        JButton breakButton, goButton, stepIntoButton,
+            stepOverButton, stepOutButton;
+        String [] toolTips = {"Break (Pause)",
+                              "Go (F5)",
+                              "Step Into (F11)",
+                              "Step Over (F7)",
+                              "Step Out (F8)"};
+        int count = 0;
+        button = breakButton = new JButton("Break");
+        button.setToolTipText("Break");
+        button.setActionCommand("Break");
+        button.addActionListener(menubar);
+        button.setEnabled(true);
+        button.setToolTipText(toolTips[count++]);
+
+        button = goButton = new JButton("Go");
+        button.setToolTipText("Go");
+        button.setActionCommand("Go");
+        button.addActionListener(menubar);
+        button.setEnabled(false);
+        button.setToolTipText(toolTips[count++]);
+
+        button = stepIntoButton = new JButton("Step Into");
+        button.setToolTipText("Step Into");
+        button.setActionCommand("Step Into");
+        button.addActionListener(menubar);
+        button.setEnabled(false);
+        button.setToolTipText(toolTips[count++]);
+
+        button = stepOverButton = new JButton("Step Over");
+        button.setToolTipText("Step Over");
+        button.setActionCommand("Step Over");
+        button.setEnabled(false);
+        button.addActionListener(menubar);
+        button.setToolTipText(toolTips[count++]);
+
+        button = stepOutButton = new JButton("Step Out");
+        button.setToolTipText("Step Out");
+        button.setActionCommand("Step Out");
+        button.setEnabled(false);
+        button.addActionListener(menubar);
+        button.setToolTipText(toolTips[count++]);
+
+        Dimension dim = stepOverButton.getPreferredSize();
+        breakButton.setPreferredSize(dim);
+        breakButton.setMinimumSize(dim);
+        breakButton.setMaximumSize(dim);
+        breakButton.setSize(dim);
+        goButton.setPreferredSize(dim);
+        goButton.setMinimumSize(dim);
+        goButton.setMaximumSize(dim);
+        stepIntoButton.setPreferredSize(dim);
+        stepIntoButton.setMinimumSize(dim);
+        stepIntoButton.setMaximumSize(dim);
+        stepOverButton.setPreferredSize(dim);
+        stepOverButton.setMinimumSize(dim);
+        stepOverButton.setMaximumSize(dim);
+        stepOutButton.setPreferredSize(dim);
+        stepOutButton.setMinimumSize(dim);
+        stepOutButton.setMaximumSize(dim);
+        toolBar.add(breakButton);
+        toolBar.add(goButton);
+        toolBar.add(stepIntoButton);
+        toolBar.add(stepOverButton);
+        toolBar.add(stepOutButton);
+
+        JPanel contentPane = new JPanel();
+        contentPane.setLayout(new BorderLayout());
+        getContentPane().add(toolBar, BorderLayout.NORTH);
+        getContentPane().add(contentPane, BorderLayout.CENTER);
+        desk = new JDesktopPane();
+        desk.setPreferredSize(new Dimension(600, 300));
+        desk.setMinimumSize(new Dimension(150, 50));
+        desk.add(console = new JSInternalConsole("JavaScript Console"));
+        context = new ContextWindow(this);
+        context.setPreferredSize(new Dimension(600, 120));
+        context.setMinimumSize(new Dimension(50, 50));
+
+        split1 = new JSplitPane(JSplitPane.VERTICAL_SPLIT, desk,
+                                          context);
+        split1.setOneTouchExpandable(true);
+        SwingGui.setResizeWeight(split1, 0.66);
+        contentPane.add(split1, BorderLayout.CENTER);
+        statusBar = new JLabel();
+        statusBar.setText("Thread: ");
+        contentPane.add(statusBar, BorderLayout.SOUTH);
+        dlg = new JFileChooser();
+
+        javax.swing.filechooser.FileFilter filter =
+            new javax.swing.filechooser.FileFilter() {
+                    public boolean accept(File f) {
+                        if (f.isDirectory()) {
+                            return true;
+                        }
+                        String n = f.getName();
+                        int i = n.lastIndexOf('.');
+                        if (i > 0 && i < n.length() -1) {
+                            String ext = n.substring(i + 1).toLowerCase();
+                            if (ext.equals("js")) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+
+                    public String getDescription() {
+                        return "JavaScript Files (*.js)";
+                    }
+                };
+        dlg.addChoosableFileFilter(filter);
+        addWindowListener(new WindowAdapter() {
+                public void windowClosing(WindowEvent e) {
+                    exit();
+                }
+            });
+    }
+
+    /**
+     * Runs the {@link #exitAction}.
+     */
+    private void exit() {
+        if (exitAction != null) {
+            SwingUtilities.invokeLater(exitAction);
+        }
+        dim.setReturnValue(Dim.EXIT);
+    }
+
+    /**
+     * Returns the {@link FileWindow} for the given URL.
+     */
+    FileWindow getFileWindow(String url) {
+        if (url == null || url.equals("<stdin>")) {
+            return null;
+        }
+        return (FileWindow)fileWindows.get(url);
+    }
+
+    /**
+     * Returns a short version of the given URL.
+     */
+    static String getShortName(String url) {
+        int lastSlash = url.lastIndexOf('/');
+        if (lastSlash < 0) {
+            lastSlash = url.lastIndexOf('\\');
+        }
+        String shortName = url;
+        if (lastSlash >= 0 && lastSlash + 1 < url.length()) {
+            shortName = url.substring(lastSlash + 1);
+        }
+        return shortName;
+    }
+
+    /**
+     * Closes the given {@link FileWindow}.
+     */
+    void removeWindow(FileWindow w) {
+        fileWindows.remove(w.getUrl());
+        JMenu windowMenu = getWindowMenu();
+        int count = windowMenu.getItemCount();
+        JMenuItem lastItem = windowMenu.getItem(count -1);
+        String name = getShortName(w.getUrl());
+        for (int i = 5; i < count; i++) {
+            JMenuItem item = windowMenu.getItem(i);
+            if (item == null) continue; // separator
+            String text = item.getText();
+            //1 D:\foo.js
+            //2 D:\bar.js
+            int pos = text.indexOf(' ');
+            if (text.substring(pos + 1).equals(name)) {
+                windowMenu.remove(item);
+                // Cascade    [0]
+                // Tile       [1]
+                // -------    [2]
+                // Console    [3]
+                // -------    [4]
+                if (count == 6) {
+                    // remove the final separator
+                    windowMenu.remove(4);
+                } else {
+                    int j = i - 4;
+                    for (;i < count -1; i++) {
+                        JMenuItem thisItem = windowMenu.getItem(i);
+                        if (thisItem != null) {
+                            //1 D:\foo.js
+                            //2 D:\bar.js
+                            text = thisItem.getText();
+                            if (text.equals("More Windows...")) {
+                                break;
+                            } else {
+                                pos = text.indexOf(' ');
+                                thisItem.setText((char)('0' + j) + " " +
+                                                 text.substring(pos + 1));
+                                thisItem.setMnemonic('0' + j);
+                                j++;
+                            }
+                        }
+                    }
+                    if (count - 6 == 0 && lastItem != item) {
+                        if (lastItem.getText().equals("More Windows...")) {
+                            windowMenu.remove(lastItem);
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        windowMenu.revalidate();
+    }
+
+    /**
+     * Shows the line at which execution in the given stack frame just stopped.
+     */
+    void showStopLine(Dim.StackFrame frame) {
+        String sourceName = frame.getUrl();
+        if (sourceName == null || sourceName.equals("<stdin>")) {
+            if (console.isVisible()) {
+                console.show();
+            }
+        } else {
+            showFileWindow(sourceName, -1);
+            int lineNumber = frame.getLineNumber();
+            FileWindow w = getFileWindow(sourceName);
+            if (w != null) {
+                setFilePosition(w, lineNumber);
+            }
+        }
+    }
+
+    /**
+     * Shows a {@link FileWindow} for the given source, creating it
+     * if it doesn't exist yet. if <code>lineNumber</code> is greater
+     * than -1, it indicates the line number to select and display.
+     * @param sourceUrl the source URL
+     * @param lineNumber the line number to select, or -1
+     */
+    protected void showFileWindow(String sourceUrl, int lineNumber) {
+        FileWindow w = getFileWindow(sourceUrl);
+        if (w == null) {
+            Dim.SourceInfo si = dim.sourceInfo(sourceUrl);
+            createFileWindow(si, -1);
+            w = getFileWindow(sourceUrl);
+        }
+        if (lineNumber > -1) {
+            int start = w.getPosition(lineNumber-1);
+            int end = w.getPosition(lineNumber)-1;
+            w.textArea.select(start);
+            w.textArea.setCaretPosition(start);
+            w.textArea.moveCaretPosition(end);
+        }
+        try {
+            if (w.isIcon()) {
+                w.setIcon(false);
+            }
+            w.setVisible(true);
+            w.moveToFront();
+            w.setSelected(true);
+            requestFocus();
+            w.requestFocus();
+            w.textArea.requestFocus();
+        } catch (Exception exc) {
+        }
+    }
+
+    /**
+     * Creates and shows a new {@link FileWindow} for the given source.
+     */
+    protected void createFileWindow(Dim.SourceInfo sourceInfo, int line) {
+        boolean activate = true;
+
+        String url = sourceInfo.url();
+        FileWindow w = new FileWindow(this, sourceInfo);
+        fileWindows.put(url, w);
+        if (line != -1) {
+            if (currentWindow != null) {
+                currentWindow.setPosition(-1);
+            }
+            try {
+                w.setPosition(w.textArea.getLineStartOffset(line-1));
+            } catch (BadLocationException exc) {
+                try {
+                    w.setPosition(w.textArea.getLineStartOffset(0));
+                } catch (BadLocationException ee) {
+                    w.setPosition(-1);
+                }
+            }
+        }
+        desk.add(w);
+        if (line != -1) {
+            currentWindow = w;
+        }
+        menubar.addFile(url);
+        w.setVisible(true);
+
+        if (activate) {
+            try {
+                w.setMaximum(true);
+                w.setSelected(true);
+                w.moveToFront();
+            } catch (Exception exc) {
+            }
+        }
+    }
+
+    /**
+     * Update the source text for <code>sourceInfo</code>. This returns true
+     * if a {@link FileWindow} for the given source exists and could be updated.
+     * Otherwise, this does nothing and returns false.
+     * @param sourceInfo the source info
+     * @return true if a {@link FileWindow} for the given source exists
+     *              and could be updated, false otherwise.
+     */
+    protected boolean updateFileWindow(Dim.SourceInfo sourceInfo) {
+        String fileName = sourceInfo.url();
+        FileWindow w = getFileWindow(fileName);
+        if (w != null) {
+            w.updateText(sourceInfo);
+            w.show();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Moves the current position in the given {@link FileWindow} to the
+     * given line.
+     */
+    private void setFilePosition(FileWindow w, int line) {
+        boolean activate = true;
+        JTextArea ta = w.textArea;
+        try {
+            if (line == -1) {
+                w.setPosition(-1);
+                if (currentWindow == w) {
+                    currentWindow = null;
+                }
+            } else {
+                int loc = ta.getLineStartOffset(line-1);
+                if (currentWindow != null && currentWindow != w) {
+                    currentWindow.setPosition(-1);
+                }
+                w.setPosition(loc);
+                currentWindow = w;
+            }
+        } catch (BadLocationException exc) {
+            // fix me
+        }
+        if (activate) {
+            if (w.isIcon()) {
+                desk.getDesktopManager().deiconifyFrame(w);
+            }
+            desk.getDesktopManager().activateFrame(w);
+            try {
+                w.show();
+                w.toFront();  // required for correct frame layering (JDK 1.4.1)
+                w.setSelected(true);
+            } catch (Exception exc) {
+            }
+        }
+    }
+
+    /**
+     * Handles script interruption.
+     */
+    void enterInterruptImpl(Dim.StackFrame lastFrame,
+                            String threadTitle, String alertMessage) {
+        statusBar.setText("Thread: " + threadTitle);
+
+        showStopLine(lastFrame);
+
+        if (alertMessage != null) {
+            MessageDialogWrapper.showMessageDialog(this,
+                                                   alertMessage,
+                                                   "Exception in Script",
+                                                   JOptionPane.ERROR_MESSAGE);
+        }
+
+        updateEnabled(true);
+
+        Dim.ContextData contextData = lastFrame.contextData();
+
+        JComboBox ctx = context.context;
+        Vector toolTips = context.toolTips;
+        context.disableUpdate();
+        int frameCount = contextData.frameCount();
+        ctx.removeAllItems();
+        // workaround for JDK 1.4 bug that caches selected value even after
+        // removeAllItems() is called
+        ctx.setSelectedItem(null);
+        toolTips.removeAllElements();
+        for (int i = 0; i < frameCount; i++) {
+            Dim.StackFrame frame = contextData.getFrame(i);
+            String url = frame.getUrl();
+            int lineNumber = frame.getLineNumber();
+            String shortName = url;
+            if (url.length() > 20) {
+                shortName = "..." + url.substring(url.length() - 17);
+            }
+            String location = "\"" + shortName + "\", line " + lineNumber;
+            ctx.insertItemAt(location, i);
+            location = "\"" + url + "\", line " + lineNumber;
+            toolTips.addElement(location);
+        }
+        context.enableUpdate();
+        ctx.setSelectedIndex(0);
+        ctx.setMinimumSize(new Dimension(50, ctx.getMinimumSize().height));
+    }
+
+    /**
+     * Returns the 'Window' menu.
+     */
+    private JMenu getWindowMenu() {
+        return menubar.getMenu(3);
+    }
+
+    /**
+     * Displays a {@link JFileChooser} and returns the selected filename.
+     */
+    private String chooseFile(String title) {
+        dlg.setDialogTitle(title);
+        File CWD = null;
+        String dir = SecurityUtilities.getSystemProperty("user.dir");
+        if (dir != null) {
+            CWD = new File(dir);
+        }
+        if (CWD != null) {
+            dlg.setCurrentDirectory(CWD);
+        }
+        int returnVal = dlg.showOpenDialog(this);
+        if (returnVal == JFileChooser.APPROVE_OPTION) {
+            try {
+                String result = dlg.getSelectedFile().getCanonicalPath();
+                CWD = dlg.getSelectedFile().getParentFile();
+                Properties props = System.getProperties();
+                props.put("user.dir", CWD.getPath());
+                System.setProperties(props);
+                return result;
+            } catch (IOException ignored) {
+            } catch (SecurityException ignored) {
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns the current selected internal frame.
+     */
+    private JInternalFrame getSelectedFrame() {
+       JInternalFrame[] frames = desk.getAllFrames();
+       for (int i = 0; i < frames.length; i++) {
+           if (frames[i].isShowing()) {
+               return frames[i];
+           }
+       }
+       return frames[frames.length - 1];
+    }
+
+    /**
+     * Enables or disables the menu and tool bars with respect to the
+     * state of script execution.
+     */
+    private void updateEnabled(boolean interrupted) {
+        ((Menubar)getJMenuBar()).updateEnabled(interrupted);
+        for (int ci = 0, cc = toolBar.getComponentCount(); ci < cc; ci++) {
+            boolean enableButton;
+            if (ci == 0) {
+                // Break
+                enableButton = !interrupted;
+            } else {
+                enableButton = interrupted;
+            }
+            toolBar.getComponent(ci).setEnabled(enableButton);
+        }
+        if (interrupted) {
+            toolBar.setEnabled(true);
+            // raise the debugger window
+            int state = getExtendedState();
+            if (state == Frame.ICONIFIED) {
+                setExtendedState(Frame.NORMAL);
+            }
+            toFront();
+            context.enable();
+        } else {
+            if (currentWindow != null) currentWindow.setPosition(-1);
+            context.disable();
+        }
+    }
+
+    /**
+     * Calls {@link JSplitPane#setResizeWeight} via reflection.
+     * For compatibility, since JDK &lt; 1.3 does not have this method.
+     */
+    static void setResizeWeight(JSplitPane pane, double weight) {
+        try {
+            Method m = JSplitPane.class.getMethod("setResizeWeight",
+                                                  new Class[]{double.class});
+            m.invoke(pane, new Object[]{new Double(weight)});
+        } catch (NoSuchMethodException exc) {
+        } catch (IllegalAccessException exc) {
+        } catch (java.lang.reflect.InvocationTargetException exc) {
+        }
+    }
+
+    /**
+     * Reads the file with the given name and returns its contents as a String.
+     */
+    private String readFile(String fileName) {
+        String text;
+        try {
+            Reader r = new FileReader(fileName);
+            try {
+                text = Kit.readReader(r);
+            } finally {
+                r.close();
+            }
+        } catch (IOException ex) {
+            MessageDialogWrapper.showMessageDialog(this,
+                                                   ex.getMessage(),
+                                                   "Error reading "+fileName,
+                                                   JOptionPane.ERROR_MESSAGE);
+            text = null;
+        }
+        return text;
+    }
+
+    // GuiCallback
+
+    /**
+     * Called when the source text for a script has been updated.
+     */
+    public void updateSourceText(Dim.SourceInfo sourceInfo) {
+        RunProxy proxy = new RunProxy(this, RunProxy.UPDATE_SOURCE_TEXT);
+        proxy.sourceInfo = sourceInfo;
+        SwingUtilities.invokeLater(proxy);
+    }
+
+    /**
+     * Called when the interrupt loop has been entered.
+     */
+    public void enterInterrupt(Dim.StackFrame lastFrame,
+                               String threadTitle,
+                               String alertMessage) {
+        if (SwingUtilities.isEventDispatchThread()) {
+            enterInterruptImpl(lastFrame, threadTitle, alertMessage);
+        } else {
+            RunProxy proxy = new RunProxy(this, RunProxy.ENTER_INTERRUPT);
+            proxy.lastFrame = lastFrame;
+            proxy.threadTitle = threadTitle;
+            proxy.alertMessage = alertMessage;
+            SwingUtilities.invokeLater(proxy);
+        }
+    }
+
+    /**
+     * Returns whether the current thread is the GUI event thread.
+     */
+    public boolean isGuiEventThread() {
+        return SwingUtilities.isEventDispatchThread();
+    }
+
+    /**
+     * Processes the next GUI event.
+     */
+    public void dispatchNextGuiEvent() throws InterruptedException {
+        EventQueue queue = awtEventQueue;
+        if (queue == null) {
+            queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
+            awtEventQueue = queue;
+        }
+        AWTEvent event = queue.getNextEvent();
+        if (event instanceof ActiveEvent) {
+            ((ActiveEvent)event).dispatch();
+        } else {
+            Object source = event.getSource();
+            if (source instanceof Component) {
+                Component comp = (Component)source;
+                comp.dispatchEvent(event);
+            } else if (source instanceof MenuComponent) {
+                ((MenuComponent)source).dispatchEvent(event);
+            }
+        }
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action from the menu or toolbar.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        int returnValue = -1;
+        if (cmd.equals("Cut") || cmd.equals("Copy") || cmd.equals("Paste")) {
+            JInternalFrame f = getSelectedFrame();
+            if (f != null && f instanceof ActionListener) {
+                ((ActionListener)f).actionPerformed(e);
+            }
+        } else if (cmd.equals("Step Over")) {
+            returnValue = Dim.STEP_OVER;
+        } else if (cmd.equals("Step Into")) {
+            returnValue = Dim.STEP_INTO;
+        } else if (cmd.equals("Step Out")) {
+            returnValue = Dim.STEP_OUT;
+        } else if (cmd.equals("Go")) {
+            returnValue = Dim.GO;
+        } else if (cmd.equals("Break")) {
+            dim.setBreak();
+        } else if (cmd.equals("Exit")) {
+            exit();
+        } else if (cmd.equals("Open")) {
+            String fileName = chooseFile("Select a file to compile");
+            if (fileName != null) {
+                String text = readFile(fileName);
+                if (text != null) {
+                    RunProxy proxy = new RunProxy(this, RunProxy.OPEN_FILE);
+                    proxy.fileName = fileName;
+                    proxy.text = text;
+                    new Thread(proxy).start();
+                }
+            }
+        } else if (cmd.equals("Load")) {
+            String fileName = chooseFile("Select a file to execute");
+            if (fileName != null) {
+                String text = readFile(fileName);
+                if (text != null) {
+                    RunProxy proxy = new RunProxy(this, RunProxy.LOAD_FILE);
+                    proxy.fileName = fileName;
+                    proxy.text = text;
+                    new Thread(proxy).start();
+                }
+            }
+        } else if (cmd.equals("More Windows...")) {
+            MoreWindows dlg = new MoreWindows(this, fileWindows,
+                                              "Window", "Files");
+            dlg.showDialog(this);
+        } else if (cmd.equals("Console")) {
+            if (console.isIcon()) {
+                desk.getDesktopManager().deiconifyFrame(console);
+            }
+            console.show();
+            desk.getDesktopManager().activateFrame(console);
+            console.consoleTextArea.requestFocus();
+        } else if (cmd.equals("Cut")) {
+        } else if (cmd.equals("Copy")) {
+        } else if (cmd.equals("Paste")) {
+        } else if (cmd.equals("Go to function...")) {
+            FindFunction dlg = new FindFunction(this, "Go to function",
+                                                "Function");
+            dlg.showDialog(this);
+        } else if (cmd.equals("Tile")) {
+            JInternalFrame[] frames = desk.getAllFrames();
+            int count = frames.length;
+            int rows, cols;
+            rows = cols = (int)Math.sqrt(count);
+            if (rows*cols < count) {
+                cols++;
+                if (rows * cols < count) {
+                    rows++;
+                }
+            }
+            Dimension size = desk.getSize();
+            int w = size.width/cols;
+            int h = size.height/rows;
+            int x = 0;
+            int y = 0;
+            for (int i = 0; i < rows; i++) {
+                for (int j = 0; j < cols; j++) {
+                    int index = (i*cols) + j;
+                    if (index >= frames.length) {
+                        break;
+                    }
+                    JInternalFrame f = frames[index];
+                    try {
+                        f.setIcon(false);
+                        f.setMaximum(false);
+                    } catch (Exception exc) {
+                    }
+                    desk.getDesktopManager().setBoundsForFrame(f, x, y,
+                                                               w, h);
+                    x += w;
+                }
+                y += h;
+                x = 0;
+            }
+        } else if (cmd.equals("Cascade")) {
+            JInternalFrame[] frames = desk.getAllFrames();
+            int count = frames.length;
+            int x, y, w, h;
+            x = y = 0;
+            h = desk.getHeight();
+            int d = h / count;
+            if (d > 30) d = 30;
+            for (int i = count -1; i >= 0; i--, x += d, y += d) {
+                JInternalFrame f = frames[i];
+                try {
+                    f.setIcon(false);
+                    f.setMaximum(false);
+                } catch (Exception exc) {
+                }
+                Dimension dimen = f.getPreferredSize();
+                w = dimen.width;
+                h = dimen.height;
+                desk.getDesktopManager().setBoundsForFrame(f, x, y, w, h);
+            }
+        } else {
+            Object obj = getFileWindow(cmd);
+            if (obj != null) {
+                FileWindow w = (FileWindow)obj;
+                try {
+                    if (w.isIcon()) {
+                        w.setIcon(false);
+                    }
+                    w.setVisible(true);
+                    w.moveToFront();
+                    w.setSelected(true);
+                } catch (Exception exc) {
+                }
+            }
+        }
+        if (returnValue != -1) {
+            updateEnabled(false);
+            dim.setReturnValue(returnValue);
+        }
+    }
+}
+
+/**
+ * Helper class for showing a message dialog.
+ */
+class MessageDialogWrapper {
+
+    /**
+     * Shows a message dialog, wrapping the <code>msg</code> at 60
+     * columns.
+     */
+    public static void showMessageDialog(Component parent, String msg,
+                                         String title, int flags) {
+        if (msg.length() > 60) {
+            StringBuffer buf = new StringBuffer();
+            int len = msg.length();
+            int j = 0;
+            int i;
+            for (i = 0; i < len; i++, j++) {
+                char c = msg.charAt(i);
+                buf.append(c);
+                if (Character.isWhitespace(c)) {
+                    int k;
+                    for (k = i + 1; k < len; k++) {
+                        if (Character.isWhitespace(msg.charAt(k))) {
+                            break;
+                        }
+                    }
+                    if (k < len) {
+                        int nextWordLen = k - i;
+                        if (j + nextWordLen > 60) {
+                            buf.append('\n');
+                            j = 0;
+                        }
+                    }
+                }
+            }
+            msg = buf.toString();
+        }
+        JOptionPane.showMessageDialog(parent, msg, title, flags);
+    }
+}
+
+/**
+ * Extension of JTextArea for script evaluation input.
+ */
+class EvalTextArea
+    extends JTextArea
+    implements KeyListener, DocumentListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -3918033649601064194L;
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * History of expressions that have been evaluated
+     */
+    private Vector history;
+
+    /**
+     * Index of the selected history item.
+     */
+    private int historyIndex = -1;
+
+    /**
+     * Position in the display where output should go.
+     */
+    private int outputMark;
+
+    /**
+     * Creates a new EvalTextArea.
+     */
+    public EvalTextArea(SwingGui debugGui) {
+        this.debugGui = debugGui;
+        history = new java.util.Vector();
+        Document doc = getDocument();
+        doc.addDocumentListener(this);
+        addKeyListener(this);
+        setLineWrap(true);
+        setFont(new Font("Monospaced", 0, 12));
+        append("% ");
+        outputMark = doc.getLength();
+    }
+
+    /**
+     * Selects a subrange of the text.
+     */
+    public void select(int start, int end) {
+        //requestFocus();
+        super.select(start, end);
+    }
+
+    /**
+     * Called when Enter is pressed.
+     */
+    private synchronized void returnPressed() {
+        Document doc = getDocument();
+        int len = doc.getLength();
+        Segment segment = new Segment();
+        try {
+            doc.getText(outputMark, len - outputMark, segment);
+        } catch (javax.swing.text.BadLocationException ignored) {
+            ignored.printStackTrace();
+        }
+        String text = segment.toString();
+        if (debugGui.dim.stringIsCompilableUnit(text)) {
+            if (text.trim().length() > 0) {
+               history.addElement(text);
+               historyIndex = history.size();
+            }
+            append("\n");
+            String result = debugGui.dim.eval(text);
+            if (result.length() > 0) {
+                append(result);
+                append("\n");
+            }
+            append("% ");
+            outputMark = doc.getLength();
+        } else {
+            append("\n");
+        }
+    }
+
+    /**
+     * Writes output into the text area.
+     */
+    public synchronized void write(String str) {
+        insert(str, outputMark);
+        int len = str.length();
+        outputMark += len;
+        select(outputMark, outputMark);
+    }
+
+    // KeyListener
+
+    /**
+     * Called when a key is pressed.
+     */
+    public void keyPressed(KeyEvent e) {
+        int code = e.getKeyCode();
+        if (code == KeyEvent.VK_BACK_SPACE || code == KeyEvent.VK_LEFT) {
+            if (outputMark == getCaretPosition()) {
+                e.consume();
+            }
+        } else if (code == KeyEvent.VK_HOME) {
+           int caretPos = getCaretPosition();
+           if (caretPos == outputMark) {
+               e.consume();
+           } else if (caretPos > outputMark) {
+               if (!e.isControlDown()) {
+                   if (e.isShiftDown()) {
+                       moveCaretPosition(outputMark);
+                   } else {
+                       setCaretPosition(outputMark);
+                   }
+                   e.consume();
+               }
+           }
+        } else if (code == KeyEvent.VK_ENTER) {
+            returnPressed();
+            e.consume();
+        } else if (code == KeyEvent.VK_UP) {
+            historyIndex--;
+            if (historyIndex >= 0) {
+                if (historyIndex >= history.size()) {
+                    historyIndex = history.size() -1;
+                }
+                if (historyIndex >= 0) {
+                    String str = (String)history.elementAt(historyIndex);
+                    int len = getDocument().getLength();
+                    replaceRange(str, outputMark, len);
+                    int caretPos = outputMark + str.length();
+                    select(caretPos, caretPos);
+                } else {
+                    historyIndex++;
+                }
+            } else {
+                historyIndex++;
+            }
+            e.consume();
+        } else if (code == KeyEvent.VK_DOWN) {
+            int caretPos = outputMark;
+            if (history.size() > 0) {
+                historyIndex++;
+                if (historyIndex < 0) {historyIndex = 0;}
+                int len = getDocument().getLength();
+                if (historyIndex < history.size()) {
+                    String str = (String)history.elementAt(historyIndex);
+                    replaceRange(str, outputMark, len);
+                    caretPos = outputMark + str.length();
+                } else {
+                    historyIndex = history.size();
+                    replaceRange("", outputMark, len);
+                }
+            }
+            select(caretPos, caretPos);
+            e.consume();
+        }
+    }
+
+    /**
+     * Called when a key is typed.
+     */
+    public void keyTyped(KeyEvent e) {
+        int keyChar = e.getKeyChar();
+        if (keyChar == 0x8 /* KeyEvent.VK_BACK_SPACE */) {
+            if (outputMark == getCaretPosition()) {
+                e.consume();
+            }
+        } else if (getCaretPosition() < outputMark) {
+            setCaretPosition(outputMark);
+        }
+    }
+
+    /**
+     * Called when a key is released.
+     */
+    public synchronized void keyReleased(KeyEvent e) {
+    }
+
+    // DocumentListener
+
+    /**
+     * Called when text was inserted into the text area.
+     */
+    public synchronized void insertUpdate(DocumentEvent e) {
+        int len = e.getLength();
+        int off = e.getOffset();
+        if (outputMark > off) {
+            outputMark += len;
+        }
+    }
+
+    /**
+     * Called when text was removed from the text area.
+     */
+    public synchronized void removeUpdate(DocumentEvent e) {
+        int len = e.getLength();
+        int off = e.getOffset();
+        if (outputMark > off) {
+            if (outputMark >= off + len) {
+                outputMark -= len;
+            } else {
+                outputMark = off;
+            }
+        }
+    }
+
+    /**
+     * Attempts to clean up the damage done by {@link #updateUI()}.
+     */
+    public synchronized void postUpdateUI() {
+        //requestFocus();
+        setCaret(getCaret());
+        select(outputMark, outputMark);
+    }
+
+    /**
+     * Called when text has changed in the text area.
+     */
+    public synchronized void changedUpdate(DocumentEvent e) {
+    }
+}
+
+/**
+ * An internal frame for evaluating script.
+ */
+class EvalWindow extends JInternalFrame implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -2860585845212160176L;
+
+    /**
+     * The text area into which expressions can be typed.
+     */
+    private EvalTextArea evalTextArea;
+
+    /**
+     * Creates a new EvalWindow.
+     */
+    public EvalWindow(String name, SwingGui debugGui) {
+        super(name, true, false, true, true);
+        evalTextArea = new EvalTextArea(debugGui);
+        evalTextArea.setRows(24);
+        evalTextArea.setColumns(80);
+        JScrollPane scroller = new JScrollPane(evalTextArea);
+        setContentPane(scroller);
+        //scroller.setPreferredSize(new Dimension(600, 400));
+        pack();
+        setVisible(true);
+    }
+
+    /**
+     * Sets whether the text area is enabled.
+     */
+    public void setEnabled(boolean b) {
+        super.setEnabled(b);
+        evalTextArea.setEnabled(b);
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action on the text area.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        if (cmd.equals("Cut")) {
+            evalTextArea.cut();
+        } else if (cmd.equals("Copy")) {
+            evalTextArea.copy();
+        } else if (cmd.equals("Paste")) {
+            evalTextArea.paste();
+        }
+    }
+}
+
+/**
+ * Internal frame for the console.
+ */
+class JSInternalConsole extends JInternalFrame implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -5523468828771087292L;
+
+    /**
+     * Creates a new JSInternalConsole.
+     */
+    public JSInternalConsole(String name) {
+        super(name, true, false, true, true);
+        consoleTextArea = new ConsoleTextArea(null);
+        consoleTextArea.setRows(24);
+        consoleTextArea.setColumns(80);
+        JScrollPane scroller = new JScrollPane(consoleTextArea);
+        setContentPane(scroller);
+        pack();
+        addInternalFrameListener(new InternalFrameAdapter() {
+                public void internalFrameActivated(InternalFrameEvent e) {
+                    // hack
+                    if (consoleTextArea.hasFocus()) {
+                        consoleTextArea.getCaret().setVisible(false);
+                        consoleTextArea.getCaret().setVisible(true);
+                    }
+                }
+            });
+    }
+
+    /**
+     * The console text area.
+     */
+    ConsoleTextArea consoleTextArea;
+
+    /**
+     * Returns the input stream of the console text area.
+     */
+    public InputStream getIn() {
+        return consoleTextArea.getIn();
+    }
+
+    /**
+     * Returns the output stream of the console text area.
+     */
+    public PrintStream getOut() {
+        return consoleTextArea.getOut();
+    }
+
+    /**
+     * Returns the error stream of the console text area.
+     */
+    public PrintStream getErr() {
+        return consoleTextArea.getErr();
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action on the text area.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        if (cmd.equals("Cut")) {
+            consoleTextArea.cut();
+        } else if (cmd.equals("Copy")) {
+            consoleTextArea.copy();
+        } else if (cmd.equals("Paste")) {
+            consoleTextArea.paste();
+        }
+    }
+}
+
+/**
+ * Popup menu class for right-clicking on {@link FileTextArea}s.
+ */
+class FilePopupMenu extends JPopupMenu {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 3589525009546013565L;
+
+    /**
+     * The popup x position.
+     */
+    int x;
+    
+    /**
+     * The popup y position.
+     */
+    int y;
+
+    /**
+     * Creates a new FilePopupMenu.
+     */
+    public FilePopupMenu(FileTextArea w) {
+        JMenuItem item;
+        add(item = new JMenuItem("Set Breakpoint"));
+        item.addActionListener(w);
+        add(item = new JMenuItem("Clear Breakpoint"));
+        item.addActionListener(w);
+        add(item = new JMenuItem("Run"));
+        item.addActionListener(w);
+    }
+
+    /**
+     * Displays the menu at the given coordinates.
+     */
+    public void show(JComponent comp, int x, int y) {
+        this.x = x;
+        this.y = y;
+        super.show(comp, x, y);
+    }
+}
+
+/**
+ * Text area to display script source.
+ */
+class FileTextArea
+    extends JTextArea
+    implements ActionListener, PopupMenuListener, KeyListener, MouseListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -25032065448563720L;
+
+    /**
+     * The owning {@link FileWindow}.
+     */
+    private FileWindow w;
+
+    /**
+     * The popup menu.
+     */
+    private FilePopupMenu popup;
+
+    /**
+     * Creates a new FileTextArea.
+     */
+    public FileTextArea(FileWindow w) {
+        this.w = w;
+        popup = new FilePopupMenu(this);
+        popup.addPopupMenuListener(this);
+        addMouseListener(this);
+        addKeyListener(this);
+        setFont(new Font("Monospaced", 0, 12));
+    }
+
+    /**
+     * Moves the selection to the given offset.
+     */
+    public void select(int pos) {
+        if (pos >= 0) {
+            try {
+                int line = getLineOfOffset(pos);
+                Rectangle rect = modelToView(pos);
+                if (rect == null) {
+                    select(pos, pos);
+                } else {
+                    try {
+                        Rectangle nrect =
+                            modelToView(getLineStartOffset(line + 1));
+                        if (nrect != null) {
+                            rect = nrect;
+                        }
+                    } catch (Exception exc) {
+                    }
+                    JViewport vp = (JViewport)getParent();
+                    Rectangle viewRect = vp.getViewRect();
+                    if (viewRect.y + viewRect.height > rect.y) {
+                        // need to scroll up
+                        select(pos, pos);
+                    } else {
+                        // need to scroll down
+                        rect.y += (viewRect.height - rect.height)/2;
+                        scrollRectToVisible(rect);
+                        select(pos, pos);
+                    }
+                }
+            } catch (BadLocationException exc) {
+                select(pos, pos);
+                //exc.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Checks if the popup menu should be shown.
+     */
+    private void checkPopup(MouseEvent e) {
+        if (e.isPopupTrigger()) {
+            popup.show(this, e.getX(), e.getY());
+        }
+    }
+
+    // MouseListener
+
+    /**
+     * Called when a mouse button is pressed.
+     */
+    public void mousePressed(MouseEvent e) {
+        checkPopup(e);
+    }
+
+    /**
+     * Called when the mouse is clicked.
+     */
+    public void mouseClicked(MouseEvent e) {
+        checkPopup(e);
+        requestFocus();
+        getCaret().setVisible(true);
+    }
+
+    /**
+     * Called when the mouse enters the component.
+     */
+    public void mouseEntered(MouseEvent e) {
+    }
+
+    /**
+     * Called when the mouse exits the component.
+     */
+    public void mouseExited(MouseEvent e) {
+    }
+
+    /**
+     * Called when a mouse button is released.
+     */
+    public void mouseReleased(MouseEvent e) {
+        checkPopup(e);
+    }
+
+    // PopupMenuListener
+
+    /**
+     * Called before the popup menu will become visible.
+     */
+    public void popupMenuWillBecomeVisible(PopupMenuEvent e) {
+    }
+
+    /**
+     * Called before the popup menu will become invisible.
+     */
+    public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {
+    }
+
+    /**
+     * Called when the popup menu is cancelled.
+     */
+    public void popupMenuCanceled(PopupMenuEvent e) {
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        int pos = viewToModel(new Point(popup.x, popup.y));
+        popup.setVisible(false);
+        String cmd = e.getActionCommand();
+        int line = -1;
+        try {
+            line = getLineOfOffset(pos);
+        } catch (Exception exc) {
+        }
+        if (cmd.equals("Set Breakpoint")) {
+            w.setBreakPoint(line + 1);
+        } else if (cmd.equals("Clear Breakpoint")) {
+            w.clearBreakPoint(line + 1);
+        } else if (cmd.equals("Run")) {
+            w.load();
+        }
+    }
+
+    // KeyListener
+
+    /**
+     * Called when a key is pressed.
+     */
+    public void keyPressed(KeyEvent e) {
+        switch (e.getKeyCode()) {
+        case KeyEvent.VK_BACK_SPACE:
+        case KeyEvent.VK_ENTER:
+        case KeyEvent.VK_DELETE:
+        case KeyEvent.VK_TAB:
+            e.consume();
+            break;
+        }
+    }
+
+    /**
+     * Called when a key is typed.
+     */
+    public void keyTyped(KeyEvent e) {
+        e.consume();
+    }
+
+    /**
+     * Called when a key is released.
+     */
+    public void keyReleased(KeyEvent e) {
+        e.consume();
+    }
+}
+
+/**
+ * Dialog to list the available windows.
+ */
+class MoreWindows extends JDialog implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 5177066296457377546L;
+
+    /**
+     * Last selected value.
+     */
+    private String value;
+
+    /**
+     * The list component.
+     */
+    private JList list;
+
+    /**
+     * Our parent frame.
+     */
+    private SwingGui swingGui;
+
+    /**
+     * The "Select" button.
+     */
+    private JButton setButton;
+
+    /**
+     * The "Cancel" button.
+     */
+    private JButton cancelButton;
+
+    /**
+     * Creates a new MoreWindows.
+     */
+    MoreWindows(SwingGui frame, Hashtable fileWindows, String title,
+                String labelText) {
+        super(frame, title, true);
+        this.swingGui = frame;
+        //buttons
+        cancelButton = new JButton("Cancel");
+        setButton = new JButton("Select");
+        cancelButton.addActionListener(this);
+        setButton.addActionListener(this);
+        getRootPane().setDefaultButton(setButton);
+
+        //dim part of the dialog
+        list = new JList(new DefaultListModel());
+        DefaultListModel model = (DefaultListModel)list.getModel();
+        model.clear();
+        //model.fireIntervalRemoved(model, 0, size);
+        Enumeration e = fileWindows.keys();
+        while (e.hasMoreElements()) {
+            String data = e.nextElement().toString();
+            model.addElement(data);
+        }
+        list.setSelectedIndex(0);
+        //model.fireIntervalAdded(model, 0, data.length);
+        setButton.setEnabled(true);
+        list.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
+        list.addMouseListener(new MouseHandler());
+        JScrollPane listScroller = new JScrollPane(list);
+        listScroller.setPreferredSize(new Dimension(320, 240));
+        //XXX: Must do the following, too, or else the scroller thinks
+        //XXX: it's taller than it is:
+        listScroller.setMinimumSize(new Dimension(250, 80));
+        listScroller.setAlignmentX(LEFT_ALIGNMENT);
+
+        //Create a container so that we can add a title around
+        //the scroll pane.  Can't add a title directly to the
+        //scroll pane because its background would be white.
+        //Lay out the label and scroll pane from top to button.
+        JPanel listPane = new JPanel();
+        listPane.setLayout(new BoxLayout(listPane, BoxLayout.Y_AXIS));
+        JLabel label = new JLabel(labelText);
+        label.setLabelFor (list);
+        listPane.add(label);
+        listPane.add(Box.createRigidArea(new Dimension(0,5)));
+        listPane.add(listScroller);
+        listPane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
+
+        //Lay out the buttons from left to right.
+        JPanel buttonPane = new JPanel();
+        buttonPane.setLayout(new BoxLayout(buttonPane, BoxLayout.X_AXIS));
+        buttonPane.setBorder(BorderFactory.createEmptyBorder(0, 10, 10, 10));
+        buttonPane.add(Box.createHorizontalGlue());
+        buttonPane.add(cancelButton);
+        buttonPane.add(Box.createRigidArea(new Dimension(10, 0)));
+        buttonPane.add(setButton);
+
+        //Put everything together, using the content pane's BorderLayout.
+        Container contentPane = getContentPane();
+        contentPane.add(listPane, BorderLayout.CENTER);
+        contentPane.add(buttonPane, BorderLayout.SOUTH);
+        pack();
+        addKeyListener(new KeyAdapter() {
+                public void keyPressed(KeyEvent ke) {
+                    int code = ke.getKeyCode();
+                    if (code == KeyEvent.VK_ESCAPE) {
+                        ke.consume();
+                        value = null;
+                        setVisible(false);
+                    }
+                }
+            });
+    }
+
+    /**
+     * Shows the dialog.
+     */
+    public String showDialog(Component comp) {
+        value = null;
+        setLocationRelativeTo(comp);
+        setVisible(true);
+        return value;
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        if (cmd.equals("Cancel")) {
+            setVisible(false);
+            value = null;
+        } else if (cmd.equals("Select")) {
+            value = (String)list.getSelectedValue();
+            setVisible(false);
+            swingGui.showFileWindow(value, -1);
+        }
+    }
+
+    /**
+     * MouseListener implementation for {@link #list}.
+     */
+    private class MouseHandler extends MouseAdapter {
+        public void mouseClicked(MouseEvent e) {
+            if (e.getClickCount() == 2) {
+                setButton.doClick();
+            }
+        }
+    }
+}
+
+/**
+ * Find function dialog.
+ */
+class FindFunction extends JDialog implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 559491015232880916L;
+
+    /**
+     * Last selected function.
+     */
+    private String value;
+
+    /**
+     * List of functions.
+     */
+    private JList list;
+
+    /**
+     * The debug GUI frame.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * The "Select" button.
+     */
+    private JButton setButton;
+
+    /**
+     * The "Cancel" button.
+     */
+    private JButton cancelButton;
+
+    /**
+     * Creates a new FindFunction.
+     */
+    public FindFunction(SwingGui debugGui, String title, String labelText) {
+        super(debugGui, title, true);
+        this.debugGui = debugGui;
+
+        cancelButton = new JButton("Cancel");
+        setButton = new JButton("Select");
+        cancelButton.addActionListener(this);
+        setButton.addActionListener(this);
+        getRootPane().setDefaultButton(setButton);
+
+        list = new JList(new DefaultListModel());
+        DefaultListModel model = (DefaultListModel)list.getModel();
+        model.clear();
+
+        String[] a = debugGui.dim.functionNames();
+        java.util.Arrays.sort(a);
+        for (int i = 0; i < a.length; i++) {
+            model.addElement(a[i]);
+        }
+        list.setSelectedIndex(0);
+
+        setButton.setEnabled(a.length > 0);
+        list.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
+        list.addMouseListener(new MouseHandler());
+        JScrollPane listScroller = new JScrollPane(list);
+        listScroller.setPreferredSize(new Dimension(320, 240));
+        listScroller.setMinimumSize(new Dimension(250, 80));
+        listScroller.setAlignmentX(LEFT_ALIGNMENT);
+
+        //Create a container so that we can add a title around
+        //the scroll pane.  Can't add a title directly to the
+        //scroll pane because its background would be white.
+        //Lay out the label and scroll pane from top to button.
+        JPanel listPane = new JPanel();
+        listPane.setLayout(new BoxLayout(listPane, BoxLayout.Y_AXIS));
+        JLabel label = new JLabel(labelText);
+        label.setLabelFor (list);
+        listPane.add(label);
+        listPane.add(Box.createRigidArea(new Dimension(0,5)));
+        listPane.add(listScroller);
+        listPane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
+
+        //Lay out the buttons from left to right.
+        JPanel buttonPane = new JPanel();
+        buttonPane.setLayout(new BoxLayout(buttonPane, BoxLayout.X_AXIS));
+        buttonPane.setBorder(BorderFactory.createEmptyBorder(0, 10, 10, 10));
+        buttonPane.add(Box.createHorizontalGlue());
+        buttonPane.add(cancelButton);
+        buttonPane.add(Box.createRigidArea(new Dimension(10, 0)));
+        buttonPane.add(setButton);
+
+        //Put everything together, using the content pane's BorderLayout.
+        Container contentPane = getContentPane();
+        contentPane.add(listPane, BorderLayout.CENTER);
+        contentPane.add(buttonPane, BorderLayout.SOUTH);
+        pack();
+        addKeyListener(new KeyAdapter() {
+                public void keyPressed(KeyEvent ke) {
+                    int code = ke.getKeyCode();
+                    if (code == KeyEvent.VK_ESCAPE) {
+                        ke.consume();
+                        value = null;
+                        setVisible(false);
+                    }
+                }
+            });
+    }
+
+    /**
+     * Shows the dialog.
+     */
+    public String showDialog(Component comp) {
+        value = null;
+        setLocationRelativeTo(comp);
+        setVisible(true);
+        return value;
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        if (cmd.equals("Cancel")) {
+            setVisible(false);
+            value = null;
+        } else if (cmd.equals("Select")) {
+            if (list.getSelectedIndex() < 0) {
+                return;
+            }
+            try {
+                value = (String)list.getSelectedValue();
+            } catch (ArrayIndexOutOfBoundsException exc) {
+                return;
+            }
+            setVisible(false);
+            Dim.FunctionSource item = debugGui.dim.functionSourceByName(value);
+            if (item != null) {
+                Dim.SourceInfo si = item.sourceInfo();
+                String url = si.url();
+                int lineNumber = item.firstLine();
+                debugGui.showFileWindow(url, lineNumber);
+            }
+        }
+    }
+
+    /**
+     * MouseListener implementation for {@link #list}.
+     */
+    class MouseHandler extends MouseAdapter {
+        public void mouseClicked(MouseEvent e) {
+            if (e.getClickCount() == 2) {
+                setButton.doClick();
+            }
+        }
+    }
+}
+
+/**
+ * Gutter for FileWindows.
+ */
+class FileHeader extends JPanel implements MouseListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -2858905404778259127L;
+
+    /**
+     * The line that the mouse was pressed on.
+     */
+    private int pressLine = -1;
+
+    /**
+     * The owning FileWindow.
+     */
+    private FileWindow fileWindow;
+
+    /**
+     * Creates a new FileHeader.
+     */
+    public FileHeader(FileWindow fileWindow) {
+        this.fileWindow = fileWindow;
+        addMouseListener(this);
+        update();
+    }
+
+    /**
+     * Updates the gutter.
+     */
+    public void update() {
+        FileTextArea textArea = fileWindow.textArea;
+        Font font = textArea.getFont();
+        setFont(font);
+        FontMetrics metrics = getFontMetrics(font);
+        int h = metrics.getHeight();
+        int lineCount = textArea.getLineCount() + 1;
+        String dummy = Integer.toString(lineCount);
+        if (dummy.length() < 2) {
+            dummy = "99";
+        }
+        Dimension d = new Dimension();
+        d.width = metrics.stringWidth(dummy) + 16;
+        d.height = lineCount * h + 100;
+        setPreferredSize(d);
+        setSize(d);
+    }
+
+    /**
+     * Paints the component.
+     */
+    public void paint(Graphics g) {
+        super.paint(g);
+        FileTextArea textArea = fileWindow.textArea;
+        Font font = textArea.getFont();
+        g.setFont(font);
+        FontMetrics metrics = getFontMetrics(font);
+        Rectangle clip = g.getClipBounds();
+        g.setColor(getBackground());
+        g.fillRect(clip.x, clip.y, clip.width, clip.height);
+        int ascent = metrics.getMaxAscent();
+        int h = metrics.getHeight();
+        int lineCount = textArea.getLineCount() + 1;
+        String dummy = Integer.toString(lineCount);
+        if (dummy.length() < 2) {
+            dummy = "99";
+        }
+        int startLine = clip.y / h;
+        int endLine = (clip.y + clip.height) / h + 1;
+        int width = getWidth();
+        if (endLine > lineCount) endLine = lineCount;
+        for (int i = startLine; i < endLine; i++) {
+            String text;
+            int pos = -2;
+            try {
+                pos = textArea.getLineStartOffset(i);
+            } catch (BadLocationException ignored) {
+            }
+            boolean isBreakPoint = fileWindow.isBreakPoint(i + 1);
+            text = Integer.toString(i + 1) + " ";
+            int y = i * h;
+            g.setColor(Color.blue);
+            g.drawString(text, 0, y + ascent);
+            int x = width - ascent;
+            if (isBreakPoint) {
+                g.setColor(new Color(0x80, 0x00, 0x00));
+                int dy = y + ascent - 9;
+                g.fillOval(x, dy, 9, 9);
+                g.drawOval(x, dy, 8, 8);
+                g.drawOval(x, dy, 9, 9);
+            }
+            if (pos == fileWindow.currentPos) {
+                Polygon arrow = new Polygon();
+                int dx = x;
+                y += ascent - 10;
+                int dy = y;
+                arrow.addPoint(dx, dy + 3);
+                arrow.addPoint(dx + 5, dy + 3);
+                for (x = dx + 5; x <= dx + 10; x++, y++) {
+                    arrow.addPoint(x, y);
+                }
+                for (x = dx + 9; x >= dx + 5; x--, y++) {
+                    arrow.addPoint(x, y);
+                }
+                arrow.addPoint(dx + 5, dy + 7);
+                arrow.addPoint(dx, dy + 7);
+                g.setColor(Color.yellow);
+                g.fillPolygon(arrow);
+                g.setColor(Color.black);
+                g.drawPolygon(arrow);
+            }
+        }
+    }
+
+    // MouseListener
+
+    /**
+     * Called when the mouse enters the component.
+     */
+    public void mouseEntered(MouseEvent e) {
+    }
+    
+    /**
+     * Called when a mouse button is pressed.
+     */
+    public void mousePressed(MouseEvent e) {
+        Font font = fileWindow.textArea.getFont();
+        FontMetrics metrics = getFontMetrics(font);
+        int h = metrics.getHeight();
+        pressLine = e.getY() / h;
+    }
+
+    /**
+     * Called when the mouse is clicked.
+     */
+    public void mouseClicked(MouseEvent e) {
+    }
+
+    /**
+     * Called when the mouse exits the component.
+     */
+    public void mouseExited(MouseEvent e) {
+    }
+
+    /**
+     * Called when a mouse button is released.
+     */
+    public void mouseReleased(MouseEvent e) {
+        if (e.getComponent() == this
+                && (e.getModifiers() & MouseEvent.BUTTON1_MASK) != 0) {
+            int y = e.getY();
+            Font font = fileWindow.textArea.getFont();
+            FontMetrics metrics = getFontMetrics(font);
+            int h = metrics.getHeight();
+            int line = y/h;
+            if (line == pressLine) {
+                fileWindow.toggleBreakPoint(line + 1);
+            } else {
+                pressLine = -1;
+            }
+        }
+    }
+}
+
+/**
+ * An internal frame for script files.
+ */
+class FileWindow extends JInternalFrame implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = -6212382604952082370L;
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * The SourceInfo object that describes the file.
+     */
+    private Dim.SourceInfo sourceInfo;
+
+    /**
+     * The FileTextArea that displays the file.
+     */
+    FileTextArea textArea;
+
+    /**
+     * The FileHeader that is the gutter for {@link #textArea}.
+     */
+    private FileHeader fileHeader;
+    
+    /**
+     * Scroll pane for containing {@link #textArea}.
+     */
+    private JScrollPane p;
+
+    /**
+     * The current offset position.
+     */
+    int currentPos;
+
+    /**
+     * Loads the file.
+     */
+    void load() {
+        String url = getUrl();
+        if (url != null) {
+            RunProxy proxy = new RunProxy(debugGui, RunProxy.LOAD_FILE);
+            proxy.fileName = url;
+            proxy.text = sourceInfo.source();
+            new Thread(proxy).start();
+        }
+    }
+
+    /**
+     * Returns the offset position for the given line.
+     */
+    public int getPosition(int line) {
+        int result = -1;
+        try {
+            result = textArea.getLineStartOffset(line);
+        } catch (javax.swing.text.BadLocationException exc) {
+        }
+        return result;
+    }
+
+    /**
+     * Returns whether the given line has a breakpoint.
+     */
+    public boolean isBreakPoint(int line) {
+        return sourceInfo.breakableLine(line) && sourceInfo.breakpoint(line);
+    }
+
+    /**
+     * Toggles the breakpoint on the given line.
+     */
+    public void toggleBreakPoint(int line) {
+        if (!isBreakPoint(line)) {
+            setBreakPoint(line);
+        } else {
+            clearBreakPoint(line);
+        }
+    }
+
+    /**
+     * Sets a breakpoint on the given line.
+     */
+    public void setBreakPoint(int line) {
+        if (sourceInfo.breakableLine(line)) {
+            boolean changed = sourceInfo.breakpoint(line, true);
+            if (changed) {
+                fileHeader.repaint();
+            }
+        }
+    }
+
+    /**
+     * Clears a breakpoint from the given line.
+     */
+    public void clearBreakPoint(int line) {
+        if (sourceInfo.breakableLine(line)) {
+            boolean changed = sourceInfo.breakpoint(line, false);
+            if (changed) {
+                fileHeader.repaint();
+            }
+        }
+    }
+
+    /**
+     * Creates a new FileWindow.
+     */
+    public FileWindow(SwingGui debugGui, Dim.SourceInfo sourceInfo) {
+        super(SwingGui.getShortName(sourceInfo.url()),
+              true, true, true, true);
+        this.debugGui = debugGui;
+        this.sourceInfo = sourceInfo;
+        updateToolTip();
+        currentPos = -1;
+        textArea = new FileTextArea(this);
+        textArea.setRows(24);
+        textArea.setColumns(80);
+        p = new JScrollPane();
+        fileHeader = new FileHeader(this);
+        p.setViewportView(textArea);
+        p.setRowHeaderView(fileHeader);
+        setContentPane(p);
+        pack();
+        updateText(sourceInfo);
+        textArea.select(0);
+    }
+
+    /**
+     * Updates the tool tip contents.
+     */
+    private void updateToolTip() {
+        // Try to set tool tip on frame. On Mac OS X 10.5,
+        // the number of components is different, so try to be safe.
+        int n = getComponentCount() - 1;
+        if (n > 1) {
+            n = 1;
+        } else if (n < 0) {
+            return;
+        }
+        Component c = getComponent(n);
+        // this will work at least for Metal L&F
+        if (c != null && c instanceof JComponent) {
+            ((JComponent)c).setToolTipText(getUrl());
+        }
+    }
+
+    /**
+     * Returns the URL of the source.
+     */
+    public String getUrl() {
+        return sourceInfo.url();
+    }
+
+    /**
+     * Called when the text of the script has changed.
+     */
+    public void updateText(Dim.SourceInfo sourceInfo) {
+        this.sourceInfo = sourceInfo;
+        String newText = sourceInfo.source();
+        if (!textArea.getText().equals(newText)) {
+            textArea.setText(newText);
+            int pos = 0;
+            if (currentPos != -1) {
+                pos = currentPos;
+            }
+            textArea.select(pos);
+        }
+        fileHeader.update();
+        fileHeader.repaint();
+    }
+
+    /**
+     * Sets the cursor position.
+     */
+    public void setPosition(int pos) {
+        textArea.select(pos);
+        currentPos = pos;
+        fileHeader.repaint();
+    }
+
+    /**
+     * Selects a range of characters.
+     */
+    public void select(int start, int end) {
+        int docEnd = textArea.getDocument().getLength();
+        textArea.select(docEnd, docEnd);
+        textArea.select(start, end);
+    }
+
+    /**
+     * Disposes this FileWindow.
+     */
+    public void dispose() {
+        debugGui.removeWindow(this);
+        super.dispose();
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        if (cmd.equals("Cut")) {
+            // textArea.cut();
+        } else if (cmd.equals("Copy")) {
+            textArea.copy();
+        } else if (cmd.equals("Paste")) {
+            // textArea.paste();
+        }
+    }
+}
+
+/**
+ * Table model class for watched expressions.
+ */
+class MyTableModel extends AbstractTableModel {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 2971618907207577000L;
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * Vector of watched expressions.
+     */
+    private Vector expressions;
+
+    /**
+     * Vector of values from evaluated from {@link #expressions}.
+     */
+    private Vector values;
+
+    /**
+     * Creates a new MyTableModel.
+     */
+    public MyTableModel(SwingGui debugGui) {
+        this.debugGui = debugGui;
+        expressions = new Vector();
+        values = new Vector();
+        expressions.addElement("");
+        values.addElement("");
+    }
+
+    /**
+     * Returns the number of columns in the table (2).
+     */
+    public int getColumnCount() {
+        return 2;
+    }
+
+    /**
+     * Returns the number of rows in the table.
+     */
+    public int getRowCount() {
+        return expressions.size();
+    }
+
+    /**
+     * Returns the name of the given column.
+     */
+    public String getColumnName(int column) {
+        switch (column) {
+        case 0:
+            return "Expression";
+        case 1:
+            return "Value";
+        }
+        return null;
+    }
+
+    /**
+     * Returns whether the given cell is editable.
+     */
+    public boolean isCellEditable(int row, int column) {
+        return true;
+    }
+
+    /**
+     * Returns the value in the given cell.
+     */
+    public Object getValueAt(int row, int column) {
+        switch (column) {
+        case 0:
+            return expressions.elementAt(row);
+        case 1:
+            return values.elementAt(row);
+        }
+        return "";
+    }
+
+    /**
+     * Sets the value in the given cell.
+     */
+    public void setValueAt(Object value, int row, int column) {
+        switch (column) {
+        case 0:
+            String expr = value.toString();
+            expressions.setElementAt(expr, row);
+            String result = "";
+            if (expr.length() > 0) {
+                result = debugGui.dim.eval(expr);
+                if (result == null) result = "";
+            }
+            values.setElementAt(result, row);
+            updateModel();
+            if (row + 1 == expressions.size()) {
+                expressions.addElement("");
+                values.addElement("");
+                fireTableRowsInserted(row + 1, row + 1);
+            }
+            break;
+        case 1:
+            // just reset column 2; ignore edits
+            fireTableDataChanged();
+        }
+    }
+
+    /**
+     * Re-evaluates the expressions in the table.
+     */
+    void updateModel() {
+        for (int i = 0; i < expressions.size(); ++i) {
+            Object value = expressions.elementAt(i);
+            String expr = value.toString();
+            String result = "";
+            if (expr.length() > 0) {
+                result = debugGui.dim.eval(expr);
+                if (result == null) result = "";
+            } else {
+                result = "";
+            }
+            result = result.replace('\n', ' ');
+            values.setElementAt(result, i);
+        }
+        fireTableDataChanged();
+    }
+}
+
+/**
+ * A table for evaluated expressions.
+ */
+class Evaluator extends JTable {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 8133672432982594256L;
+
+    /**
+     * The {@link TableModel} for this table.
+     */
+    MyTableModel tableModel;
+
+    /**
+     * Creates a new Evaluator.
+     */
+    public Evaluator(SwingGui debugGui) {
+        super(new MyTableModel(debugGui));
+        tableModel = (MyTableModel)getModel();
+    }
+}
+
+/**
+ * Tree model for script object inspection.
+ */
+class VariableModel implements TreeTableModel {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final String[] cNames = { " Name", " Value" };
+
+    /**
+     * Tree column types.
+     */
+    private static final Class[] cTypes =
+        { TreeTableModel.class, String.class };
+
+    /**
+     * Empty {@link VariableNode} array.
+     */
+    private static final VariableNode[] CHILDLESS = new VariableNode[0];
+
+    /**
+     * The debugger.
+     */
+    private Dim debugger;
+
+    /**
+     * The root node.
+     */
+    private VariableNode root;
+
+    /**
+     * Creates a new VariableModel.
+     */
+    public VariableModel() {
+    }
+
+    /**
+     * Creates a new VariableModel.
+     */
+    public VariableModel(Dim debugger, Object scope) {
+        this.debugger = debugger;
+        this.root = new VariableNode(scope, "this");
+    }
+
+    // TreeTableModel
+
+    /**
+     * Returns the root node of the tree.
+     */
+    public Object getRoot() {
+        if (debugger == null) {
+            return null;
+        }
+        return root;
+    }
+
+    /**
+     * Returns the number of children of the given node.
+     */
+    public int getChildCount(Object nodeObj) {
+        if (debugger == null) {
+            return 0;
+        }
+        VariableNode node = (VariableNode) nodeObj;
+        return children(node).length;
+    }
+
+    /**
+     * Returns a child of the given node.
+     */
+    public Object getChild(Object nodeObj, int i) {
+        if (debugger == null) {
+            return null;
+        }
+        VariableNode node = (VariableNode) nodeObj;
+        return children(node)[i];
+    }
+
+    /**
+     * Returns whether the given node is a leaf node.
+     */
+    public boolean isLeaf(Object nodeObj) {
+        if (debugger == null) {
+            return true;
+        }
+        VariableNode node = (VariableNode) nodeObj;
+        return children(node).length == 0;
+    }
+
+    /**
+     * Returns the index of a node under its parent.
+     */
+    public int getIndexOfChild(Object parentObj, Object childObj) {
+        if (debugger == null) {
+            return -1;
+        }
+        VariableNode parent = (VariableNode) parentObj;
+        VariableNode child = (VariableNode) childObj;
+        VariableNode[] children = children(parent);
+        for (int i = 0; i != children.length; i++) {
+            if (children[i] == child) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * Returns whether the given cell is editable.
+     */
+    public boolean isCellEditable(Object node, int column) {
+        return column == 0;
+    }
+
+    /**
+     * Sets the value at the given cell.
+     */
+    public void setValueAt(Object value, Object node, int column) { }
+
+    /**
+     * Adds a TreeModelListener to this tree.
+     */
+    public void addTreeModelListener(TreeModelListener l) { }
+
+    /**
+     * Removes a TreeModelListener from this tree.
+     */
+    public void removeTreeModelListener(TreeModelListener l) { }
+
+    public void valueForPathChanged(TreePath path, Object newValue) { }
+
+    // TreeTableNode
+
+    /**
+     * Returns the number of columns.
+     */
+    public int getColumnCount() {
+        return cNames.length;
+    }
+
+    /**
+     * Returns the name of the given column.
+     */
+    public String getColumnName(int column) {
+        return cNames[column];
+    }
+
+    /**
+     * Returns the type of value stored in the given column.
+     */
+    public Class getColumnClass(int column) {
+        return cTypes[column];
+    }
+
+    /**
+     * Returns the value at the given cell.
+     */
+    public Object getValueAt(Object nodeObj, int column) {
+        if (debugger == null) { return null; }
+        VariableNode node = (VariableNode)nodeObj;
+        switch (column) {
+        case 0: // Name
+            return node.toString();
+        case 1: // Value
+            String result;
+            try {
+                result = debugger.objectToString(getValue(node));
+            } catch (RuntimeException exc) {
+                result = exc.getMessage();
+            }
+            StringBuffer buf = new StringBuffer();
+            int len = result.length();
+            for (int i = 0; i < len; i++) {
+                char ch = result.charAt(i);
+                if (Character.isISOControl(ch)) {
+                    ch = ' ';
+                }
+                buf.append(ch);
+            }
+            return buf.toString();
+        }
+        return null;
+    }
+
+    /**
+     * Returns an array of the children of the given node.
+     */
+    private VariableNode[] children(VariableNode node) {
+        if (node.children != null) {
+            return node.children;
+        }
+
+        VariableNode[] children;
+
+        Object value = getValue(node);
+        Object[] ids = debugger.getObjectIds(value);
+        if (ids == null || ids.length == 0) {
+            children = CHILDLESS;
+        } else {
+            Arrays.sort(ids, new Comparator() {
+                    public int compare(Object l, Object r)
+                    {
+                        if (l instanceof String) {
+                            if (r instanceof Integer) {
+                                return -1;
+                            }
+                            return ((String)l).compareToIgnoreCase((String)r);
+                        } else {
+                            if (r instanceof String) {
+                                return 1;
+                            }
+                            int lint = ((Integer)l).intValue();
+                            int rint = ((Integer)r).intValue();
+                            return lint - rint;
+                        }
+                    }
+            });
+            children = new VariableNode[ids.length];
+            for (int i = 0; i != ids.length; ++i) {
+                children[i] = new VariableNode(value, ids[i]);
+            }
+        }
+        node.children = children;
+        return children;
+    }
+
+    /**
+     * Returns the value of the given node.
+     */
+    public Object getValue(VariableNode node) {
+        try {
+            return debugger.getObjectProperty(node.object, node.id);
+        } catch (Exception exc) {
+            return "undefined";
+        }
+    }
+
+    /**
+     * A variable node in the tree.
+     */
+    private static class VariableNode {
+
+        /**
+         * The script object.
+         */
+        private Object object;
+
+        /**
+         * The object name.  Either a String or an Integer.
+         */
+        private Object id;
+
+        /**
+         * Array of child nodes.  This is filled with the properties of
+         * the object.
+         */
+        private VariableNode[] children;
+
+        /**
+         * Creates a new VariableNode.
+         */
+        public VariableNode(Object object, Object id) {
+            this.object = object;
+            this.id = id;
+        }
+
+        /**
+         * Returns a string representation of this node.
+         */
+        public String toString() {
+            return id instanceof String
+                ? (String) id : "[" + ((Integer) id).intValue() + "]";
+        }
+    }
+}
+
+/**
+ * A tree table for browsing script objects.
+ */
+class MyTreeTable extends JTreeTable {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 3457265548184453049L;
+
+    /**
+     * Creates a new MyTreeTable.
+     */
+    public MyTreeTable(VariableModel model) {
+        super(model);
+    }
+
+    /**
+     * Initializes a tree for this tree table.
+     */
+    public JTree resetTree(TreeTableModel treeTableModel) {
+        tree = new TreeTableCellRenderer(treeTableModel);
+
+        // Install a tableModel representing the visible rows in the tree.
+        super.setModel(new TreeTableModelAdapter(treeTableModel, tree));
+
+        // Force the JTable and JTree to share their row selection models.
+        ListToTreeSelectionModelWrapper selectionWrapper = new
+            ListToTreeSelectionModelWrapper();
+        tree.setSelectionModel(selectionWrapper);
+        setSelectionModel(selectionWrapper.getListSelectionModel());
+
+        // Make the tree and table row heights the same.
+        if (tree.getRowHeight() < 1) {
+            // Metal looks better like this.
+            setRowHeight(18);
+        }
+
+        // Install the tree editor renderer and editor.
+        setDefaultRenderer(TreeTableModel.class, tree);
+        setDefaultEditor(TreeTableModel.class, new TreeTableCellEditor());
+        setShowGrid(true);
+        setIntercellSpacing(new Dimension(1,1));
+        tree.setRootVisible(false);
+        tree.setShowsRootHandles(true);
+        DefaultTreeCellRenderer r = (DefaultTreeCellRenderer)tree.getCellRenderer();
+        r.setOpenIcon(null);
+        r.setClosedIcon(null);
+        r.setLeafIcon(null);
+        return tree;
+    }
+
+    /**
+     * Returns whether the cell under the coordinates of the mouse
+     * in the {@link EventObject} is editable.
+     */
+    public boolean isCellEditable(EventObject e) {
+        if (e instanceof MouseEvent) {
+            MouseEvent me = (MouseEvent)e;
+            // If the modifiers are not 0 (or the left mouse button),
+            // tree may try and toggle the selection, and table
+            // will then try and toggle, resulting in the
+            // selection remaining the same. To avoid this, we
+            // only dispatch when the modifiers are 0 (or the left mouse
+            // button).
+            if (me.getModifiers() == 0 ||
+                ((me.getModifiers() & (InputEvent.BUTTON1_MASK|1024)) != 0 &&
+                 (me.getModifiers() &
+                  (InputEvent.SHIFT_MASK |
+                   InputEvent.CTRL_MASK |
+                   InputEvent.ALT_MASK |
+                   InputEvent.BUTTON2_MASK |
+                   InputEvent.BUTTON3_MASK |
+                   64   | //SHIFT_DOWN_MASK
+                   128  | //CTRL_DOWN_MASK
+                   512  | // ALT_DOWN_MASK
+                   2048 | //BUTTON2_DOWN_MASK
+                   4096   //BUTTON3_DOWN_MASK
+                   )) == 0)) {
+                int row = rowAtPoint(me.getPoint());
+                for (int counter = getColumnCount() - 1; counter >= 0;
+                     counter--) {
+                    if (TreeTableModel.class == getColumnClass(counter)) {
+                        MouseEvent newME = new MouseEvent
+                            (MyTreeTable.this.tree, me.getID(),
+                             me.getWhen(), me.getModifiers(),
+                             me.getX() - getCellRect(row, counter, true).x,
+                             me.getY(), me.getClickCount(),
+                             me.isPopupTrigger());
+                        MyTreeTable.this.tree.dispatchEvent(newME);
+                        break;
+                    }
+                }
+            }
+            if (me.getClickCount() >= 3) {
+                return true;
+            }
+            return false;
+        }
+        if (e == null) {
+            return true;
+        }
+        return false;
+    }
+}
+
+/**
+ * Panel that shows information about the context.
+ */
+class ContextWindow extends JPanel implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 2306040975490228051L;
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * The combo box that holds the stack frames.
+     */
+    JComboBox context;
+
+    /**
+     * Tool tips for the stack frames.
+     */
+    Vector toolTips;
+
+    /**
+     * Tabbed pane for "this" and "locals".
+     */
+    private JTabbedPane tabs;
+
+    /**
+     * Tabbed pane for "watch" and "evaluate".
+     */
+    private JTabbedPane tabs2;
+
+    /**
+     * The table showing the "this" object.
+     */
+    private MyTreeTable thisTable;
+
+    /**
+     * The table showing the stack local variables.
+     */
+    private MyTreeTable localsTable;
+
+    /**
+     * The {@link #evaluator}'s table model.
+     */
+    private MyTableModel tableModel;
+
+    /**
+     * The script evaluator table.
+     */
+    private Evaluator evaluator;
+
+    /**
+     * The script evaluation text area.
+     */
+    private EvalTextArea cmdLine;
+
+    /**
+     * The split pane.
+     */
+    JSplitPane split;
+
+    /**
+     * Whether the ContextWindow is enabled.
+     */
+    private boolean enabled;
+
+    /**
+     * Creates a new ContextWindow.
+     */
+    public ContextWindow(final SwingGui debugGui) {
+        this.debugGui = debugGui;
+        enabled = false;
+        JPanel left = new JPanel();
+        JToolBar t1 = new JToolBar();
+        t1.setName("Variables");
+        t1.setLayout(new GridLayout());
+        t1.add(left);
+        JPanel p1 = new JPanel();
+        p1.setLayout(new GridLayout());
+        JPanel p2 = new JPanel();
+        p2.setLayout(new GridLayout());
+        p1.add(t1);
+        JLabel label = new JLabel("Context:");
+        context = new JComboBox();
+        context.setLightWeightPopupEnabled(false);
+        toolTips = new java.util.Vector();
+        label.setBorder(context.getBorder());
+        context.addActionListener(this);
+        context.setActionCommand("ContextSwitch");
+        GridBagLayout layout = new GridBagLayout();
+        left.setLayout(layout);
+        GridBagConstraints lc = new GridBagConstraints();
+        lc.insets.left = 5;
+        lc.anchor = GridBagConstraints.WEST;
+        lc.ipadx = 5;
+        layout.setConstraints(label, lc);
+        left.add(label);
+        GridBagConstraints c = new GridBagConstraints();
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        c.fill = GridBagConstraints.HORIZONTAL;
+        c.anchor = GridBagConstraints.WEST;
+        layout.setConstraints(context, c);
+        left.add(context);
+        tabs = new JTabbedPane(SwingConstants.BOTTOM);
+        tabs.setPreferredSize(new Dimension(500,300));
+        thisTable = new MyTreeTable(new VariableModel());
+        JScrollPane jsp = new JScrollPane(thisTable);
+        jsp.getViewport().setViewSize(new Dimension(5,2));
+        tabs.add("this", jsp);
+        localsTable = new MyTreeTable(new VariableModel());
+        localsTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+        localsTable.setPreferredSize(null);
+        jsp = new JScrollPane(localsTable);
+        tabs.add("Locals", jsp);
+        c.weightx  = c.weighty = 1;
+        c.gridheight = GridBagConstraints.REMAINDER;
+        c.fill = GridBagConstraints.BOTH;
+        c.anchor = GridBagConstraints.WEST;
+        layout.setConstraints(tabs, c);
+        left.add(tabs);
+        evaluator = new Evaluator(debugGui);
+        cmdLine = new EvalTextArea(debugGui);
+        //cmdLine.requestFocus();
+        tableModel = evaluator.tableModel;
+        jsp = new JScrollPane(evaluator);
+        JToolBar t2 = new JToolBar();
+        t2.setName("Evaluate");
+        tabs2 = new JTabbedPane(SwingConstants.BOTTOM);
+        tabs2.add("Watch", jsp);
+        tabs2.add("Evaluate", new JScrollPane(cmdLine));
+        tabs2.setPreferredSize(new Dimension(500,300));
+        t2.setLayout(new GridLayout());
+        t2.add(tabs2);
+        p2.add(t2);
+        evaluator.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+        split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
+                               p1, p2);
+        split.setOneTouchExpandable(true);
+        SwingGui.setResizeWeight(split, 0.5);
+        setLayout(new BorderLayout());
+        add(split, BorderLayout.CENTER);
+
+        final JToolBar finalT1 = t1;
+        final JToolBar finalT2 = t2;
+        final JPanel finalP1 = p1;
+        final JPanel finalP2 = p2;
+        final JSplitPane finalSplit = split;
+        final JPanel finalThis = this;
+
+        ComponentListener clistener = new ComponentListener() {
+                boolean t2Docked = true;
+                void check(Component comp) {
+                    Component thisParent = finalThis.getParent();
+                    if (thisParent == null) {
+                        return;
+                    }
+                    Component parent = finalT1.getParent();
+                    boolean leftDocked = true;
+                    boolean rightDocked = true;
+                    boolean adjustVerticalSplit = false;
+                    if (parent != null) {
+                        if (parent != finalP1) {
+                            while (!(parent instanceof JFrame)) {
+                                parent = parent.getParent();
+                            }
+                            JFrame frame = (JFrame)parent;
+                            debugGui.addTopLevel("Variables", frame);
+
+                            // We need the following hacks because:
+                            // - We want an undocked toolbar to be
+                            //   resizable.
+                            // - We are using JToolbar as a container of a
+                            //   JComboBox. Without this JComboBox's popup
+                            //   can get left floating when the toolbar is
+                            //   re-docked.
+                            //
+                            // We make the frame resizable and then
+                            // remove JToolbar's window listener
+                            // and insert one of our own that first ensures
+                            // the JComboBox's popup window is closed
+                            // and then calls JToolbar's window listener.
+                            if (!frame.isResizable()) {
+                                frame.setResizable(true);
+                                frame.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
+                                final EventListener[] l =
+                                    frame.getListeners(WindowListener.class);
+                                frame.removeWindowListener((WindowListener)l[0]);
+                                frame.addWindowListener(new WindowAdapter() {
+                                        public void windowClosing(WindowEvent e) {
+                                            context.hidePopup();
+                                            ((WindowListener)l[0]).windowClosing(e);
+                                        }
+                                    });
+                                //adjustVerticalSplit = true;
+                            }
+                            leftDocked = false;
+                        } else {
+                            leftDocked = true;
+                        }
+                    }
+                    parent = finalT2.getParent();
+                    if (parent != null) {
+                        if (parent != finalP2) {
+                            while (!(parent instanceof JFrame)) {
+                                parent = parent.getParent();
+                            }
+                            JFrame frame = (JFrame)parent;
+                            debugGui.addTopLevel("Evaluate", frame);
+                            frame.setResizable(true);
+                            rightDocked = false;
+                        } else {
+                            rightDocked = true;
+                        }
+                    }
+                    if (leftDocked && t2Docked && rightDocked && t2Docked) {
+                        // no change
+                        return;
+                    }
+                    t2Docked = rightDocked;
+                    JSplitPane split = (JSplitPane)thisParent;
+                    if (leftDocked) {
+                        if (rightDocked) {
+                            finalSplit.setDividerLocation(0.5);
+                        } else {
+                            finalSplit.setDividerLocation(1.0);
+                        }
+                        if (adjustVerticalSplit) {
+                            split.setDividerLocation(0.66);
+                        }
+
+                    } else if (rightDocked) {
+                            finalSplit.setDividerLocation(0.0);
+                            split.setDividerLocation(0.66);
+                    } else {
+                        // both undocked
+                        split.setDividerLocation(1.0);
+                    }
+                }
+                public void componentHidden(ComponentEvent e) {
+                    check(e.getComponent());
+                }
+                public void componentMoved(ComponentEvent e) {
+                    check(e.getComponent());
+                }
+                public void componentResized(ComponentEvent e) {
+                    check(e.getComponent());
+                }
+                public void componentShown(ComponentEvent e) {
+                    check(e.getComponent());
+                }
+            };
+        p1.addContainerListener(new ContainerListener() {
+            public void componentAdded(ContainerEvent e) {
+                Component thisParent = finalThis.getParent();
+                JSplitPane split = (JSplitPane)thisParent;
+                if (e.getChild() == finalT1) {
+                    if (finalT2.getParent() == finalP2) {
+                        // both docked
+                        finalSplit.setDividerLocation(0.5);
+                    } else {
+                        // left docked only
+                        finalSplit.setDividerLocation(1.0);
+                    }
+                    split.setDividerLocation(0.66);
+                }
+            }
+            public void componentRemoved(ContainerEvent e) {
+                Component thisParent = finalThis.getParent();
+                JSplitPane split = (JSplitPane)thisParent;
+                if (e.getChild() == finalT1) {
+                    if (finalT2.getParent() == finalP2) {
+                        // right docked only
+                        finalSplit.setDividerLocation(0.0);
+                        split.setDividerLocation(0.66);
+                    } else {
+                        // both undocked
+                        split.setDividerLocation(1.0);
+                    }
+                }
+            }
+            });
+        t1.addComponentListener(clistener);
+        t2.addComponentListener(clistener);
+        disable();
+    }
+
+    /**
+     * Disables the component.
+     */
+    public void disable() {
+        context.setEnabled(false);
+        thisTable.setEnabled(false);
+        localsTable.setEnabled(false);
+        evaluator.setEnabled(false);
+        cmdLine.setEnabled(false);
+    }
+
+    /**
+     * Enables the component.
+     */
+    public void enable() {
+        context.setEnabled(true);
+        thisTable.setEnabled(true);
+        localsTable.setEnabled(true);
+        evaluator.setEnabled(true);
+        cmdLine.setEnabled(true);
+    }
+
+    /**
+     * Disables updating of the component.
+     */
+    public void disableUpdate() {
+        enabled = false;
+    }
+
+    /**
+     * Enables updating of the component.
+     */
+    public void enableUpdate() {
+        enabled = true;
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        if (!enabled) return;
+        if (e.getActionCommand().equals("ContextSwitch")) {
+            Dim.ContextData contextData = debugGui.dim.currentContextData();
+            if (contextData == null) { return; }
+            int frameIndex = context.getSelectedIndex();
+            context.setToolTipText(toolTips.elementAt(frameIndex).toString());
+            int frameCount = contextData.frameCount();
+            if (frameIndex >= frameCount) {
+                return;
+            }
+            Dim.StackFrame frame = contextData.getFrame(frameIndex);
+            Object scope = frame.scope();
+            Object thisObj = frame.thisObj();
+            thisTable.resetTree(new VariableModel(debugGui.dim, thisObj));
+            VariableModel scopeModel;
+            if (scope != thisObj) {
+                scopeModel = new VariableModel(debugGui.dim, scope);
+            } else {
+                scopeModel = new VariableModel();
+            }
+            localsTable.resetTree(scopeModel);
+            debugGui.dim.contextSwitch(frameIndex);
+            debugGui.showStopLine(frame);
+            tableModel.updateModel();
+        }
+    }
+}
+
+/**
+ * The debugger frame menu bar.
+ */
+class Menubar extends JMenuBar implements ActionListener {
+
+    /**
+     * Serializable magic number.
+     */
+    private static final long serialVersionUID = 3217170497245911461L;
+
+    /**
+     * Items that are enabled only when interrupted.
+     */
+    private Vector interruptOnlyItems = new Vector();
+
+    /**
+     * Items that are enabled only when running.
+     */
+    private Vector runOnlyItems = new Vector();
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * The menu listing the internal frames.
+     */
+    private JMenu windowMenu;
+
+    /**
+     * The "Break on exceptions" menu item.
+     */
+    private JCheckBoxMenuItem breakOnExceptions;
+
+    /**
+     * The "Break on enter" menu item.
+     */
+    private JCheckBoxMenuItem breakOnEnter;
+
+    /**
+     * The "Break on return" menu item.
+     */
+    private JCheckBoxMenuItem breakOnReturn;
+
+    /**
+     * Creates a new Menubar.
+     */
+    Menubar(SwingGui debugGui) {
+        super();
+        this.debugGui = debugGui;
+        String[] fileItems  = {"Open...", "Run...", "", "Exit"};
+        String[] fileCmds  = {"Open", "Load", "", "Exit"};
+        char[] fileShortCuts = {'0', 'N', 0, 'X'};
+        int[] fileAccelerators = {KeyEvent.VK_O,
+                                  KeyEvent.VK_N,
+                                  0,
+                                  KeyEvent.VK_Q};
+        String[] editItems = {"Cut", "Copy", "Paste", "Go to function..."};
+        char[] editShortCuts = {'T', 'C', 'P', 'F'};
+        String[] debugItems = {"Break", "Go", "Step Into", "Step Over", "Step Out"};
+        char[] debugShortCuts = {'B', 'G', 'I', 'O', 'T'};
+        String[] plafItems = {"Metal", "Windows", "Motif"};
+        char [] plafShortCuts = {'M', 'W', 'F'};
+        int[] debugAccelerators = {KeyEvent.VK_PAUSE,
+                                   KeyEvent.VK_F5,
+                                   KeyEvent.VK_F11,
+                                   KeyEvent.VK_F7,
+                                   KeyEvent.VK_F8,
+                                   0, 0};
+
+        JMenu fileMenu = new JMenu("File");
+        fileMenu.setMnemonic('F');
+        JMenu editMenu = new JMenu("Edit");
+        editMenu.setMnemonic('E');
+        JMenu plafMenu = new JMenu("Platform");
+        plafMenu.setMnemonic('P');
+        JMenu debugMenu = new JMenu("Debug");
+        debugMenu.setMnemonic('D');
+        windowMenu = new JMenu("Window");
+        windowMenu.setMnemonic('W');
+        for (int i = 0; i < fileItems.length; ++i) {
+            if (fileItems[i].length() == 0) {
+                fileMenu.addSeparator();
+            } else {
+                JMenuItem item = new JMenuItem(fileItems[i],
+                                               fileShortCuts[i]);
+                item.setActionCommand(fileCmds[i]);
+                item.addActionListener(this);
+                fileMenu.add(item);
+                if (fileAccelerators[i] != 0) {
+                    KeyStroke k = KeyStroke.getKeyStroke(fileAccelerators[i], Event.CTRL_MASK);
+                    item.setAccelerator(k);
+                }
+            }
+        }
+        for (int i = 0; i < editItems.length; ++i) {
+            JMenuItem item = new JMenuItem(editItems[i],
+                                           editShortCuts[i]);
+            item.addActionListener(this);
+            editMenu.add(item);
+        }
+        for (int i = 0; i < plafItems.length; ++i) {
+            JMenuItem item = new JMenuItem(plafItems[i],
+                                           plafShortCuts[i]);
+            item.addActionListener(this);
+            plafMenu.add(item);
+        }
+        for (int i = 0; i < debugItems.length; ++i) {
+            JMenuItem item = new JMenuItem(debugItems[i],
+                                           debugShortCuts[i]);
+            item.addActionListener(this);
+            if (debugAccelerators[i] != 0) {
+                KeyStroke k = KeyStroke.getKeyStroke(debugAccelerators[i], 0);
+                item.setAccelerator(k);
+            }
+            if (i != 0) {
+                interruptOnlyItems.add(item);
+            } else {
+                runOnlyItems.add(item);
+            }
+            debugMenu.add(item);
+        }
+        breakOnExceptions = new JCheckBoxMenuItem("Break on Exceptions");
+        breakOnExceptions.setMnemonic('X');
+        breakOnExceptions.addActionListener(this);
+        breakOnExceptions.setSelected(false);
+        debugMenu.add(breakOnExceptions);
+
+        breakOnEnter = new JCheckBoxMenuItem("Break on Function Enter");
+        breakOnEnter.setMnemonic('E');
+        breakOnEnter.addActionListener(this);
+        breakOnEnter.setSelected(false);
+        debugMenu.add(breakOnEnter);
+
+        breakOnReturn = new JCheckBoxMenuItem("Break on Function Return");
+        breakOnReturn.setMnemonic('R');
+        breakOnReturn.addActionListener(this);
+        breakOnReturn.setSelected(false);
+        debugMenu.add(breakOnReturn);
+
+        add(fileMenu);
+        add(editMenu);
+        //add(plafMenu);
+        add(debugMenu);
+        JMenuItem item;
+        windowMenu.add(item = new JMenuItem("Cascade", 'A'));
+        item.addActionListener(this);
+        windowMenu.add(item = new JMenuItem("Tile", 'T'));
+        item.addActionListener(this);
+        windowMenu.addSeparator();
+        windowMenu.add(item = new JMenuItem("Console", 'C'));
+        item.addActionListener(this);
+        add(windowMenu);
+
+        updateEnabled(false);
+    }
+
+    /**
+     * Returns the "Break on exceptions" menu item.
+     */
+    public JCheckBoxMenuItem getBreakOnExceptions() {
+        return breakOnExceptions;
+    }
+
+    /**
+     * Returns the "Break on enter" menu item.
+     */
+    public JCheckBoxMenuItem getBreakOnEnter() {
+        return breakOnEnter;
+    }
+
+    /**
+     * Returns the "Break on return" menu item.
+     */
+    public JCheckBoxMenuItem getBreakOnReturn() {
+        return breakOnReturn;
+    }
+
+    /**
+     * Returns the "Debug" menu.
+     */
+    public JMenu getDebugMenu() {
+        return getMenu(2);
+    }
+
+    // ActionListener
+
+    /**
+     * Performs an action.
+     */
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        String plaf_name = null;
+        if (cmd.equals("Metal")) {
+            plaf_name = "javax.swing.plaf.metal.MetalLookAndFeel";
+        } else if (cmd.equals("Windows")) {
+            plaf_name = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
+        } else if (cmd.equals("Motif")) {
+            plaf_name = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
+        } else {
+            Object source = e.getSource();
+            if (source == breakOnExceptions) {
+                debugGui.dim.setBreakOnExceptions(breakOnExceptions.isSelected());
+            } else if (source == breakOnEnter) {
+                debugGui.dim.setBreakOnEnter(breakOnEnter.isSelected());
+            } else if (source == breakOnReturn) {
+                debugGui.dim.setBreakOnReturn(breakOnReturn.isSelected());
+            } else {
+                debugGui.actionPerformed(e);
+            }
+            return;
+        }
+        try {
+            UIManager.setLookAndFeel(plaf_name);
+            SwingUtilities.updateComponentTreeUI(debugGui);
+            SwingUtilities.updateComponentTreeUI(debugGui.dlg);
+        } catch (Exception ignored) {
+            //ignored.printStackTrace();
+        }
+    }
+
+    /**
+     * Adds a file to the window menu.
+     */
+    public void addFile(String url) {
+        int count = windowMenu.getItemCount();
+        JMenuItem item;
+        if (count == 4) {
+            windowMenu.addSeparator();
+            count++;
+        }
+        JMenuItem lastItem = windowMenu.getItem(count -1);
+        boolean hasMoreWin = false;
+        int maxWin = 5;
+        if (lastItem != null &&
+           lastItem.getText().equals("More Windows...")) {
+            hasMoreWin = true;
+            maxWin++;
+        }
+        if (!hasMoreWin && count - 4 == 5) {
+            windowMenu.add(item = new JMenuItem("More Windows...", 'M'));
+            item.setActionCommand("More Windows...");
+            item.addActionListener(this);
+            return;
+        } else if (count - 4 <= maxWin) {
+            if (hasMoreWin) {
+                count--;
+                windowMenu.remove(lastItem);
+            }
+            String shortName = SwingGui.getShortName(url);
+
+            windowMenu.add(item = new JMenuItem((char)('0' + (count-4)) + " " + shortName, '0' + (count - 4)));
+            if (hasMoreWin) {
+                windowMenu.add(lastItem);
+            }
+        } else {
+            return;
+        }
+        item.setActionCommand(url);
+        item.addActionListener(this);
+    }
+
+    /**
+     * Updates the enabledness of menu items.
+     */
+    public void updateEnabled(boolean interrupted) {
+        for (int i = 0; i != interruptOnlyItems.size(); ++i) {
+            JMenuItem item = (JMenuItem)interruptOnlyItems.elementAt(i);
+            item.setEnabled(interrupted);
+        }
+
+        for (int i = 0; i != runOnlyItems.size(); ++i) {
+            JMenuItem item = (JMenuItem)runOnlyItems.elementAt(i);
+            item.setEnabled(!interrupted);
+        }
+    }
+}
+
+/**
+ * Class to consolidate all cases that require to implement Runnable
+ * to avoid class generation bloat.
+ */
+class RunProxy implements Runnable {
+
+    // Constants for 'type'.
+    static final int OPEN_FILE = 1;
+    static final int LOAD_FILE = 2;
+    static final int UPDATE_SOURCE_TEXT = 3;
+    static final int ENTER_INTERRUPT = 4;
+
+    /**
+     * The debugger GUI.
+     */
+    private SwingGui debugGui;
+
+    /**
+     * The type of Runnable this object is.  Takes one of the constants
+     * defined in this class.
+     */
+    private int type;
+
+    /**
+     * The name of the file to open or load.
+     */
+    String fileName;
+
+    /**
+     * The source text to update.
+     */
+    String text;
+
+    /**
+     * The source for which to update the text.
+     */
+    Dim.SourceInfo sourceInfo;
+
+    /**
+     * The frame to interrupt in.
+     */
+    Dim.StackFrame lastFrame;
+
+    /**
+     * The name of the interrupted thread.
+     */
+    String threadTitle;
+
+    /**
+     * The message of the exception thrown that caused the thread
+     * interruption, if any.
+     */
+    String alertMessage;
+
+    /**
+     * Creates a new RunProxy.
+     */
+    public RunProxy(SwingGui debugGui, int type) {
+        this.debugGui = debugGui;
+        this.type = type;
+    }
+
+    /**
+     * Runs this Runnable.
+     */
+    public void run() {
+        switch (type) {
+          case OPEN_FILE:
+            try {
+                debugGui.dim.compileScript(fileName, text);
+            } catch (RuntimeException ex) {
+                MessageDialogWrapper.showMessageDialog(
+                    debugGui, ex.getMessage(), "Error Compiling "+fileName,
+                    JOptionPane.ERROR_MESSAGE);
+            }
+            break;
+
+          case LOAD_FILE:
+            try {
+                debugGui.dim.evalScript(fileName, text);
+            } catch (RuntimeException ex) {
+                MessageDialogWrapper.showMessageDialog(
+                    debugGui, ex.getMessage(), "Run error for "+fileName,
+                    JOptionPane.ERROR_MESSAGE);
+            }
+            break;
+
+          case UPDATE_SOURCE_TEXT:
+            {
+                String fileName = sourceInfo.url();
+                if (!debugGui.updateFileWindow(sourceInfo) &&
+                        !fileName.equals("<stdin>")) {
+                    debugGui.createFileWindow(sourceInfo, -1);
+                }
+            }
+            break;
+
+          case ENTER_INTERRUPT:
+            debugGui.enterInterruptImpl(lastFrame, threadTitle, alertMessage);
+            break;
+
+          default:
+            throw new IllegalArgumentException(String.valueOf(type));
+
+        }
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/build.xml b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/build.xml
new file mode 100644
index 0000000..c35fd40
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/debugger/build.xml
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- ***** BEGIN LICENSE BLOCK *****
+   - Version: MPL 1.1/GPL 2.0
+   -
+   - The contents of this file are subject to the Mozilla Public License Version
+   - 1.1 (the "License"); you may not use this file except in compliance with
+   - the License. You may obtain a copy of the License at
+   - http://www.mozilla.org/MPL/
+   -
+   - Software distributed under the License is distributed on an "AS IS" basis,
+   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+   - for the specific language governing rights and limitations under the
+   - License.
+   -
+   - The Original Code is Rhino code, released May 6, 1999.
+   -
+   - The Initial Developer of the Original Code is
+   - Netscape Communications Corporation.
+   - Portions created by the Initial Developer are Copyright (C) 1997-1999
+   - the Initial Developer. All Rights Reserved.
+   -
+   - Contributor(s):
+   -
+   - Alternatively, the contents of this file may be used under the terms of
+   - the GNU General Public License Version 2 or later (the "GPL"), in which
+   - case the provisions of the GPL are applicable instead of those above. If
+   - you wish to allow use of your version of this file only under the terms of
+   - the GPL and not to allow others to use your version of this file under the
+   - MPL, indicate your decision by deleting the provisions above and replacing
+   - them with the notice and other provisions required by the GPL. If you do
+   - not delete the provisions above, a recipient may use your version of this
+   - file under either the MPL or the GPL.
+   -
+   - ***** END LICENSE BLOCK ***** -->
+
+
+<project name="toolsrc" default="help" basedir=".">
+
+  <target name="properties">
+    <property name="swing-ex-url" value="http://java.sun.com/products/jfc/tsc/articles/treetable2/downloads/src.zip"/>
+    <available file="downloaded/AbstractCellEditor.java"
+               property="swing-ex-available"/>
+  </target>
+
+  <target name="get-swing-ex" unless="swing-ex-available">
+    <!-- Download source from Sun's site, unzip it, remove
+         the files we don't need, and change the package
+    -->
+    <mkdir dir="downloaded"/>
+    <get src="${swing-ex-url}" dest="downloaded/swingExSrc.zip"/>
+    <unzip src="downloaded/swingExSrc.zip" dest="downloaded/">
+      <patternset>
+          <include name="AbstractCellEditor.java"/>
+          <include name="JTreeTable.java"/>
+          <include name="TreeTableModel.java"/>
+          <include name="TreeTableModelAdapter.java"/>
+      </patternset>
+    </unzip>
+    <replace file="downloaded/AbstractCellEditor.java">
+       <replacetoken>import java.awt.Component;</replacetoken>
+       <replacevalue>
+package org.mozilla.javascript.tools.debugger.downloaded;
+       </replacevalue>
+    </replace>
+    <replace file="downloaded/AbstractCellEditor.java">
+       <replacetoken>import java.awt.event.*;</replacetoken>
+       <replacevalue></replacevalue>
+    </replace>
+    <replace file="downloaded/AbstractCellEditor.java">
+       <replacetoken>import java.awt.AWTEvent;</replacetoken>
+       <replacevalue></replacevalue>
+    </replace>
+    <replace file="downloaded/AbstractCellEditor.java">
+       <replacetoken>import java.io.Serializable;</replacetoken>
+       <replacevalue></replacevalue>
+    </replace>
+    <replace file="downloaded/JTreeTable.java">
+       <replacetoken>import javax.swing.*;</replacetoken>
+       <replacevalue>
+         package org.mozilla.javascript.tools.debugger.downloaded;
+         import javax.swing.*;
+       </replacevalue>
+    </replace>
+    <replace file="downloaded/JTreeTable.java">
+       <replacetoken>class ListToTreeSelectionModelWrapper</replacetoken>
+       <replacevalue>public class ListToTreeSelectionModelWrapper</replacevalue>
+    </replace>
+    <replace file="downloaded/JTreeTable.java">
+       <replacetoken>ListSelectionModel getListSelectionModel</replacetoken>
+       <replacevalue>public ListSelectionModel getListSelectionModel</replacevalue>
+    </replace>
+    <replace file="downloaded/JTreeTable.java">
+       <replacetoken>import java.awt.Rectangle;</replacetoken>
+       <replacevalue></replacevalue>
+    </replace>
+    <replace file="downloaded/TreeTableModel.java">
+       <replacetoken>import javax.swing.tree.TreeModel;</replacetoken>
+       <replacevalue>
+         package org.mozilla.javascript.tools.debugger.downloaded;
+         import javax.swing.tree.TreeModel;
+       </replacevalue>
+    </replace>
+    <replace file="downloaded/TreeTableModelAdapter.java">
+       <replacetoken>import javax.swing.JTree;</replacetoken>
+       <replacevalue>
+         package org.mozilla.javascript.tools.debugger.downloaded;
+         import javax.swing.JTree;
+       </replacevalue>
+    </replace>
+    <delete file="downloaded/swingExSrc.zip"/>
+  </target>
+
+  <target name="download" depends="properties,get-swing-ex"/>
+
+  <target name="help" depends="properties">
+<echo>The following targets are available with this build file:
+
+ download    Download ${swing-ex-url}
+             and extract the necessary files from it.
+
+ help        Print this help.
+
+</echo>
+  </target>
+
+</project>
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/CodePrinter.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/CodePrinter.java
new file mode 100644
index 0000000..dd4f689
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/CodePrinter.java
@@ -0,0 +1,212 @@
+/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.idswitch;
+
+class CodePrinter {
+
+// length of u-type escape like \u12AB
+    private static final int LITERAL_CHAR_MAX_SIZE = 6;
+
+    private String lineTerminator = "\n";
+
+    private int indentStep = 4;
+    private int indentTabSize = 8;
+
+    private char[] buffer = new char[1 << 12]; // 4K
+    private int offset;
+
+    public String getLineTerminator() { return lineTerminator; }
+    public void setLineTerminator(String value) { lineTerminator = value; }
+
+    public int getIndentStep() { return indentStep; }
+    public void setIndentStep(int char_count) { indentStep = char_count; }
+
+    public int getIndentTabSize() {    return indentTabSize; }
+    public void setIndentTabSize(int tab_size) { indentTabSize = tab_size; }
+
+    public void clear() {
+        offset = 0;
+    }
+
+    private int ensure_area(int area_size) {
+        int begin = offset;
+        int end = begin + area_size;
+        if (end > buffer.length) {
+            int new_capacity = buffer.length * 2;
+            if (end > new_capacity) { new_capacity = end; }
+            char[] tmp = new char[new_capacity];
+            System.arraycopy(buffer, 0, tmp, 0, begin);
+            buffer = tmp;
+        }
+        return begin;
+    }
+
+    private int add_area(int area_size) {
+        int pos = ensure_area(area_size);
+        offset = pos + area_size;
+        return pos;
+    }
+
+    public int getOffset() {
+        return offset;
+    }
+
+    public int getLastChar() {
+        return offset == 0 ? -1 : buffer[offset - 1];
+    }
+
+    public void p(char c) {
+        int pos = add_area(1);
+        buffer[pos] = c;
+    }
+
+    public void p(String s) {
+        int l = s.length();
+        int pos = add_area(l);
+        s.getChars(0, l, buffer, pos);
+    }
+
+    public final void p(char[] array) {
+        p(array, 0, array.length);
+    }
+
+    public void p(char[] array, int begin, int end) {
+        int l = end - begin;
+        int pos = add_area(l);
+        System.arraycopy(array, begin, buffer, pos, l);
+    }
+
+    public void p(int i) {
+        p(Integer.toString(i));
+    }
+
+    public void qchar(int c) {
+        int pos = ensure_area(2 + LITERAL_CHAR_MAX_SIZE);
+        buffer[pos] = '\'';
+        pos = put_string_literal_char(pos + 1, c, false);
+        buffer[pos] = '\'';
+        offset = pos + 1;
+    }
+
+    public void qstring(String s) {
+        int l = s.length();
+        int pos = ensure_area(2 + LITERAL_CHAR_MAX_SIZE * l);
+        buffer[pos] = '"';
+        ++pos;
+        for (int i = 0; i != l; ++i) {
+            pos = put_string_literal_char(pos, s.charAt(i), true);
+        }
+        buffer[pos] = '"';
+        offset = pos + 1;
+    }
+
+    private int put_string_literal_char(int pos, int c, boolean in_string) {
+        boolean backslash_symbol = true;
+        switch (c) {
+            case '\b': c = 'b'; break;
+            case '\t': c = 't'; break;
+            case '\n': c = 'n'; break;
+            case '\f': c = 'f'; break;
+            case '\r': c = 'r'; break;
+            case '\'': backslash_symbol = !in_string; break;
+            case '"': backslash_symbol = in_string; break;
+            default: backslash_symbol = false;
+        }
+
+        if (backslash_symbol) {
+            buffer[pos] = '\\';
+            buffer[pos + 1] = (char)c;
+            pos += 2;
+        }
+        else if (' ' <= c && c <= 126) {
+            buffer[pos] = (char)c;
+            ++pos;
+        }
+        else {
+            buffer[pos] = '\\';
+            buffer[pos + 1] = 'u';
+            buffer[pos + 2] = digit_to_hex_letter(0xF & (c >> 12));
+            buffer[pos + 3] = digit_to_hex_letter(0xF & (c >> 8));
+            buffer[pos + 4] = digit_to_hex_letter(0xF & (c >> 4));
+            buffer[pos + 5] = digit_to_hex_letter(0xF & c);
+            pos += 6;
+        }
+        return pos;
+    }
+
+    private static char digit_to_hex_letter(int d) {
+        return (char)((d < 10) ? '0' + d : 'A' - 10 + d);
+    }
+
+    public void indent(int level) {
+        int visible_size = indentStep * level;
+        int indent_size, tab_count;
+        if (indentTabSize <= 0) {
+            tab_count = 0; indent_size = visible_size;
+        }
+        else {
+            tab_count = visible_size / indentTabSize;
+            indent_size = tab_count + visible_size % indentTabSize;
+        }
+        int pos = add_area(indent_size);
+        int tab_end = pos + tab_count;
+        int indent_end = pos + indent_size;
+        for (; pos != tab_end; ++pos) {    buffer[pos] = '\t'; }
+        for (; pos != indent_end; ++pos) {    buffer[pos] = ' '; }
+    }
+
+    public void nl() {
+        p('\n');
+    }
+
+    public void line(int indent_level, String s) {
+        indent(indent_level); p(s); nl();
+    }
+
+    public void erase(int begin, int end) {
+        System.arraycopy(buffer, end, buffer, begin, offset - end);
+        offset -= end - begin;
+    }
+
+    public String toString() {
+        return new String(buffer, 0, offset);
+    }
+
+
+
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/FileBody.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/FileBody.java
new file mode 100644
index 0000000..60bdfb4
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/FileBody.java
@@ -0,0 +1,191 @@
+/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.idswitch;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+
+public class FileBody {
+
+    private static class ReplaceItem {
+        ReplaceItem next;
+        int begin;
+        int end;
+        String replacement;
+
+        ReplaceItem(int begin, int end, String text) {
+            this.begin = begin;
+            this.end = end;
+            this.replacement = text;
+        }
+    }
+
+    private char[] buffer = new char[1 << 14]; // 16K
+    private int bufferEnd;
+    private int lineBegin;
+    private int lineEnd;
+    private int nextLineStart;
+
+    private int lineNumber;
+
+    ReplaceItem firstReplace;
+    ReplaceItem lastReplace;
+
+
+    public char[] getBuffer() { return buffer; }
+
+    public void readData(Reader r) throws IOException {
+        int capacity = buffer.length;
+        int offset = 0;
+        for (;;) {
+            int n_read = r.read(buffer, offset, capacity - offset);
+            if (n_read < 0) { break; }
+            offset += n_read;
+            if (capacity == offset) {
+                capacity *= 2;
+                char[] tmp = new char[capacity];
+                System.arraycopy(buffer, 0, tmp, 0, offset);
+                buffer = tmp;
+            }
+        }
+        bufferEnd = offset;
+    }
+
+    public void writeInitialData(Writer w) throws IOException {
+        w.write(buffer, 0, bufferEnd);
+    }
+
+    public void writeData(Writer w) throws IOException {
+        int offset = 0;
+        for (ReplaceItem x = firstReplace; x != null; x = x.next) {
+            int before_replace = x.begin - offset;
+            if (before_replace > 0) {
+                w.write(buffer, offset, before_replace);
+            }
+            w.write(x.replacement);
+            offset = x.end;
+        }
+        int tail = bufferEnd - offset;
+        if (tail != 0) {
+            w.write(buffer, offset, tail);
+        }
+    }
+
+    public boolean wasModified() { return firstReplace != null; }
+
+    public boolean setReplacement(int begin, int end, String text) {
+        if (equals(text, buffer, begin, end)) { return false; }
+
+        ReplaceItem item = new ReplaceItem(begin, end, text);
+        if (firstReplace == null) {
+            firstReplace = lastReplace = item;
+        }
+        else if (begin < firstReplace.begin) {
+            item.next = firstReplace;
+            firstReplace = item;
+        }
+        else {
+            ReplaceItem cursor = firstReplace;
+            ReplaceItem next = cursor.next;
+            while (next != null) {
+                if (begin < next.begin) {
+                    item.next = next;
+                    cursor.next = item;
+                    break;
+                }
+                cursor = next;
+                next = next.next;
+            }
+            if (next == null) {
+                lastReplace.next = item;
+            }
+        }
+
+        return true;
+    }
+
+    public int getLineNumber() { return lineNumber; }
+
+    public int getLineBegin() { return lineBegin; }
+
+    public int getLineEnd() { return lineEnd; }
+
+    public void startLineLoop() {
+        lineNumber = 0;
+        lineBegin = lineEnd = nextLineStart = 0;
+    }
+
+    public boolean nextLine() {
+        if (nextLineStart == bufferEnd) {
+            lineNumber = 0; return false;
+        }
+        int i; int c = 0;
+        for (i = nextLineStart; i != bufferEnd; ++i) {
+            c = buffer[i];
+            if (c == '\n' || c == '\r') { break; }
+        }
+        lineBegin = nextLineStart;
+        lineEnd = i;
+        if (i == bufferEnd) {
+            nextLineStart = i;
+        }
+        else if (c == '\r' && i + 1 != bufferEnd && buffer[i + 1] == '\n') {
+            nextLineStart = i + 2;
+        }
+        else {
+            nextLineStart = i + 1;
+        }
+        ++lineNumber;
+        return true;
+    }
+
+    private static boolean equals(String str, char[] array, int begin, int end)
+    {
+        if (str.length() == end - begin) {
+            for (int i = begin, j = 0; i != end; ++i, ++j) {
+                if (array[i] != str.charAt(j)) { return false; }
+            }
+            return true;
+        }
+        return false;
+    }
+
+}
+
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/IdValuePair.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/IdValuePair.java
new file mode 100644
index 0000000..69d5065
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/IdValuePair.java
@@ -0,0 +1,58 @@
+/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.idswitch;
+
+public class IdValuePair
+{
+    public final int idLength;
+    public final String id;
+    public final String value;
+
+    private int lineNumber;
+
+    public IdValuePair(String id, String value) {
+        this.idLength = id.length();
+        this.id = id;
+        this.value = value;
+    }
+
+    public int getLineNumber() { return lineNumber; }
+
+    public void setLineNumber(int value) { lineNumber = value; }
+}
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/Main.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/Main.java
new file mode 100644
index 0000000..ae1d038
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/Main.java
@@ -0,0 +1,612 @@
+/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.idswitch;
+
+import java.io.*;
+import java.util.*;
+import java.text.SimpleDateFormat;
+
+import org.mozilla.javascript.EvaluatorException;
+import org.mozilla.javascript.tools.ToolErrorReporter;
+
+public class Main {
+
+    private static final String SWITCH_TAG_STR = "string_id_map";
+    private static final String GENERATED_TAG_STR = "generated";
+    private static final String STRING_TAG_STR = "string";
+
+    private static final int
+        NORMAL_LINE        = 0,
+        SWITCH_TAG         = 1,
+        GENERATED_TAG      = 2,
+        STRING_TAG         = 3;
+
+    private final Vector all_pairs = new Vector();
+
+    private ToolErrorReporter R;
+    private CodePrinter P;
+    private FileBody body;
+    private String source_file;
+
+    private int tag_definition_end;
+
+    private int tag_value_start;
+    private int tag_value_end;
+
+    private static boolean is_value_type(int id) {
+        if (id == STRING_TAG) { return true; }
+        return false;
+    }
+
+    private static String tag_name(int id) {
+        switch (id) {
+            case SWITCH_TAG: return SWITCH_TAG_STR;
+            case -SWITCH_TAG: return "/" + SWITCH_TAG_STR;
+            case GENERATED_TAG: return GENERATED_TAG_STR;
+            case -GENERATED_TAG: return "/" + GENERATED_TAG_STR;
+        }
+        return "";
+    }
+
+    void process_file(String file_path) throws IOException {
+        source_file = file_path;
+
+        body = new FileBody();
+
+        InputStream is;
+        if (file_path.equals("-")) {
+            is = System.in;
+        }
+        else {
+            is = new FileInputStream(file_path);
+        }
+        try {
+            Reader r = new InputStreamReader(is, "ASCII");
+            body.readData(r);
+        }
+        finally { is.close(); }
+
+        process_file();
+
+        if (body.wasModified()) {
+            OutputStream os;
+            if (file_path.equals("-")) {
+                os = System.out;
+            }
+            else {
+                os = new FileOutputStream(file_path);
+            }
+
+            try {
+                Writer w = new OutputStreamWriter(os);
+                body.writeData(w);
+                w.flush();
+            }
+            finally { os.close(); }
+        }
+    }
+
+    private void process_file() {
+        int cur_state = 0;
+        char[] buffer = body.getBuffer();
+
+        int generated_begin = -1, generated_end = -1;
+        int time_stamp_begin = -1, time_stamp_end = -1;
+
+        body.startLineLoop();
+        while (body.nextLine()) {
+            int begin = body.getLineBegin();
+            int end = body.getLineEnd();
+
+            int tag_id = extract_line_tag_id(buffer, begin, end);
+            boolean bad_tag = false;
+            switch (cur_state) {
+                case NORMAL_LINE:
+                    if (tag_id == SWITCH_TAG) {
+                        cur_state = SWITCH_TAG;
+                        all_pairs.removeAllElements();
+                        generated_begin = -1;
+                    }
+                    else if (tag_id == -SWITCH_TAG) {
+                        bad_tag = true;
+                    }
+                    break;
+                case SWITCH_TAG:
+                    if (tag_id == 0) {
+                        look_for_id_definitions(buffer, begin, end, false);
+                    }
+                    else if (tag_id == STRING_TAG) {
+                        look_for_id_definitions(buffer, begin, end, true);
+                    }
+                    else if (tag_id == GENERATED_TAG) {
+                        if (generated_begin >= 0) { bad_tag = true; }
+                        else {
+                            cur_state = GENERATED_TAG;
+                            time_stamp_begin = tag_definition_end;
+                            time_stamp_end = end;
+                        }
+                    }
+                    else if (tag_id == -SWITCH_TAG) {
+                        cur_state = 0;
+                        if (generated_begin >= 0 && !all_pairs.isEmpty()) {
+                            generate_java_code();
+                            String code = P.toString();
+                            boolean different = body.setReplacement
+                                (generated_begin, generated_end, code);
+                            if (different) {
+                                String stamp = get_time_stamp();
+                                body.setReplacement
+                                    (time_stamp_begin, time_stamp_end, stamp);
+                            }
+                        }
+
+                        break;
+                    }
+                    else {
+                        bad_tag = true;
+                    }
+                    break;
+                case GENERATED_TAG:
+                    if (tag_id == 0) {
+                        if (generated_begin < 0) { generated_begin = begin; }
+                    }
+                    else if (tag_id == -GENERATED_TAG) {
+                        if (generated_begin < 0) { generated_begin = begin; }
+                        cur_state = SWITCH_TAG;
+                        generated_end = begin;
+                    }
+                    else {
+                        bad_tag = true;
+                    }
+                    break;
+            }
+            if (bad_tag) {
+                String text = ToolErrorReporter.getMessage(
+                    "msg.idswitch.bad_tag_order", tag_name(tag_id));
+                throw R.runtimeError
+                    (text, source_file, body.getLineNumber(), null, 0);
+            }
+        }
+
+        if (cur_state != 0) {
+            String text = ToolErrorReporter.getMessage(
+                "msg.idswitch.file_end_in_switch", tag_name(cur_state));
+            throw R.runtimeError
+                (text, source_file, body.getLineNumber(), null, 0);
+        }
+    }
+
+    private String get_time_stamp() {
+        SimpleDateFormat f = new SimpleDateFormat
+            (" 'Last update:' yyyy-MM-dd HH:mm:ss z");
+        return f.format(new Date());
+    }
+
+    private void generate_java_code() {
+
+        P.clear();
+
+        IdValuePair[] pairs = new IdValuePair[all_pairs.size()];
+        all_pairs.copyInto(pairs);
+
+        SwitchGenerator g = new SwitchGenerator();
+        g.char_tail_test_threshold = 2;
+        g.setReporter(R);
+        g.setCodePrinter(P);
+
+        g.generateSwitch(pairs, "0");
+    }
+
+    private int extract_line_tag_id(char[] array, int cursor, int end) {
+        int id = 0;
+        cursor = skip_white_space(array, cursor, end);
+        int after_leading_white_space = cursor;
+        cursor = look_for_slash_slash(array, cursor, end);
+        if (cursor != end) {
+            boolean at_line_start = (after_leading_white_space + 2 == cursor);
+            cursor = skip_white_space(array, cursor, end);
+            if (cursor != end && array[cursor] == '#') {
+                ++cursor;
+
+                boolean end_tag = false;
+                if (cursor != end && array[cursor] == '/') {
+                    ++cursor; end_tag = true;
+                }
+
+                int tag_start = cursor;
+
+                for (; cursor != end; ++cursor) {
+                    int c = array[cursor];
+                    if (c == '#' || c == '=' ||is_white_space(c)) { break; }
+                }
+
+                if (cursor != end) {
+                    int tag_end = cursor;
+                    cursor = skip_white_space(array, cursor, end);
+                    if (cursor != end) {
+                        int c = array[cursor];
+                        if (c == '=' || c == '#') {
+                            id = get_tag_id
+                                (array, tag_start, tag_end, at_line_start);
+                            if (id != 0) {
+                                String bad = null;
+                                if (c == '#') {
+                                    if (end_tag) {
+                                        id = -id;
+                                        if (is_value_type(id)) {
+                                            bad = "msg.idswitch.no_end_usage";
+                                        }
+                                    }
+                                    tag_definition_end = cursor + 1;
+                                }
+                                else  {
+                                    if (end_tag) {
+                                        bad = "msg.idswitch.no_end_with_value";
+                                    }
+                                    else if (!is_value_type(id)) {
+                                        bad = "msg.idswitch.no_value_allowed";
+                                    }
+                                    id = extract_tag_value
+                                        (array, cursor + 1, end, id);
+                                }
+                                if (bad != null) {
+                                    String s = ToolErrorReporter.getMessage(
+                                        bad, tag_name(id));
+                                    throw R.runtimeError
+                                        (s, source_file, body.getLineNumber(),
+                                         null, 0);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return id;
+    }
+
+// Return position after first of // or end if not found
+    private int look_for_slash_slash(char[] array, int cursor, int end) {
+        while (cursor + 2 <= end) {
+            int c = array[cursor++];
+            if (c == '/') {
+                c = array[cursor++];
+                if (c == '/') {
+                    return cursor;
+                }
+            }
+        }
+        return end;
+    }
+
+    private int extract_tag_value(char[] array, int cursor, int end, int id) {
+        // cursor points after #[^#=]+=
+        // ALERT: implement support for quoted strings
+        boolean found = false;
+        cursor = skip_white_space(array, cursor, end);
+        if (cursor != end) {
+            int value_start = cursor;
+            int value_end = cursor;
+            while (cursor != end) {
+                int c = array[cursor];
+                if (is_white_space(c)) {
+                    int after_space = skip_white_space(array, cursor + 1, end);
+                    if (after_space != end && array[after_space] == '#') {
+                        value_end = cursor;
+                        cursor = after_space;
+                        break;
+                    }
+                    cursor = after_space + 1;
+                }
+                else if (c == '#') {
+                    value_end = cursor;
+                    break;
+                }
+                else {
+                    ++cursor;
+                }
+            }
+            if (cursor != end) {
+                // array[cursor] is '#' here
+                found = true;
+                tag_value_start = value_start;
+                tag_value_end = value_end;
+                tag_definition_end = cursor + 1;
+            }
+        }
+        return (found) ? id : 0;
+    }
+
+    private int get_tag_id
+        (char[] array, int begin, int end, boolean at_line_start)
+    {
+        if (at_line_start) {
+            if (equals(SWITCH_TAG_STR, array, begin, end)) {
+                return SWITCH_TAG;
+            }
+            if (equals(GENERATED_TAG_STR, array, begin, end)) {
+                return GENERATED_TAG;
+            }
+        }
+        if (equals(STRING_TAG_STR, array, begin, end)) {
+            return STRING_TAG;
+        }
+        return 0;
+    }
+
+    private void look_for_id_definitions
+        (char[] array, int begin, int end, boolean use_tag_value_as_string)
+    {
+    // Look for the pattern
+    // '^[ \t]+Id_([a-zA-Z0-9_]+)[ \t]*=.*$'
+    // where \1 gives field or method name
+        int cursor = begin;
+        // Skip tab and spaces at the beginning
+        cursor = skip_white_space(array, cursor, end);
+        int id_start = cursor;
+        int name_start = skip_matched_prefix("Id_", array, cursor, end);
+        if (name_start >= 0) {
+            // Found Id_ prefix
+            cursor = name_start;
+            cursor = skip_name_char(array, cursor, end);
+            int name_end = cursor;
+            if (name_start != name_end) {
+                cursor = skip_white_space(array, cursor, end);
+                if (cursor != end) {
+                    if (array[cursor] == '=') {
+                        int id_end = name_end;
+                        if (use_tag_value_as_string) {
+                            name_start = tag_value_start;
+                            name_end = tag_value_end;
+                        }
+                        // Got the match
+                        add_id(array, id_start, id_end, name_start, name_end);
+                    }
+                }
+            }
+        }
+    }
+
+    private void add_id
+        (char[] array, int id_start, int id_end, int name_start, int name_end)
+    {
+        String name = new String(array, name_start, name_end - name_start);
+        String value = new String(array, id_start, id_end - id_start);
+
+        IdValuePair pair = new IdValuePair(name, value);
+
+        pair.setLineNumber(body.getLineNumber());
+
+        all_pairs.addElement(pair);
+    }
+
+    private static boolean is_white_space(int c) {
+        return c == ' ' || c == '\t';
+    }
+
+    private static int skip_white_space(char[] array, int begin, int end) {
+        int cursor = begin;
+        for (; cursor != end; ++cursor) {
+            int c = array[cursor];
+            if (!is_white_space(c)) { break; }
+        }
+        return cursor;
+    }
+
+    private static int skip_matched_prefix
+        (String prefix, char[] array, int begin, int end)
+    {
+        int cursor = -1;
+        int prefix_length = prefix.length();
+        if (prefix_length <= end - begin) {
+            cursor = begin;
+            for (int i = 0; i != prefix_length; ++i, ++cursor) {
+                if (prefix.charAt(i) != array[cursor]) {
+                    cursor = -1; break;
+                }
+            }
+        }
+        return cursor;
+    }
+
+    private static boolean equals(String str, char[] array, int begin, int end)
+    {
+        if (str.length() == end - begin) {
+            for (int i = begin, j = 0; i != end; ++i, ++j) {
+                if (array[i] != str.charAt(j)) { return false; }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private static int skip_name_char(char[] array, int begin, int end) {
+        int cursor = begin;
+        for (; cursor != end; ++cursor) {
+            int c = array[cursor];
+            if (!('a' <= c && c <= 'z') && !('A' <= c && c <= 'Z')) {
+                if (!('0' <= c && c <= '9')) {
+                    if (c != '_') {
+                        break;
+                    }
+                }
+            }
+        }
+        return cursor;
+    }
+
+    public static void main(String[] args) {
+        Main self = new Main();
+        int status = self.exec(args);
+        System.exit(status);
+    }
+
+    private int exec(String[] args) {
+        R = new ToolErrorReporter(true, System.err);
+
+        int arg_count = process_options(args);
+
+        if (arg_count == 0) {
+            option_error(ToolErrorReporter.getMessage(
+                             "msg.idswitch.no_file_argument"));
+            return -1;
+        }
+        if (arg_count > 1) {
+            option_error(ToolErrorReporter.getMessage(
+                             "msg.idswitch.too_many_arguments"));
+            return -1;
+        }
+
+        P = new CodePrinter();
+        P.setIndentStep(4);
+        P.setIndentTabSize(0);
+
+        try {
+            process_file(args[0]);
+        }
+        catch (IOException ex) {
+            print_error(ToolErrorReporter.getMessage(
+                            "msg.idswitch.io_error", ex.toString()));
+            return -1;
+        }
+        catch (EvaluatorException ex) {
+            return -1;
+        }
+        return 0;
+    }
+
+    private int process_options(String[] args) {
+
+        int status = 1;
+
+        boolean show_usage = false;
+        boolean show_version = false;
+
+        int N = args.length;
+        L: for (int i = 0; i != N; ++i) {
+            String arg = args[i];
+            int arg_length = arg.length();
+            if (arg_length >= 2) {
+                if (arg.charAt(0) == '-') {
+                    if (arg.charAt(1) == '-') {
+                        if (arg_length == 2) {
+                            args[i] = null; break;
+                        }
+                        if (arg.equals("--help")) {
+                            show_usage = true;
+                        }
+                        else if (arg.equals("--version")) {
+                            show_version = true;
+                        }
+                        else {
+                            option_error(ToolErrorReporter.getMessage(
+                                             "msg.idswitch.bad_option", arg));
+                            status = -1; break L;
+                        }
+                    }
+                    else {
+                        for (int j = 1; j != arg_length; ++j) {
+                            char c = arg.charAt(j);
+                            switch (c) {
+                                case 'h': show_usage = true; break;
+                                default:
+                                    option_error(
+                                        ToolErrorReporter.getMessage(
+                                            "msg.idswitch.bad_option_char",
+                                            String.valueOf(c)));
+                                    status = -1;
+                                    break L;
+                            }
+
+                        }
+                    }
+                    args[i] = null;
+                }
+            }
+        }
+
+        if (status == 1) {
+            if (show_usage) { show_usage(); status = 0; }
+            if (show_version) { show_version(); status = 0; }
+        }
+
+        if (status != 1) { System.exit(status); }
+
+        return remove_nulls(args);
+    }
+
+    private void show_usage() {
+        System.out.println(
+            ToolErrorReporter.getMessage("msg.idswitch.usage"));
+        System.out.println();
+    }
+
+    private void show_version() {
+        System.out.println(
+            ToolErrorReporter.getMessage("msg.idswitch.version"));
+    }
+
+    private void option_error(String str) {
+        print_error(
+            ToolErrorReporter.getMessage("msg.idswitch.bad_invocation", str));
+    }
+
+    private void print_error(String text) {
+        System.err.println(text);
+    }
+
+    private int remove_nulls(String[] array) {
+        int N = array.length;
+        int cursor = 0;
+        for (; cursor != N; ++cursor) {
+            if (array[cursor] == null) { break; }
+        }
+        int destination = cursor;
+        if (cursor != N) {
+            ++cursor;
+            for (; cursor != N; ++cursor) {
+                String elem = array[cursor];
+                if (elem != null) {
+                    array[destination] = elem; ++destination;
+                }
+            }
+        }
+        return destination;
+    }
+}
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/SwitchGenerator.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/SwitchGenerator.java
new file mode 100644
index 0000000..3db99d6
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/idswitch/SwitchGenerator.java
@@ -0,0 +1,491 @@
+/* -*- Mode: java; tab-width: 4; indent-tabs-mode: 1; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.idswitch;
+
+import org.mozilla.javascript.EvaluatorException;
+import org.mozilla.javascript.tools.ToolErrorReporter;
+
+public class SwitchGenerator {
+
+    String v_switch_label = "L0";
+    String v_label = "L";
+    String v_s = "s";
+    String v_c = "c";
+    String v_guess = "X";
+    String v_id = "id";
+    String v_length_suffix = "_length";
+
+    int use_if_threshold = 3;
+    int char_tail_test_threshold = 2;
+
+    private IdValuePair[] pairs;
+    private String default_value;
+    private int[] columns;
+    private boolean c_was_defined;
+
+    private CodePrinter P;
+    private ToolErrorReporter R;
+    private String source_file;
+
+    public CodePrinter getCodePrinter() { return P; }
+    public void setCodePrinter(CodePrinter value) { P = value; }
+
+    public ToolErrorReporter getReporter() { return R; }
+    public void setReporter(ToolErrorReporter value) { R = value; }
+
+    public String getSourceFileName() { return source_file; }
+    public void setSourceFileName(String value) { source_file = value; }
+
+    public void generateSwitch(String[] pairs, String default_value) {
+        int N = pairs.length / 2;
+        IdValuePair[] id_pairs = new IdValuePair[N];
+        for (int i = 0; i != N; ++i) {
+            id_pairs[i] = new IdValuePair(pairs[2 * i], pairs[2 * i + 1]);
+        }
+        generateSwitch(id_pairs, default_value);
+
+    }
+
+    public void generateSwitch(IdValuePair[] pairs, String default_value) {
+        int begin = 0;
+        int end = pairs.length;
+        if (begin == end) { return; }
+        this.pairs = pairs;
+        this.default_value = default_value;
+
+        generate_body(begin, end, 2);
+    }
+
+    private void generate_body(int begin, int end, int indent_level) {
+        P.indent(indent_level);
+        P.p(v_switch_label); P.p(": { ");
+        P.p(v_id); P.p(" = "); P.p(default_value);
+        P.p("; String "); P.p(v_guess); P.p(" = null;");
+
+        c_was_defined = false;
+        int c_def_begin = P.getOffset();
+        P.p(" int "); P.p(v_c); P.p(';');
+        int c_def_end = P.getOffset();
+        P.nl();
+
+        generate_length_switch(begin, end, indent_level + 1);
+
+        if (!c_was_defined) {
+            P.erase(c_def_begin, c_def_end);
+        }
+
+        P.indent(indent_level + 1);
+        P.p("if ("); P.p(v_guess); P.p("!=null && ");
+        P.p(v_guess); P.p("!="); P.p(v_s);
+        P.p(" && !"); P.p(v_guess); P.p(".equals("); P.p(v_s); P.p(")) ");
+        P.p(v_id); P.p(" = "); P.p(default_value); P.p(";"); P.nl();
+        
+        // Add break at end of block to suppress warning for unused label
+        P.indent(indent_level + 1);
+        P.p("break "); P.p(v_switch_label); P.p(";"); P.nl();
+        
+        P.line(indent_level, "}");
+    }
+
+    private void generate_length_switch(int begin, int end, int indent_level) {
+
+        sort_pairs(begin, end, -1);
+
+        check_all_is_different(begin, end);
+
+        int lengths_count = count_different_lengths(begin, end);
+
+        columns = new int[pairs[end  - 1].idLength];
+
+        boolean use_if;
+        if (lengths_count <= use_if_threshold) {
+            use_if = true;
+            if (lengths_count != 1) {
+                P.indent(indent_level);
+                P.p("int "); P.p(v_s); P.p(v_length_suffix);
+                P.p(" = "); P.p(v_s); P.p(".length();");
+                P.nl();
+            }
+        }
+        else {
+            use_if = false;
+            P.indent(indent_level);
+            P.p(v_label); P.p(": switch (");
+            P.p(v_s); P.p(".length()) {");
+            P.nl();
+        }
+
+        int same_length_begin = begin;
+        int cur_l = pairs[begin].idLength, l = 0;
+        for (int i = begin;;) {
+            ++i;
+            if (i == end || (l = pairs[i].idLength) != cur_l) {
+                int next_indent;
+                if (use_if) {
+                    P.indent(indent_level);
+                    if (same_length_begin != begin) { P.p("else "); }
+                    P.p("if (");
+                    if (lengths_count == 1) {
+                        P.p(v_s); P.p(".length()==");
+                    }
+                    else {
+                        P.p(v_s); P.p(v_length_suffix); P.p("==");
+                    }
+                    P.p(cur_l);
+                    P.p(") {");
+                    next_indent = indent_level + 1;
+                }
+                else {
+                    P.indent(indent_level);
+                    P.p("case "); P.p(cur_l); P.p(":");
+                    next_indent = indent_level + 1;
+                }
+                generate_letter_switch
+                    (same_length_begin, i, next_indent, !use_if, use_if);
+                if (use_if) {
+                    P.p("}"); P.nl();
+                }
+                else {
+                    P.p("break "); P.p(v_label); P.p(";"); P.nl();
+                }
+
+                if (i == end) { break; }
+                same_length_begin = i;
+                cur_l = l;
+            }
+        }
+
+        if (!use_if) {
+            P.indent(indent_level); P.p("}"); P.nl();
+        }
+
+    }
+
+    private void generate_letter_switch
+        (int begin, int end,
+         int indent_level, boolean label_was_defined, boolean inside_if)
+    {
+        int L = pairs[begin].idLength;
+
+        for (int i = 0; i != L; ++i) {
+            columns[i] = i;
+        }
+
+        generate_letter_switch_r
+            (begin, end, L, indent_level, label_was_defined, inside_if);
+    }
+
+
+    private boolean generate_letter_switch_r
+        (int begin, int end, int L,
+         int indent_level, boolean label_was_defined, boolean inside_if)
+    {
+        boolean next_is_unreachable = false;
+        if (begin + 1 == end) {
+            P.p(' ');
+            IdValuePair pair = pairs[begin];
+            if (L > char_tail_test_threshold) {
+                P.p(v_guess); P.p("="); P.qstring(pair.id); P.p(";");
+                P.p(v_id); P.p("="); P.p(pair.value); P.p(";");
+            }
+            else {
+                if (L == 0) {
+                    next_is_unreachable = true;
+                    P.p(v_id); P.p("="); P.p(pair.value);
+                    P.p("; break "); P.p(v_switch_label); P.p(";");
+                }
+                else {
+                    P.p("if (");
+                    int column = columns[0];
+                    P.p(v_s); P.p(".charAt("); P.p(column); P.p(")==");
+                    P.qchar(pair.id.charAt(column));
+                    for (int i = 1; i != L; ++i) {
+                        P.p(" && ");
+                        column = columns[i];
+                        P.p(v_s); P.p(".charAt("); P.p(column); P.p(")==");
+                        P.qchar(pair.id.charAt(column));
+                    }
+                    P.p(") {");
+                    P.p(v_id); P.p("="); P.p(pair.value);
+                    P.p("; break "); P.p(v_switch_label); P.p(";}");
+                }
+            }
+            P.p(' ');
+            return next_is_unreachable;
+        }
+
+        int max_column_index = find_max_different_column(begin, end, L);
+        int max_column = columns[max_column_index];
+        int count = count_different_chars(begin, end, max_column);
+
+        columns[max_column_index] = columns[L - 1];
+
+        if (inside_if) { P.nl(); P.indent(indent_level); }
+        else { P.p(' '); }
+
+        boolean use_if;
+        if (count <= use_if_threshold) {
+            use_if = true;
+            c_was_defined = true;
+            P.p(v_c); P.p("="); P.p(v_s);
+            P.p(".charAt("); P.p(max_column); P.p(");");
+        }
+        else {
+            use_if = false;
+            if (!label_was_defined) {
+                label_was_defined = true;
+                P.p(v_label); P.p(": ");
+            }
+            P.p("switch ("); P.p(v_s);
+            P.p(".charAt("); P.p(max_column); P.p(")) {");
+        }
+
+        int same_char_begin = begin;
+        int cur_ch = pairs[begin].id.charAt(max_column), ch = 0;
+        for (int i = begin;;) {
+            ++i;
+            if (i == end || (ch = pairs[i].id.charAt(max_column)) != cur_ch) {
+                int next_indent;
+                if (use_if) {
+                    P.nl(); P.indent(indent_level);
+                    if (same_char_begin != begin) { P.p("else "); }
+                    P.p("if ("); P.p(v_c); P.p("==");
+                    P.qchar(cur_ch); P.p(") {");
+                    next_indent = indent_level + 1;
+                }
+                else {
+                    P.nl(); P.indent(indent_level);
+                    P.p("case "); P.qchar(cur_ch); P.p(":");
+                    next_indent = indent_level + 1;
+                }
+                boolean after_unreachable = generate_letter_switch_r
+                    (same_char_begin, i, L - 1,
+                     next_indent, label_was_defined, use_if);
+                if (use_if) {
+                    P.p("}");
+                }
+                else {
+                    if (!after_unreachable) {
+                        P.p("break "); P.p(v_label); P.p(";");
+                    }
+                }
+                if (i == end) { break; }
+                same_char_begin = i;
+                cur_ch = ch;
+            }
+        }
+
+        if (use_if) {
+            P.nl();
+            if (inside_if) { P.indent(indent_level - 1); }
+            else { P.indent(indent_level); }
+        }
+        else {
+            P.nl(); P.indent(indent_level); P.p("}");
+            if (inside_if) { P.nl(); P.indent(indent_level - 1);}
+            else { P.p(' '); }
+        }
+
+        columns[max_column_index] = max_column;
+
+        return next_is_unreachable;
+    }
+
+
+    private int count_different_lengths(int begin, int end) {
+        int lengths_count = 0;
+        int cur_l = -1;
+        for (; begin != end; ++begin) {
+            int l = pairs[begin].idLength;
+            if (cur_l != l) {
+                ++lengths_count; cur_l = l;
+            }
+        }
+        return lengths_count;
+    }
+
+    private int find_max_different_column(int begin, int end, int L) {
+        int max_count = 0;
+        int max_index = 0;
+
+        for (int i = 0; i != L; ++i) {
+            int column = columns[i];
+            sort_pairs(begin, end, column);
+            int count = count_different_chars(begin, end, column);
+            if (count == end - begin) { return i; }
+            if (max_count < count) {
+                max_count = count;
+                max_index = i;
+            }
+        }
+
+        if (max_index != L - 1) {
+            sort_pairs(begin, end, columns[max_index]);
+        }
+
+        return max_index;
+    }
+
+    private int count_different_chars(int begin, int end, int column) {
+        int chars_count = 0;
+        int cur_ch = -1;
+        for (; begin != end; ++begin) {
+            int ch = pairs[begin].id.charAt(column);
+            if (ch != cur_ch) {
+                ++chars_count; cur_ch = ch;
+            }
+        }
+        return chars_count;
+    }
+
+    private void check_all_is_different(int begin, int end) {
+        if (begin != end) {
+            IdValuePair prev = pairs[begin];
+            while (++begin != end) {
+                IdValuePair current = pairs[begin];
+                if (prev.id.equals(current.id)) {
+                    throw on_same_pair_fail(prev, current);
+                }
+                prev = current;
+            }
+        }
+    }
+
+    private EvaluatorException on_same_pair_fail(IdValuePair a, IdValuePair b) {
+        int line1 = a.getLineNumber(), line2 = b.getLineNumber();
+        if (line2 > line1) { int tmp = line1; line1 = line2; line2 = tmp; }
+        String error_text = ToolErrorReporter.getMessage(
+            "msg.idswitch.same_string", a.id, new Integer(line2));
+        return R.runtimeError(error_text, source_file, line1, null, 0);
+    }
+
+    private void sort_pairs(int begin, int end, int comparator) {
+        heap4Sort(pairs, begin, end - begin, comparator);
+    }
+
+    private static boolean bigger
+        (IdValuePair a, IdValuePair b, int comparator)
+    {
+        if (comparator < 0) {
+        // For length selection switch it is enough to compare just length,
+        // but to detect same strings full comparison is essential
+            //return a.idLength > b.idLength;
+            int diff = a.idLength - b.idLength;
+            if (diff != 0) { return diff > 0; }
+            return a.id.compareTo(b.id) > 0;
+        }
+        else {
+            return a.id.charAt(comparator) > b.id.charAt(comparator);
+        }
+    }
+
+    private static void heap4Sort
+        (IdValuePair[] array, int offset, int size, int comparator)
+    {
+        if (size <= 1) { return; }
+        makeHeap4(array, offset, size, comparator);
+        while (size > 1) {
+            --size;
+            IdValuePair v1 = array[offset + size];
+            IdValuePair v2 = array[offset + 0];
+            array[offset + size] = v2;
+            array[offset + 0] = v1;
+            heapify4(array, offset, size, 0, comparator);
+        }
+    }
+
+    private static void makeHeap4
+        (IdValuePair[] array, int offset, int size, int comparator)
+    {
+        for (int i = ((size + 2) >> 2); i != 0;) {
+            --i;
+            heapify4(array, offset, size, i, comparator);
+        }
+    }
+
+    private static void heapify4
+        (IdValuePair[] array, int offset, int size, int i, int comparator)
+    {
+        int new_i1, new_i2, new_i3;
+        IdValuePair i_val = array[offset + i];
+        for (;;) {
+            int base = (i << 2);
+            new_i1 = base | 1;
+            new_i2 = base | 2;
+            new_i3 = base | 3;
+            int new_i4 = base + 4;
+            if (new_i4 >= size) { break; }
+            IdValuePair val1 = array[offset + new_i1];
+            IdValuePair val2 = array[offset + new_i2];
+            IdValuePair val3 = array[offset + new_i3];
+            IdValuePair val4 = array[offset + new_i4];
+            if (bigger(val2, val1, comparator)) {
+                val1 = val2; new_i1 = new_i2;
+            }
+            if (bigger(val4, val3, comparator)) {
+                val3 = val4; new_i3 = new_i4;
+            }
+            if (bigger(val3, val1, comparator)) {
+                val1 = val3; new_i1 = new_i3;
+            }
+            if (bigger(i_val, val1, comparator)) { return; }
+            array[offset + i] = val1;
+            array[offset + new_i1] = i_val;
+            i = new_i1;
+        }
+        if (new_i1 < size) {
+            IdValuePair val1 = array[offset + new_i1];
+            if (new_i2 != size) {
+                IdValuePair val2 = array[offset + new_i2];
+                if (bigger(val2, val1, comparator)) {
+                    val1 = val2; new_i1 = new_i2;
+                }
+                if (new_i3 != size) {
+                    IdValuePair val3 = array[offset + new_i3];
+                    if (bigger(val3, val1, comparator)) {
+                        val1 = val3; new_i1 = new_i3;
+                    }
+                }
+            }
+            if (bigger(val1, i_val, comparator)) {
+                array[offset + i] = val1;
+                array[offset + new_i1] = i_val;
+            }
+        }
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/jsc/Main.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/jsc/Main.java
new file mode 100644
index 0000000..2da4f2f
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/jsc/Main.java
@@ -0,0 +1,395 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Christine Begle
+ *   Norris Boyd
+ *   Roger Lawrence
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.jsc;
+
+import java.io.*;
+import java.util.*;
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.optimizer.ClassCompiler;
+import org.mozilla.javascript.tools.ToolErrorReporter;
+
+/**
+ * @author Norris Boyd
+ */
+public class Main {
+
+    /**
+     * Main entry point.
+     *
+     * Process arguments as would a normal Java program.
+     * Then set up the execution environment and begin to
+     * compile scripts.
+     */
+    public static void main(String args[])
+    {
+        Main main = new Main();
+        args = main.processOptions(args);
+        if (args == null) {
+            if (main.printHelp) {
+                System.out.println(ToolErrorReporter.getMessage(
+                    "msg.jsc.usage", Main.class.getName()));
+                System.exit(0);
+            }
+            System.exit(1);
+        }
+        if (!main.reporter.hasReportedError()) {
+            main.processSource(args);
+        }
+    }
+
+    public Main()
+    {
+        reporter = new ToolErrorReporter(true);
+        compilerEnv = new CompilerEnvirons();
+        compilerEnv.setErrorReporter(reporter);
+        compiler = new ClassCompiler(compilerEnv);
+    }
+
+    /**
+     * Parse arguments.
+     *
+     */
+    public String[] processOptions(String args[])
+    {
+        targetPackage = "";        // default to no package
+        compilerEnv.setGenerateDebugInfo(false);   // default to no symbols
+        for (int i=0; i < args.length; i++) {
+            String arg = args[i];
+            if (!arg.startsWith("-")) {
+                int tail = args.length - i;
+                if (targetName != null && tail > 1) {
+                    addError("msg.multiple.js.to.file", targetName);
+                    return null;
+                }
+                String[] result = new String[tail];
+                for (int j = 0; j != tail; ++j) {
+                    result[j] = args[i + j];
+                }
+                return result;
+            }
+            if (arg.equals("-help") || arg.equals("-h")
+                || arg.equals("--help"))
+            {
+                printHelp = true;
+                return null;
+            }
+
+            try {
+                if (arg.equals("-version") && ++i < args.length) {
+                    int version = Integer.parseInt(args[i]);
+                    compilerEnv.setLanguageVersion(version);
+                    continue;
+                }
+                if ((arg.equals("-opt") || arg.equals("-O"))  &&
+                    ++i < args.length)
+                {
+                    int optLevel = Integer.parseInt(args[i]);
+                    compilerEnv.setOptimizationLevel(optLevel);
+                    continue;
+                }
+            }
+            catch (NumberFormatException e) {
+                badUsage(args[i]);
+                return null;
+            }
+            if (arg.equals("-nosource")) {
+                compilerEnv.setGeneratingSource(false);
+                continue;
+            }
+            if (arg.equals("-debug") || arg.equals("-g")) {
+                compilerEnv.setGenerateDebugInfo(true);
+                continue;
+            }
+            if (arg.equals("-main-method-class") && ++i < args.length) {
+                compiler.setMainMethodClass(args[i]);
+                continue;
+            }
+            if (arg.equals("-o") && ++i < args.length) {
+                String name = args[i];
+                int end = name.length();
+                if (end == 0
+                    || !Character.isJavaIdentifierStart(name.charAt(0)))
+                {
+                    addError("msg.invalid.classfile.name", name);
+                    continue;
+                }
+                for (int j = 1; j < end; j++) {
+                    char c = name.charAt(j);
+                    if (!Character.isJavaIdentifierPart(c)) {
+                        if (c == '.') {
+                            // check if it is the dot in .class
+                            if (j == end - 6 && name.endsWith(".class")) {
+                                name = name.substring(0, j);
+                                break;
+                            }
+                        }
+                        addError("msg.invalid.classfile.name", name);
+                        break;
+                    }
+                }
+                targetName = name;
+                continue;
+            }
+            if (arg.equals("-observe-instruction-count")) {
+                compilerEnv.setGenerateObserverCount(true);
+            }
+            if (arg.equals("-package") && ++i < args.length) {
+                String pkg = args[i];
+                int end = pkg.length();
+                for (int j = 0; j != end; ++j) {
+                    char c = pkg.charAt(j);
+                    if (Character.isJavaIdentifierStart(c)) {
+                        for (++j; j != end; ++j) {
+                            c = pkg.charAt(j);
+                            if (!Character.isJavaIdentifierPart(c)) {
+                                break;
+                            }
+                        }
+                        if (j == end) {
+                            break;
+                        }
+                        if (c == '.' && j != end - 1) {
+                            continue;
+                        }
+                    }
+                    addError("msg.package.name", targetPackage);
+                    return null;
+                }
+                targetPackage = pkg;
+                continue;
+            }
+            if (arg.equals("-extends") && ++i < args.length) {
+                String targetExtends = args[i];
+                Class superClass;
+                try {
+                    superClass = Class.forName(targetExtends);
+                } catch (ClassNotFoundException e) {
+                    throw new Error(e.toString()); // TODO: better error
+                }
+                compiler.setTargetExtends(superClass);
+                continue;
+            }
+            if (arg.equals("-implements") && ++i < args.length) {
+                // TODO: allow for multiple comma-separated interfaces.
+                String targetImplements = args[i];
+                StringTokenizer st = new StringTokenizer(targetImplements,
+                                                         ",");
+                Vector v = new Vector();
+                while (st.hasMoreTokens()) {
+                    String className = st.nextToken();
+                    try {
+                        v.addElement(Class.forName(className));
+                    } catch (ClassNotFoundException e) {
+                        throw new Error(e.toString()); // TODO: better error
+                    }
+                }
+                Class[] implementsClasses = new Class[v.size()];
+                v.copyInto(implementsClasses);
+                compiler.setTargetImplements(implementsClasses);
+                continue;
+            }
+            if (arg.equals("-d") && ++i < args.length) {
+                destinationDir = args[i];
+                continue;
+            }
+            badUsage(arg);
+            return null;
+        }
+        // no file name
+        p(ToolErrorReporter.getMessage("msg.no.file"));
+        return null;
+    }
+    /**
+     * Print a usage message.
+     */
+    private static void badUsage(String s) {
+        System.err.println(ToolErrorReporter.getMessage(
+            "msg.jsc.bad.usage", Main.class.getName(), s));
+    }
+
+    /**
+     * Compile JavaScript source.
+     *
+     */
+    public void processSource(String[] filenames)
+    {
+        for (int i = 0; i != filenames.length; ++i) {
+            String filename = filenames[i];
+            if (!filename.endsWith(".js")) {
+                addError("msg.extension.not.js", filename);
+                return;
+            }
+            File f = new File(filename);
+            String source = readSource(f);
+            if (source == null) return;
+
+            String mainClassName = targetName;
+            if (mainClassName == null) {
+                String name = f.getName();
+                String nojs = name.substring(0, name.length() - 3);
+                mainClassName = getClassName(nojs);
+            }
+            if (targetPackage.length() != 0) {
+                mainClassName = targetPackage+"."+mainClassName;
+            }
+
+            Object[] compiled
+                = compiler.compileToClassFiles(source, filename, 1,
+                                               mainClassName);
+            if (compiled == null || compiled.length == 0) {
+                return;
+            }
+
+            File targetTopDir = null;
+            if (destinationDir != null) {
+                targetTopDir = new File(destinationDir);
+            } else {
+                String parent = f.getParent();
+                if (parent != null) {
+                    targetTopDir = new File(parent);
+                }
+            }
+            for (int j = 0; j != compiled.length; j += 2) {
+                String className = (String)compiled[j];
+                byte[] bytes = (byte[])compiled[j + 1];
+                File outfile = getOutputFile(targetTopDir, className);
+                try {
+                    FileOutputStream os = new FileOutputStream(outfile);
+                    try {
+                        os.write(bytes);
+                    } finally {
+                        os.close();
+                    }
+                } catch (IOException ioe) {
+                    addFormatedError(ioe.toString());
+                }
+            }
+        }
+    }
+
+    private String readSource(File f)
+    {
+        if (!f.exists()) {
+            addError("msg.jsfile.not.found", f.getAbsolutePath());
+            return null;
+        }
+        try {
+            Reader in = new FileReader(f);
+            try {
+                return Kit.readReader(in);
+            } finally {
+                in.close();
+            }
+        } catch (FileNotFoundException ex) {
+            addError("msg.couldnt.open", f.getAbsolutePath());
+        } catch (IOException ioe) {
+            addFormatedError(ioe.toString());
+        }
+        return null;
+    }
+
+    private File getOutputFile(File parentDir, String className)
+    {
+        String path = className.replace('.', File.separatorChar);
+        path = path.concat(".class");
+        File f = new File(parentDir, path);
+        String dirPath = f.getParent();
+        if (dirPath != null) {
+            File dir = new File(dirPath);
+            if (!dir.exists()) {
+                dir.mkdirs();
+            }
+        }
+        return f;
+    }
+
+    /**
+     * Verify that class file names are legal Java identifiers.  Substitute
+     * illegal characters with underscores, and prepend the name with an
+     * underscore if the file name does not begin with a JavaLetter.
+     */
+
+    String getClassName(String name) {
+        char[] s = new char[name.length()+1];
+        char c;
+        int j = 0;
+
+        if (!Character.isJavaIdentifierStart(name.charAt(0))) {
+            s[j++] = '_';
+        }
+        for (int i=0; i < name.length(); i++, j++) {
+            c = name.charAt(i);
+            if ( Character.isJavaIdentifierPart(c) ) {
+                s[j] = c;
+            } else {
+                s[j] = '_';
+            }
+        }
+        return (new String(s)).trim();
+     }
+
+    private static void p(String s) {
+        System.out.println(s);
+    }
+
+    private void addError(String messageId, String arg)
+    {
+        String msg;
+        if (arg == null) {
+            msg = ToolErrorReporter.getMessage(messageId);
+        } else {
+            msg = ToolErrorReporter.getMessage(messageId, arg);
+        }
+        addFormatedError(msg);
+    }
+
+    private void addFormatedError(String message)
+    {
+        reporter.error(message, null, -1, null, -1);
+    }
+
+    private boolean printHelp;
+    private ToolErrorReporter reporter;
+    private CompilerEnvirons compilerEnv;
+    private ClassCompiler compiler;
+    private String targetName;
+    private String targetPackage;
+    private String destinationDir;
+}
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/resources/Messages.properties b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/resources/Messages.properties
new file mode 100644
index 0000000..76615e9
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/resources/Messages.properties
@@ -0,0 +1,268 @@
+#
+# JavaScript tools messages file.
+#
+# ***** BEGIN LICENSE BLOCK *****
+# Version: MPL 1.1/GPL 2.0
+#
+# The contents of this file are subject to the Mozilla Public License Version
+# 1.1 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+# http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+# for the specific language governing rights and limitations under the
+# License.
+#
+# The Original Code is Rhino code, released
+# May 6, 1999.
+#
+# The Initial Developer of the Original Code is
+# Netscape Communications Corporation.
+# Portions created by the Initial Developer are Copyright (C) 1997-1999
+# the Initial Developer. All Rights Reserved.
+#
+# Contributor(s):
+#
+# Alternatively, the contents of this file may be used under the terms of
+# the GNU General Public License Version 2 or later (the "GPL"), in which
+# case the provisions of the GPL are applicable instead of those above. If
+# you wish to allow use of your version of this file only under the terms of
+# the GPL and not to allow others to use your version of this file under the
+# MPL, indicate your decision by deleting the provisions above and replacing
+# them with the notice and other provisions required by the GPL. If you do
+# not delete the provisions above, a recipient may use your version of this
+# file under either the MPL or the GPL.
+#
+# ***** END LICENSE BLOCK *****
+
+msg.expected.string.arg =\
+    Expected a string argument.
+
+msg.class.not.found =\
+    Class "{0}" not found.
+
+msg.couldnt.open =\
+    Couldn''t open file "{0}".
+
+msg.couldnt.open.url =\
+    Couldn''t open URL "{0}: {1}".
+
+msg.no-opt =\
+    Must have the org.mozilla.javascript.optimizer package available \
+    to compile to class files.
+
+msg.shell.invalid =\
+    Invalid option "{0}"
+
+msg.shell.usage =\
+    Usage: java {0} [options...] [files]\n\
+    Valid options are:\n\
+    \    -?, -help          Displays help messages.\n\
+    \    -w                 Enable warnings.\n\
+    \    -version 100|110|120|130|140|150|160|170\n\
+    \                       Set a specific language version.\n\
+    \    -opt [-1|0-9]      Set optimization level.\n\
+    \    -f script-filename Execute script file.\n\
+    \    -e script-source   Evaluate inline script.\n\
+    \    -debug             Generate debug code.\n\
+    \    -strict            Enable strict mode warnings.\n\
+    \    -fatal-warnings    Treat warnings as errors.
+
+msg.help =\
+    \n\
+    Command                Description \n\
+    =======                =========== \n\
+    help()                 Display usage and help messages. \n\
+    defineClass(className) Define an extension using the Java class \n\
+    \                       named with the string argument. \n\
+    \                       Uses ScriptableObject.defineClass(). \n\
+    load(["foo.js", ...])  Load JavaScript source files named by \n\
+    \                       string arguments. \n\
+    loadClass(className)   Load a class named by a string argument. \n\
+    \                       The class must be a script compiled to a \n\
+    \                       class file. \n\
+    print([expr ...])      Evaluate and print expressions. \n\
+    quit()                 Quit the shell. \n\
+    version([number])      Get or set the JavaScript version number. \n\
+    gc()                   Runs the garbage collector.\n\
+    spawn(arg)             Evaluate function or scriptname on a new thread \n\
+    sync(function)         Creates a synchronized version of the function, \n\
+    \                       where the synchronization object is "this" \n\
+    readFile(fileName [, encoding])\n\
+    \                       Returns the content of the file as a string. \n\
+    \                       Encoding of the string can be optionally specified. \n\
+    readUrl(url [, encoding]) \n\
+    \                       Similar to readFile, reads the contents of the url.\n\
+    runCommand(name ...)   Runs a specified shell command. Additional arguments are \n\
+    \                       passed to the command \n\
+    seal(args ...)         Seals the supplied objects \n\
+    toint32(arg)           Converts the argument into a 32-bit integer \n\
+    serialize(obj, fileName) \n\
+    \                      Serializes an object and saves it to a file \n\
+    deserialise(fileName)  Reconstructs a serialized object \n\
+    environment            Returns the current environment object \n\
+    history                Displays the shell command history \n\
+    \n\
+    For full description of all available commands see shell.html in\n\
+    the docs directory of Rhino distribution.\n\
+
+msg.warning =\
+    warning: {0}
+
+msg.format1 =\
+    {0}
+
+msg.format2 =\
+    line {0}: {1}
+
+msg.format3 =\
+    "{0}", line {1}: {2}
+
+msg.uncaughtJSException =\
+    exception from uncaught JavaScript throw: {0}
+
+msg.uncaughtEcmaError =\
+    uncaught JavaScript runtime exception: {0}
+
+msg.jsc.bad.usage =\
+    Didn''t understand "{1}". \n\
+    For more information, try java {0} -h
+
+msg.jsc.usage =\
+Usage: java {0} [OPTION]... SOURCE...\n\
+Valid options are: \n\
+\  -version VERSION   Use the specified language version.\n\
+\                       VERSION should be one of 100|110|120|130|140|150|160|170.\n\
+\  -opt LEVEL         Use optimization with the specified level.\n\
+\                       LEVEL should be one of 0..9.\n\
+\  -debug, -g         Include debug information.\n\
+\  -nosource          Do not include source to function objects.\n\
+\                       It makes f.toString() useless and violates ECMAScript\n\
+\                       standard but makes generated classes smaller and\n\
+\                       saves memory.\n\
+\  -o CLASSNAME       Use specified name as the last component of the main\n\
+\                       generated class name. When specified, only one script\n\
+\                       SOURCE is allowed. If omitted, it defaults to source\n\
+\                       name with stripped .js suffix.\n\
+\  -package PACKAGE   Place generated classes in the specified package.\n\
+\  -d DIRECTORY       Use DIRECTORY as destination directory for generated\n\
+\                       classes. If omitted, it defaults to parent directory\n\
+\                       of SOURCE.\n\
+\  -extends CLASS     The main generated class will extend the specified\n\
+\                       class CLASS.\n\
+\  -implements INTERFACE1,INTERFACE2,... The main generated class will\n\
+\                       implement the specified list of interfaces.\n\
+\  -main-method-class CLASS Specify the class name used for main method \n\
+\                       implementation. The class must have a method matching\n\
+\                       "public static void main(Script sc, String[] args)"\n\
+\  -observe-instruction-count Generate code that contains callbacks to \n\
+\                       accumulate counts of executed instructions. Code \n\
+\                       compiled with this flag can be monitored using \n\
+\                       Context.setInstructionObserverThreshold. \n\
+\  -help, --help, -h  Print this help and exit.\n\
+
+
+msg.no.file =\
+    A file name must be specified to compile.
+
+msg.invalid.classfile.name =\
+    File "{0}" is not a valid class file name.
+
+msg.extension.not.js =\
+    File "{0}" is not a valid js file name.
+
+msg.jsfile.not.found=\
+    File "{0}" not found.
+
+msg.multiple.js.to.file =\
+    Cannot compile multiple js files to "{0}".
+
+msg.package.name =\
+    "{0}" is not a valid package name.
+
+msg.spawn.args =\
+    Argument to spawn() must be a function or script.
+
+msg.must.implement.Script =\
+    Argument to loadClass() must be the name of a class that implements \
+    the Script interface. Class files generated by compiling scripts \
+    will implement Script.
+
+msg.runCommand.bad.args =\
+    The first argument to runCommand must be a command name.
+
+msg.runCommand.bad.env =\
+    A value of the env property of option object for runCommnad must be an \
+    object.
+
+msg.shell.seal.not.object =\
+    seal function can only be applied to objects
+
+msg.shell.seal.not.scriptable =\
+    seal function supports only sealing of ScriptableObject instances
+
+msg.shell.readFile.bad.args =\
+    readFile require at least file path to be specified
+
+msg.shell.readUrl.bad.args =\
+    readUrl require at least file path to be specified
+
+msg.shell.bad.function.scope =\
+    Wrong scope object for shell function: {0}
+
+msg.idswitch.same_string =\
+    The string {0} is used second time in the switch code. \
+    Previous occurrence was at line {1}
+
+msg.idswitch.file_end_in_switch =\
+    End of file inside tag {0}
+
+msg.idswitch.bad_tag_order =\
+    String switch tag {0} is not allowed here
+
+msg.idswitch.no_end_with_value =\
+    End for tag {0} can not contain value
+
+msg.idswitch.no_value_allowed =\
+    Tag {0} can not contain value
+
+msg.idswitch.no_end_usage =\
+    Tag {0} can not be used as end tag
+
+msg.idswitch.no_file_argument =\
+    File argument should be given
+
+msg.idswitch.too_many_arguments =\
+    Too many arguments are given
+
+msg.idswitch.bad_option =\
+    Invalid option {0}
+
+msg.idswitch.bad_option_char =\
+    Invalid option letter {0}
+
+msg.idswitch.bad_invocation =\
+StringIdMap: {0}\n\
+For more information, try\n\
+java org.mozilla.javascript.tools.idswitch.StringIdMap --help
+
+msg.idswitch.io_error =\
+StringIdMap: IO error, {0}
+
+msg.idswitch.usage = \
+Usage: java org.mozilla.javascript.tools.idswitch.StringIdMap [OPTIONS] JAVA_SOURCE_FILE\n\
+Generates efficient string dispatch code in JAVA_SOURCE_FILE.\n\
+The resulting Java source fragment replaces the old dispatch code.\n\
+If JAVA_SOURCE_FILE is -, standard input is used for Java source and the\n\
+result is sent to standard output.\n\
+\n\
+\  -h, --help          display this help and exit\n\
+\      --version       display version information and exit\n\
+\n\
+Note: the original file will be overwritten without any backup actions\n\
+\      and all code inside #generated# tag will be replaced by new one.
+
+msg.idswitch.version = \
+org.mozilla.javascript.tools.idswitch.StringIdMap version 0.2
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ConsoleTextArea.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ConsoleTextArea.java
new file mode 100644
index 0000000..08cac62
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ConsoleTextArea.java
@@ -0,0 +1,300 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * See Beyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Christopher Oliver
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.shell;
+import java.io.*;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.text.Document;
+import javax.swing.text.Segment;
+
+class ConsoleWrite implements Runnable {
+    private ConsoleTextArea textArea;
+    private String str;
+
+    public ConsoleWrite(ConsoleTextArea textArea, String str) {
+        this.textArea = textArea;
+        this.str = str;
+    }
+
+    public void run() {
+        textArea.write(str);
+    }
+}
+
+class ConsoleWriter extends java.io.OutputStream {
+
+    private ConsoleTextArea textArea;
+    private StringBuffer buffer;
+
+    public ConsoleWriter(ConsoleTextArea textArea) {
+        this.textArea = textArea;
+        buffer = new StringBuffer();
+    }
+
+    public synchronized void write(int ch) {
+        buffer.append((char)ch);
+        if(ch == '\n') {
+            flushBuffer();
+        }
+    }
+
+    public synchronized void write (char[] data, int off, int len) {
+        for(int i = off; i < len; i++) {
+            buffer.append(data[i]);
+            if(data[i] == '\n') {
+                flushBuffer();
+            }
+        }
+    }
+
+    public synchronized void flush() {
+        if (buffer.length() > 0) {
+            flushBuffer();
+        }
+    }
+
+    public void close () {
+        flush();
+    }
+
+    private void flushBuffer() {
+        String str = buffer.toString();
+        buffer.setLength(0);
+        SwingUtilities.invokeLater(new ConsoleWrite(textArea, str));
+    }
+}
+
+public class ConsoleTextArea
+    extends JTextArea implements KeyListener, DocumentListener
+{
+    static final long serialVersionUID = 8557083244830872961L;
+
+    private ConsoleWriter console1;
+    private ConsoleWriter console2;
+    private PrintStream out;
+    private PrintStream err;
+    private PrintWriter inPipe;
+    private PipedInputStream in;
+    private java.util.Vector history;
+    private int historyIndex = -1;
+    private int outputMark = 0;
+
+    public void select(int start, int end) {
+        requestFocus();
+        super.select(start, end);
+    }
+
+    public ConsoleTextArea(String[] argv) {
+        super();
+        history = new java.util.Vector();
+        console1 = new ConsoleWriter(this);
+        console2 = new ConsoleWriter(this);
+        out = new PrintStream(console1);
+        err = new PrintStream(console2);
+        PipedOutputStream outPipe = new PipedOutputStream();
+        inPipe = new PrintWriter(outPipe);
+        in = new PipedInputStream();
+        try {
+            outPipe.connect(in);
+        } catch(IOException exc) {
+            exc.printStackTrace();
+        }
+        getDocument().addDocumentListener(this);
+        addKeyListener(this);
+        setLineWrap(true);
+        setFont(new Font("Monospaced", 0, 12));
+    }
+
+
+    synchronized void returnPressed() {
+        Document doc = getDocument();
+        int len = doc.getLength();
+        Segment segment = new Segment();
+        try {
+            doc.getText(outputMark, len - outputMark, segment);
+        } catch(javax.swing.text.BadLocationException ignored) {
+            ignored.printStackTrace();
+        }
+        if(segment.count > 0) {
+            history.addElement(segment.toString());
+        }
+        historyIndex = history.size();
+        inPipe.write(segment.array, segment.offset, segment.count);
+        append("\n");
+        outputMark = doc.getLength();
+        inPipe.write("\n");
+        inPipe.flush();
+        console1.flush();
+    }
+
+    public void eval(String str) {
+        inPipe.write(str);
+        inPipe.write("\n");
+        inPipe.flush();
+        console1.flush();
+    }
+
+    public void keyPressed(KeyEvent e) {
+        int code = e.getKeyCode();
+        if(code == KeyEvent.VK_BACK_SPACE || code == KeyEvent.VK_LEFT) {
+            if(outputMark == getCaretPosition()) {
+                e.consume();
+            }
+        } else if(code == KeyEvent.VK_HOME) {
+           int caretPos = getCaretPosition();
+           if(caretPos == outputMark) {
+               e.consume();
+           } else if(caretPos > outputMark) {
+               if(!e.isControlDown()) {
+                   if(e.isShiftDown()) {
+                       moveCaretPosition(outputMark);
+                   } else {
+                       setCaretPosition(outputMark);
+                   }
+                   e.consume();
+               }
+           }
+        } else if(code == KeyEvent.VK_ENTER) {
+            returnPressed();
+            e.consume();
+        } else if(code == KeyEvent.VK_UP) {
+            historyIndex--;
+            if(historyIndex >= 0) {
+                if(historyIndex >= history.size()) {
+                    historyIndex = history.size() -1;
+                }
+                if(historyIndex >= 0) {
+                    String str = (String)history.elementAt(historyIndex);
+                    int len = getDocument().getLength();
+                    replaceRange(str, outputMark, len);
+                    int caretPos = outputMark + str.length();
+                    select(caretPos, caretPos);
+                } else {
+                    historyIndex++;
+                }
+            } else {
+                historyIndex++;
+            }
+            e.consume();
+        } else if(code == KeyEvent.VK_DOWN) {
+            int caretPos = outputMark;
+            if(history.size() > 0) {
+                historyIndex++;
+                if(historyIndex < 0) {historyIndex = 0;}
+                int len = getDocument().getLength();
+                if(historyIndex < history.size()) {
+                    String str = (String)history.elementAt(historyIndex);
+                    replaceRange(str, outputMark, len);
+                    caretPos = outputMark + str.length();
+                } else {
+                    historyIndex = history.size();
+                    replaceRange("", outputMark, len);
+                }
+            }
+            select(caretPos, caretPos);
+            e.consume();
+        }
+    }
+
+    public void keyTyped(KeyEvent e) {
+        int keyChar = e.getKeyChar();
+        if(keyChar == 0x8 /* KeyEvent.VK_BACK_SPACE */) {
+            if(outputMark == getCaretPosition()) {
+                e.consume();
+            }
+        } else if(getCaretPosition() < outputMark) {
+            setCaretPosition(outputMark);
+        }
+    }
+
+    public synchronized void keyReleased(KeyEvent e) {
+    }
+
+    public synchronized void write(String str) {
+        insert(str, outputMark);
+        int len = str.length();
+        outputMark += len;
+        select(outputMark, outputMark);
+    }
+
+    public synchronized void insertUpdate(DocumentEvent e) {
+        int len = e.getLength();
+        int off = e.getOffset();
+        if(outputMark > off) {
+            outputMark += len;
+        }
+    }
+
+    public synchronized void removeUpdate(DocumentEvent e) {
+        int len = e.getLength();
+        int off = e.getOffset();
+        if(outputMark > off) {
+            if(outputMark >= off + len) {
+                outputMark -= len;
+            } else {
+                outputMark = off;
+            }
+        }
+    }
+
+    public synchronized void postUpdateUI() {
+        // this attempts to cleanup the damage done by updateComponentTreeUI
+        requestFocus();
+        setCaret(getCaret());
+        select(outputMark, outputMark);
+    }
+
+    public synchronized void changedUpdate(DocumentEvent e) {
+    }
+
+
+    public InputStream getIn() {
+        return in;
+    }
+
+    public PrintStream getOut() {
+        return out;
+    }
+
+    public PrintStream getErr() {
+        return err;
+    }
+
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Environment.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Environment.java
new file mode 100644
index 0000000..19904b9
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Environment.java
@@ -0,0 +1,141 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+        Environment.java
+
+        Wraps java.lang.System properties.
+
+        by Patrick C. Beard <beard@netscape.com>
+ */
+
+package org.mozilla.javascript.tools.shell;
+
+import org.mozilla.javascript.Scriptable;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.ScriptableObject;
+
+import java.util.Vector;
+import java.util.Enumeration;
+import java.util.Properties;
+
+/**
+ * Environment, intended to be instantiated at global scope, provides
+ * a natural way to access System properties from JavaScript.
+ *
+ * @author Patrick C. Beard
+ */
+public class Environment extends ScriptableObject
+{
+    static final long serialVersionUID = -430727378460177065L;
+
+    private Environment thePrototypeInstance = null;
+
+    public static void defineClass(ScriptableObject scope) {
+        try {
+            ScriptableObject.defineClass(scope, Environment.class);
+        } catch (Exception e) {
+            throw new Error(e.getMessage());
+        }
+    }
+
+    public String getClassName() {
+        return "Environment";
+    }
+
+    public Environment() {
+        if (thePrototypeInstance == null)
+            thePrototypeInstance = this;
+    }
+
+    public Environment(ScriptableObject scope) {
+        setParentScope(scope);
+        Object ctor = ScriptRuntime.getTopLevelProp(scope, "Environment");
+        if (ctor != null && ctor instanceof Scriptable) {
+            Scriptable s = (Scriptable) ctor;
+            setPrototype((Scriptable) s.get("prototype", s));
+        }
+    }
+
+    public boolean has(String name, Scriptable start) {
+        if (this == thePrototypeInstance)
+            return super.has(name, start);
+
+        return (System.getProperty(name) != null);
+    }
+
+    public Object get(String name, Scriptable start) {
+        if (this == thePrototypeInstance)
+            return super.get(name, start);
+
+        String result = System.getProperty(name);
+        if (result != null)
+            return ScriptRuntime.toObject(getParentScope(), result);
+        else
+            return Scriptable.NOT_FOUND;
+    }
+
+    public void put(String name, Scriptable start, Object value) {
+        if (this == thePrototypeInstance)
+            super.put(name, start, value);
+        else
+            System.getProperties().put(name, ScriptRuntime.toString(value));
+    }
+
+    private Object[] collectIds() {
+        Properties props = System.getProperties();
+        Enumeration names = props.propertyNames();
+        Vector keys = new Vector();
+        while (names.hasMoreElements())
+            keys.addElement(names.nextElement());
+        Object[] ids = new Object[keys.size()];
+        keys.copyInto(ids);
+        return ids;
+    }
+
+    public Object[] getIds() {
+        if (this == thePrototypeInstance)
+            return super.getIds();
+        return collectIds();
+    }
+
+    public Object[] getAllIds() {
+        if (this == thePrototypeInstance)
+            return super.getAllIds();
+        return collectIds();
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Global.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Global.java
new file mode 100644
index 0000000..fdb8f4e
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Global.java
@@ -0,0 +1,1038 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Patrick Beard
+ *   Igor Bukanov
+ *   Norris Boyd
+ *   Rob Ginda
+ *   Kurt Westerfeld
+ *   Matthias Radestock
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import java.io.*;
+import java.net.*;
+import java.lang.reflect.*;
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.tools.ToolErrorReporter;
+import org.mozilla.javascript.serialize.*;
+
+/**
+ * This class provides for sharing functions across multiple threads.
+ * This is of particular interest to server applications.
+ *
+ * @author Norris Boyd
+ */
+public class Global extends ImporterTopLevel
+{
+    static final long serialVersionUID = 4029130780977538005L;
+
+    NativeArray history;
+    private InputStream inStream;
+    private PrintStream outStream;
+    private PrintStream errStream;
+    private boolean sealedStdLib = false;
+    boolean initialized;
+    private QuitAction quitAction;
+    private String[] prompts = { "js> ", "  > " };
+
+    public Global()
+    {
+    }
+
+    public Global(Context cx)
+    {
+        init(cx);
+    }
+
+    public boolean isInitialized() {
+        return initialized;
+    }
+
+    /**
+     * Set the action to call from quit().
+     */
+    public void initQuitAction(QuitAction quitAction)
+    {
+        if (quitAction == null)
+            throw new IllegalArgumentException("quitAction is null");
+        if (this.quitAction != null)
+            throw new IllegalArgumentException("The method is once-call.");
+
+        this.quitAction = quitAction;
+    }
+
+    public void init(ContextFactory factory)
+    {
+        factory.call(new ContextAction() {
+                public Object run(Context cx)
+                {
+                    init(cx);
+                    return null;
+                }
+            });
+    }
+
+    public void init(Context cx)
+    {
+        // Define some global functions particular to the shell. Note
+        // that these functions are not part of ECMA.
+        initStandardObjects(cx, sealedStdLib);
+        String[] names = {
+            "defineClass",
+            "deserialize",
+            "gc",
+            "help",
+            "load",
+            "loadClass",
+            "print",
+            "quit",
+            "readFile",
+            "readUrl",
+            "runCommand",
+            "seal",
+            "serialize",
+            "spawn",
+            "sync",
+            "toint32",
+            "version",
+        };
+        defineFunctionProperties(names, Global.class,
+                                 ScriptableObject.DONTENUM);
+
+        // Set up "environment" in the global scope to provide access to the
+        // System environment variables.
+        Environment.defineClass(this);
+        Environment environment = new Environment(this);
+        defineProperty("environment", environment,
+                       ScriptableObject.DONTENUM);
+
+        history = (NativeArray) cx.newArray(this, 0);
+        defineProperty("history", history, ScriptableObject.DONTENUM);
+        initialized = true;
+    }
+
+    /**
+     * Print a help message.
+     *
+     * This method is defined as a JavaScript function.
+     */
+    public static void help(Context cx, Scriptable thisObj,
+                            Object[] args, Function funObj)
+    {
+        PrintStream out = getInstance(funObj).getOut();
+        out.println(ToolErrorReporter.getMessage("msg.help"));
+    }
+
+    public static void gc(Context cx, Scriptable thisObj,
+            Object[] args, Function funObj)
+    {
+        System.gc();
+    }
+
+
+    /**
+     * Print the string values of its arguments.
+     *
+     * This method is defined as a JavaScript function.
+     * Note that its arguments are of the "varargs" form, which
+     * allows it to handle an arbitrary number of arguments
+     * supplied to the JavaScript function.
+     *
+     */
+    public static Object print(Context cx, Scriptable thisObj,
+                               Object[] args, Function funObj)
+    {
+        PrintStream out = getInstance(funObj).getOut();
+        for (int i=0; i < args.length; i++) {
+            if (i > 0)
+                out.print(" ");
+
+            // Convert the arbitrary JavaScript value into a string form.
+            String s = Context.toString(args[i]);
+
+            out.print(s);
+        }
+        out.println();
+        return Context.getUndefinedValue();
+    }
+
+    /**
+     * Call embedding-specific quit action passing its argument as
+     * int32 exit code.
+     *
+     * This method is defined as a JavaScript function.
+     */
+    public static void quit(Context cx, Scriptable thisObj,
+                            Object[] args, Function funObj)
+    {
+        Global global = getInstance(funObj);
+        if (global.quitAction != null) {
+            int exitCode = (args.length == 0 ? 0
+                            : ScriptRuntime.toInt32(args[0]));
+            global.quitAction.quit(cx, exitCode);
+        }
+    }
+
+    /**
+     * Get and set the language version.
+     *
+     * This method is defined as a JavaScript function.
+     */
+    public static double version(Context cx, Scriptable thisObj,
+                                 Object[] args, Function funObj)
+    {
+        double result = cx.getLanguageVersion();
+        if (args.length > 0) {
+            double d = Context.toNumber(args[0]);
+            cx.setLanguageVersion((int) d);
+        }
+        return result;
+    }
+
+    /**
+     * Load and execute a set of JavaScript source files.
+     *
+     * This method is defined as a JavaScript function.
+     *
+     */
+    public static void load(Context cx, Scriptable thisObj,
+                            Object[] args, Function funObj)
+    {
+        for (int i = 0; i < args.length; i++) {
+            Main.processFile(cx, thisObj, Context.toString(args[i]));
+        }
+    }
+
+    /**
+     * Load a Java class that defines a JavaScript object using the
+     * conventions outlined in ScriptableObject.defineClass.
+     * <p>
+     * This method is defined as a JavaScript function.
+     * @exception IllegalAccessException if access is not available
+     *            to a reflected class member
+     * @exception InstantiationException if unable to instantiate
+     *            the named class
+     * @exception InvocationTargetException if an exception is thrown
+     *            during execution of methods of the named class
+     * @see org.mozilla.javascript.ScriptableObject#defineClass(Scriptable,Class)
+     */
+    public static void defineClass(Context cx, Scriptable thisObj,
+                                   Object[] args, Function funObj)
+        throws IllegalAccessException, InstantiationException,
+               InvocationTargetException
+    {
+        Class clazz = getClass(args);
+        ScriptableObject.defineClass(thisObj, clazz);
+    }
+
+    /**
+     * Load and execute a script compiled to a class file.
+     * <p>
+     * This method is defined as a JavaScript function.
+     * When called as a JavaScript function, a single argument is
+     * expected. This argument should be the name of a class that
+     * implements the Script interface, as will any script
+     * compiled by jsc.
+     *
+     * @exception IllegalAccessException if access is not available
+     *            to the class
+     * @exception InstantiationException if unable to instantiate
+     *            the named class
+     */
+    public static void loadClass(Context cx, Scriptable thisObj,
+                                 Object[] args, Function funObj)
+        throws IllegalAccessException, InstantiationException
+    {
+        Class clazz = getClass(args);
+        if (!Script.class.isAssignableFrom(clazz)) {
+            throw reportRuntimeError("msg.must.implement.Script");
+        }
+        Script script = (Script) clazz.newInstance();
+        script.exec(cx, thisObj);
+    }
+
+    private static Class getClass(Object[] args) {
+        if (args.length == 0) {
+            throw reportRuntimeError("msg.expected.string.arg");
+        }
+        Object arg0 = args[0];
+        if (arg0 instanceof Wrapper) {
+            Object wrapped = ((Wrapper)arg0).unwrap();
+            if (wrapped instanceof Class)
+                return (Class)wrapped;
+        }
+        String className = Context.toString(args[0]);
+        try {
+            return Class.forName(className);
+        }
+        catch (ClassNotFoundException cnfe) {
+            throw reportRuntimeError("msg.class.not.found", className);
+        }
+    }
+
+    public static void serialize(Context cx, Scriptable thisObj,
+                                 Object[] args, Function funObj)
+        throws IOException
+    {
+        if (args.length < 2) {
+            throw Context.reportRuntimeError(
+                "Expected an object to serialize and a filename to write " +
+                "the serialization to");
+        }
+        Object obj = args[0];
+        String filename = Context.toString(args[1]);
+        FileOutputStream fos = new FileOutputStream(filename);
+        Scriptable scope = ScriptableObject.getTopLevelScope(thisObj);
+        ScriptableOutputStream out = new ScriptableOutputStream(fos, scope);
+        out.writeObject(obj);
+        out.close();
+    }
+
+    public static Object deserialize(Context cx, Scriptable thisObj,
+                                     Object[] args, Function funObj)
+        throws IOException, ClassNotFoundException
+    {
+        if (args.length < 1) {
+            throw Context.reportRuntimeError(
+                "Expected a filename to read the serialization from");
+        }
+        String filename = Context.toString(args[0]);
+        FileInputStream fis = new FileInputStream(filename);
+        Scriptable scope = ScriptableObject.getTopLevelScope(thisObj);
+        ObjectInputStream in = new ScriptableInputStream(fis, scope);
+        Object deserialized = in.readObject();
+        in.close();
+        return Context.toObject(deserialized, scope);
+    }
+    
+    public String[] getPrompts(Context cx) {
+        if (ScriptableObject.hasProperty(this, "prompts")) {
+            Object promptsJS = ScriptableObject.getProperty(this,
+                                                            "prompts");
+            if (promptsJS instanceof Scriptable) {
+                Scriptable s = (Scriptable) promptsJS;
+                if (ScriptableObject.hasProperty(s, 0) &&
+                    ScriptableObject.hasProperty(s, 1))
+                {
+                    Object elem0 = ScriptableObject.getProperty(s, 0);
+                    if (elem0 instanceof Function) {
+                        elem0 = ((Function) elem0).call(cx, this, s,
+                                new Object[0]);
+                    }
+                    prompts[0] = Context.toString(elem0);
+                    Object elem1 = ScriptableObject.getProperty(s, 1);
+                    if (elem1 instanceof Function) {
+                        elem1 = ((Function) elem1).call(cx, this, s,
+                                new Object[0]);
+                    }
+                    prompts[1] = Context.toString(elem1);
+                }
+            }
+        }
+        return prompts;
+    }    
+
+    /**
+     * The spawn function runs a given function or script in a different
+     * thread.
+     *
+     * js> function g() { a = 7; }
+     * js> a = 3;
+     * 3
+     * js> spawn(g)
+     * Thread[Thread-1,5,main]
+     * js> a
+     * 3
+     */
+    public static Object spawn(Context cx, Scriptable thisObj, Object[] args,
+                               Function funObj)
+    {
+        Scriptable scope = funObj.getParentScope();
+        Runner runner;
+        if (args.length != 0 && args[0] instanceof Function) {
+            Object[] newArgs = null;
+            if (args.length > 1 && args[1] instanceof Scriptable) {
+                newArgs = cx.getElements((Scriptable) args[1]);
+            }
+            if (newArgs == null) { newArgs = ScriptRuntime.emptyArgs; }
+            runner = new Runner(scope, (Function) args[0], newArgs);
+        } else if (args.length != 0 && args[0] instanceof Script) {
+            runner = new Runner(scope, (Script) args[0]);
+        } else {
+            throw reportRuntimeError("msg.spawn.args");
+        }
+        runner.factory = cx.getFactory();
+        Thread thread = new Thread(runner);
+        thread.start();
+        return thread;
+    }
+
+    /**
+     * The sync function creates a synchronized function (in the sense
+     * of a Java synchronized method) from an existing function. The
+     * new function synchronizes on the <code>this</code> object of
+     * its invocation.
+     * js> var o = { f : sync(function(x) {
+     *       print("entry");
+     *       Packages.java.lang.Thread.sleep(x*1000);
+     *       print("exit");
+     *     })};
+     * js> spawn(function() {o.f(5);});
+     * Thread[Thread-0,5,main]
+     * entry
+     * js> spawn(function() {o.f(5);});
+     * Thread[Thread-1,5,main]
+     * js>
+     * exit
+     * entry
+     * exit
+     */
+    public static Object sync(Context cx, Scriptable thisObj, Object[] args,
+                              Function funObj)
+    {
+        if (args.length == 1 && args[0] instanceof Function) {
+            return new Synchronizer((Function)args[0]);
+        }
+        else {
+            throw reportRuntimeError("msg.sync.args");
+        }
+    }
+
+    /**
+     * Execute the specified command with the given argument and options
+     * as a separate process and return the exit status of the process.
+     * <p>
+     * Usage:
+     * <pre>
+     * runCommand(command)
+     * runCommand(command, arg1, ..., argN)
+     * runCommand(command, arg1, ..., argN, options)
+     * </pre>
+     * All except the last arguments to runCommand are converted to strings
+     * and denote command name and its arguments. If the last argument is a
+     * JavaScript object, it is an option object. Otherwise it is converted to
+     * string denoting the last argument and options objects assumed to be
+     * empty.
+     * Te following properties of the option object are processed:
+     * <ul>
+     * <li><tt>args</tt> - provides an array of additional command arguments
+     * <li><tt>env</tt> - explicit environment object. All its enumeratable
+     *   properties define the corresponding environment variable names.
+     * <li><tt>input</tt> - the process input. If it is not
+     *   java.io.InputStream, it is converted to string and sent to the process
+     *   as its input. If not specified, no input is provided to the process.
+     * <li><tt>output</tt> - the process output instead of
+     *   java.lang.System.out. If it is not instance of java.io.OutputStream,
+     *   the process output is read, converted to a string, appended to the
+     *   output property value converted to string and put as the new value of
+     *   the output property.
+     * <li><tt>err</tt> - the process error output instead of
+     *   java.lang.System.err. If it is not instance of java.io.OutputStream,
+     *   the process error output is read, converted to a string, appended to
+     *   the err property value converted to string and put as the new
+     *   value of the err property.
+     * </ul>
+     */
+    public static Object runCommand(Context cx, Scriptable thisObj,
+                                    Object[] args, Function funObj)
+        throws IOException
+    {
+        int L = args.length;
+        if (L == 0 || (L == 1 && args[0] instanceof Scriptable)) {
+            throw reportRuntimeError("msg.runCommand.bad.args");
+        }
+
+        InputStream in = null;
+        OutputStream out = null, err = null;
+        ByteArrayOutputStream outBytes = null, errBytes = null;
+        Object outObj = null, errObj = null;
+        String[] environment = null;
+        Scriptable params = null;
+        Object[] addArgs = null;
+        if (args[L - 1] instanceof Scriptable) {
+            params = (Scriptable)args[L - 1];
+            --L;
+            Object envObj = ScriptableObject.getProperty(params, "env");
+            if (envObj != Scriptable.NOT_FOUND) {
+                if (envObj == null) {
+                    environment = new String[0];
+                } else {
+                    if (!(envObj instanceof Scriptable)) {
+                        throw reportRuntimeError("msg.runCommand.bad.env");
+                    }
+                    Scriptable envHash = (Scriptable)envObj;
+                    Object[] ids = ScriptableObject.getPropertyIds(envHash);
+                    environment = new String[ids.length];
+                    for (int i = 0; i != ids.length; ++i) {
+                        Object keyObj = ids[i], val;
+                        String key;
+                        if (keyObj instanceof String) {
+                            key = (String)keyObj;
+                            val = ScriptableObject.getProperty(envHash, key);
+                        } else {
+                            int ikey = ((Number)keyObj).intValue();
+                            key = Integer.toString(ikey);
+                            val = ScriptableObject.getProperty(envHash, ikey);
+                        }
+                        if (val == ScriptableObject.NOT_FOUND) {
+                            val = Undefined.instance;
+                        }
+                        environment[i] = key+'='+ScriptRuntime.toString(val);
+                    }
+                }
+            }
+            Object inObj = ScriptableObject.getProperty(params, "input");
+            if (inObj != Scriptable.NOT_FOUND) {
+                in = toInputStream(inObj);
+            }
+            outObj = ScriptableObject.getProperty(params, "output");
+            if (outObj != Scriptable.NOT_FOUND) {
+                out = toOutputStream(outObj);
+                if (out == null) {
+                    outBytes = new ByteArrayOutputStream();
+                    out = outBytes;
+                }
+            }
+            errObj = ScriptableObject.getProperty(params, "err");
+            if (errObj != Scriptable.NOT_FOUND) {
+                err = toOutputStream(errObj);
+                if (err == null) {
+                    errBytes = new ByteArrayOutputStream();
+                    err = errBytes;
+                }
+            }
+            Object addArgsObj = ScriptableObject.getProperty(params, "args");
+            if (addArgsObj != Scriptable.NOT_FOUND) {
+                Scriptable s = Context.toObject(addArgsObj,
+                                                getTopLevelScope(thisObj));
+                addArgs = cx.getElements(s);
+            }
+        }
+        Global global = getInstance(funObj);
+        if (out == null) {
+            out = (global != null) ? global.getOut() : System.out;
+        }
+        if (err == null) {
+            err = (global != null) ? global.getErr() : System.err;
+        }
+        // If no explicit input stream, do not send any input to process,
+        // in particular, do not use System.in to avoid deadlocks
+        // when waiting for user input to send to process which is already
+        // terminated as it is not always possible to interrupt read method.
+
+        String[] cmd = new String[(addArgs == null) ? L : L + addArgs.length];
+        for (int i = 0; i != L; ++i) {
+            cmd[i] = ScriptRuntime.toString(args[i]);
+        }
+        if (addArgs != null) {
+            for (int i = 0; i != addArgs.length; ++i) {
+                cmd[L + i] = ScriptRuntime.toString(addArgs[i]);
+            }
+        }
+
+        int exitCode = runProcess(cmd, environment, in, out, err);
+        if (outBytes != null) {
+            String s = ScriptRuntime.toString(outObj) + outBytes.toString();
+            ScriptableObject.putProperty(params, "output", s);
+        }
+        if (errBytes != null) {
+            String s = ScriptRuntime.toString(errObj) + errBytes.toString();
+            ScriptableObject.putProperty(params, "err", s);
+        }
+
+        return new Integer(exitCode);
+    }
+
+    /**
+     * The seal function seals all supplied arguments.
+     */
+    public static void seal(Context cx, Scriptable thisObj, Object[] args,
+                            Function funObj)
+    {
+        for (int i = 0; i != args.length; ++i) {
+            Object arg = args[i];
+            if (!(arg instanceof ScriptableObject) || arg == Undefined.instance)
+            {
+                if (!(arg instanceof Scriptable) || arg == Undefined.instance)
+                {
+                    throw reportRuntimeError("msg.shell.seal.not.object");
+                } else {
+                    throw reportRuntimeError("msg.shell.seal.not.scriptable");
+                }
+            }
+        }
+
+        for (int i = 0; i != args.length; ++i) {
+            Object arg = args[i];
+            ((ScriptableObject)arg).sealObject();
+        }
+    }
+
+    /**
+     * The readFile reads the given file content and convert it to a string
+     * using the specified character coding or default character coding if
+     * explicit coding argument is not given.
+     * <p>
+     * Usage:
+     * <pre>
+     * readFile(filePath)
+     * readFile(filePath, charCoding)
+     * </pre>
+     * The first form converts file's context to string using the default
+     * character coding.
+     */
+    public static Object readFile(Context cx, Scriptable thisObj, Object[] args,
+                                  Function funObj)
+        throws IOException
+    {
+        if (args.length == 0) {
+            throw reportRuntimeError("msg.shell.readFile.bad.args");
+        }
+        String path = ScriptRuntime.toString(args[0]);
+        String charCoding = null;
+        if (args.length >= 2) {
+            charCoding = ScriptRuntime.toString(args[1]);
+        }
+
+        return readUrl(path, charCoding, true);
+    }
+
+    /**
+     * The readUrl opens connection to the given URL, read all its data
+     * and converts them to a string
+     * using the specified character coding or default character coding if
+     * explicit coding argument is not given.
+     * <p>
+     * Usage:
+     * <pre>
+     * readUrl(url)
+     * readUrl(url, charCoding)
+     * </pre>
+     * The first form converts file's context to string using the default
+     * charCoding.
+     */
+    public static Object readUrl(Context cx, Scriptable thisObj, Object[] args,
+                                 Function funObj)
+        throws IOException
+    {
+        if (args.length == 0) {
+            throw reportRuntimeError("msg.shell.readUrl.bad.args");
+        }
+        String url = ScriptRuntime.toString(args[0]);
+        String charCoding = null;
+        if (args.length >= 2) {
+            charCoding = ScriptRuntime.toString(args[1]);
+        }
+
+        return readUrl(url, charCoding, false);
+    }
+
+    /**
+     * Convert the argumnet to int32 number.
+     */
+    public static Object toint32(Context cx, Scriptable thisObj, Object[] args,
+                                 Function funObj)
+    {
+        Object arg = (args.length != 0 ? args[0] : Undefined.instance);
+        if (arg instanceof Integer)
+            return arg;
+        return ScriptRuntime.wrapInt(ScriptRuntime.toInt32(arg));
+    }
+
+    public InputStream getIn() {
+        return inStream == null ? System.in : inStream;
+    }
+
+    public void setIn(InputStream in) {
+        inStream = in;
+    }
+
+    public PrintStream getOut() {
+        return outStream == null ? System.out : outStream;
+    }
+
+    public void setOut(PrintStream out) {
+        outStream = out;
+    }
+
+    public PrintStream getErr() {
+        return errStream == null ? System.err : errStream;
+    }
+
+    public void setErr(PrintStream err) {
+        errStream = err;
+    }
+
+    public void setSealedStdLib(boolean value)
+    {
+        sealedStdLib = value;
+    }
+
+    private static Global getInstance(Function function)
+    {
+        Scriptable scope = function.getParentScope();
+        if (!(scope instanceof Global))
+            throw reportRuntimeError("msg.bad.shell.function.scope",
+                                     String.valueOf(scope));
+        return (Global)scope;
+    }
+
+    /**
+     * Runs the given process using Runtime.exec().
+     * If any of in, out, err is null, the corresponding process stream will
+     * be closed immediately, otherwise it will be closed as soon as
+     * all data will be read from/written to process
+     *
+     * @return Exit value of process.
+     * @throws IOException If there was an error executing the process.
+     */
+    private static int runProcess(String[] cmd, String[] environment,
+                                  InputStream in, OutputStream out,
+                                  OutputStream err)
+        throws IOException
+    {
+        Process p;
+        if (environment == null) {
+            p = Runtime.getRuntime().exec(cmd);
+        } else {
+            p = Runtime.getRuntime().exec(cmd, environment);
+        }
+
+        try {
+            PipeThread inThread = null;
+            if (in != null) {
+                inThread = new PipeThread(false, in, p.getOutputStream());
+                inThread.start();
+            } else {
+                p.getOutputStream().close();
+            }
+
+            PipeThread outThread = null;
+            if (out != null) {
+                outThread = new PipeThread(true, p.getInputStream(), out);
+                outThread.start();
+            } else {
+                p.getInputStream().close();
+            }
+
+            PipeThread errThread = null;
+            if (err != null) {
+                errThread = new PipeThread(true, p.getErrorStream(), err);
+                errThread.start();
+            } else {
+                p.getErrorStream().close();
+            }
+
+            // wait for process completion
+            for (;;) {
+                try {
+                    p.waitFor();
+                    if (outThread != null) {
+                        outThread.join();
+                    }
+                    if (inThread != null) {
+                        inThread.join();
+                    }
+                    if (errThread != null) {
+                        errThread.join();
+                    }
+                    break;
+                } catch (InterruptedException ignore) {
+                }
+            }
+
+            return p.exitValue();
+        } finally {
+            p.destroy();
+        }
+    }
+
+    static void pipe(boolean fromProcess, InputStream from, OutputStream to)
+        throws IOException
+    {
+        try {
+            final int SIZE = 4096;
+            byte[] buffer = new byte[SIZE];
+            for (;;) {
+                int n;
+                if (!fromProcess) {
+                    n = from.read(buffer, 0, SIZE);
+                } else {
+                    try {
+                        n = from.read(buffer, 0, SIZE);
+                    } catch (IOException ex) {
+                        // Ignore exception as it can be cause by closed pipe
+                        break;
+                    }
+                }
+                if (n < 0) { break; }
+                if (fromProcess) {
+                    to.write(buffer, 0, n);
+                    to.flush();
+                } else {
+                    try {
+                        to.write(buffer, 0, n);
+                        to.flush();
+                    } catch (IOException ex) {
+                        // Ignore exception as it can be cause by closed pipe
+                        break;
+                    }
+                }
+            }
+        } finally {
+            try {
+                if (fromProcess) {
+                    from.close();
+                } else {
+                    to.close();
+                }
+            } catch (IOException ex) {
+                // Ignore errors on close. On Windows JVM may throw invalid
+                // refrence exception if process terminates too fast.
+            }
+        }
+    }
+
+    private static InputStream toInputStream(Object value)
+        throws IOException
+    {
+        InputStream is = null;
+        String s = null;
+        if (value instanceof Wrapper) {
+            Object unwrapped = ((Wrapper)value).unwrap();
+            if (unwrapped instanceof InputStream) {
+                is = (InputStream)unwrapped;
+            } else if (unwrapped instanceof byte[]) {
+                is = new ByteArrayInputStream((byte[])unwrapped);
+            } else if (unwrapped instanceof Reader) {
+                s = readReader((Reader)unwrapped);
+            } else if (unwrapped instanceof char[]) {
+                s = new String((char[])unwrapped);
+            }
+        }
+        if (is == null) {
+            if (s == null) { s = ScriptRuntime.toString(value); }
+            is = new ByteArrayInputStream(s.getBytes());
+        }
+        return is;
+    }
+
+    private static OutputStream toOutputStream(Object value) {
+        OutputStream os = null;
+        if (value instanceof Wrapper) {
+            Object unwrapped = ((Wrapper)value).unwrap();
+            if (unwrapped instanceof OutputStream) {
+                os = (OutputStream)unwrapped;
+            }
+        }
+        return os;
+    }
+
+    private static String readUrl(String filePath, String charCoding,
+                                  boolean urlIsFile)
+        throws IOException
+    {
+        int chunkLength;
+        InputStream is = null;
+        try {
+            if (!urlIsFile) {
+                URL urlObj = new URL(filePath);
+                URLConnection uc = urlObj.openConnection();
+                is = uc.getInputStream();
+                chunkLength = uc.getContentLength();
+                if (chunkLength <= 0)
+                    chunkLength = 1024;
+                if (charCoding == null) {
+                    String type = uc.getContentType();
+                    if (type != null) {
+                        charCoding = getCharCodingFromType(type);
+                    }
+                }
+            } else {
+                File f = new File(filePath);
+
+                long length = f.length();
+                chunkLength = (int)length;
+                if (chunkLength != length)
+                    throw new IOException("Too big file size: "+length);
+
+                if (chunkLength == 0) { return ""; }
+
+                is = new FileInputStream(f);
+            }
+
+            Reader r;
+            if (charCoding == null) {
+                r = new InputStreamReader(is);
+            } else {
+                r = new InputStreamReader(is, charCoding);
+            }
+            return readReader(r, chunkLength);
+
+        } finally {
+            if (is != null)
+                is.close();
+        }
+    }
+
+    private static String getCharCodingFromType(String type)
+    {
+        int i = type.indexOf(';');
+        if (i >= 0) {
+            int end = type.length();
+            ++i;
+            while (i != end && type.charAt(i) <= ' ') {
+                ++i;
+            }
+            String charset = "charset";
+            if (charset.regionMatches(true, 0, type, i, charset.length()))
+            {
+                i += charset.length();
+                while (i != end && type.charAt(i) <= ' ') {
+                    ++i;
+                }
+                if (i != end && type.charAt(i) == '=') {
+                    ++i;
+                    while (i != end && type.charAt(i) <= ' ') {
+                        ++i;
+                    }
+                    if (i != end) {
+                        // i is at the start of non-empty
+                        // charCoding spec
+                        while (type.charAt(end -1) <= ' ') {
+                            --end;
+                        }
+                        return type.substring(i, end);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+
+    private static String readReader(Reader reader)
+        throws IOException
+    {
+        return readReader(reader, 4096);
+    }
+
+    private static String readReader(Reader reader, int initialBufferSize)
+        throws IOException
+    {
+        char[] buffer = new char[initialBufferSize];
+        int offset = 0;
+        for (;;) {
+            int n = reader.read(buffer, offset, buffer.length - offset);
+            if (n < 0) { break;    }
+            offset += n;
+            if (offset == buffer.length) {
+                char[] tmp = new char[buffer.length * 2];
+                System.arraycopy(buffer, 0, tmp, 0, offset);
+                buffer = tmp;
+            }
+        }
+        return new String(buffer, 0, offset);
+    }
+
+    static RuntimeException reportRuntimeError(String msgId) {
+        String message = ToolErrorReporter.getMessage(msgId);
+        return Context.reportRuntimeError(message);
+    }
+
+    static RuntimeException reportRuntimeError(String msgId, String msgArg)
+    {
+        String message = ToolErrorReporter.getMessage(msgId, msgArg);
+        return Context.reportRuntimeError(message);
+    }
+}
+
+
+class Runner implements Runnable, ContextAction {
+
+    Runner(Scriptable scope, Function func, Object[] args) {
+        this.scope = scope;
+        f = func;
+        this.args = args;
+    }
+
+    Runner(Scriptable scope, Script script) {
+        this.scope = scope;
+        s = script;
+    }
+
+    public void run()
+    {
+        factory.call(this);
+    }
+
+    public Object run(Context cx)
+    {
+        if (f != null)
+            return f.call(cx, scope, scope, args);
+        else
+            return s.exec(cx, scope);
+    }
+
+    ContextFactory factory;
+    private Scriptable scope;
+    private Function f;
+    private Script s;
+    private Object[] args;
+}
+
+class PipeThread extends Thread {
+
+    PipeThread(boolean fromProcess, InputStream from, OutputStream to) {
+        setDaemon(true);
+        this.fromProcess = fromProcess;
+        this.from = from;
+        this.to = to;
+    }
+
+    public void run() {
+        try {
+            Global.pipe(fromProcess, from, to);
+        } catch (IOException ex) {
+            throw Context.throwAsScriptRuntimeEx(ex);
+        }
+    }
+
+    private boolean fromProcess;
+    private InputStream from;
+    private OutputStream to;
+}
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JSConsole.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JSConsole.java
new file mode 100644
index 0000000..f6fe3a1
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JSConsole.java
@@ -0,0 +1,225 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino JavaScript Debugger code, released
+ * November 21, 2000.
+ *
+ * The Initial Developer of the Original Code is
+ * See Beyond Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Christopher Oliver
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+package org.mozilla.javascript.tools.shell;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.File;
+
+import javax.swing.ButtonGroup;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JRadioButtonMenuItem;
+import javax.swing.JScrollPane;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+
+import org.mozilla.javascript.SecurityUtilities;
+
+public class JSConsole extends JFrame implements ActionListener
+{
+    static final long serialVersionUID = 2551225560631876300L;
+
+    private File CWD;
+    private JFileChooser dlg;
+    private ConsoleTextArea consoleTextArea;
+
+    public String chooseFile() {
+        if(CWD == null) {
+            String dir = SecurityUtilities.getSystemProperty("user.dir");
+            if(dir != null) {
+                CWD = new File(dir);
+            }
+        }
+        if(CWD != null) {
+            dlg.setCurrentDirectory(CWD);
+        }
+        dlg.setDialogTitle("Select a file to load");
+        int returnVal = dlg.showOpenDialog(this);
+        if(returnVal == JFileChooser.APPROVE_OPTION) {
+            String result = dlg.getSelectedFile().getPath();
+            CWD = new File(dlg.getSelectedFile().getParent());
+            return result;
+        }
+        return null;
+    }
+
+    public static void main(String args[]) {
+        new JSConsole(args);
+    }
+
+    public void createFileChooser() {
+        dlg = new JFileChooser();
+        javax.swing.filechooser.FileFilter filter =
+            new javax.swing.filechooser.FileFilter() {
+                    public boolean accept(File f) {
+                        if(f.isDirectory()) {
+                            return true;
+                        }
+                        String name = f.getName();
+                        int i = name.lastIndexOf('.');
+                        if(i > 0 && i < name.length() -1) {
+                            String ext = name.substring(i + 1).toLowerCase();
+                            if(ext.equals("js")) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+
+                    public String getDescription() {
+                        return "JavaScript Files (*.js)";
+                    }
+                };
+        dlg.addChoosableFileFilter(filter);
+
+    }
+
+    public JSConsole(String[] args) {
+        super("Rhino JavaScript Console");
+        JMenuBar menubar = new JMenuBar();
+        createFileChooser();
+        String[] fileItems  = {"Load...", "Exit"};
+        String[] fileCmds  = {"Load", "Exit"};
+        char[] fileShortCuts = {'L', 'X'};
+        String[] editItems = {"Cut", "Copy", "Paste"};
+        char[] editShortCuts = {'T', 'C', 'P'};
+        String[] plafItems = {"Metal", "Windows", "Motif"};
+        boolean [] plafState = {true, false, false};
+        JMenu fileMenu = new JMenu("File");
+        fileMenu.setMnemonic('F');
+        JMenu editMenu = new JMenu("Edit");
+        editMenu.setMnemonic('E');
+        JMenu plafMenu = new JMenu("Platform");
+        plafMenu.setMnemonic('P');
+        for(int i = 0; i < fileItems.length; ++i) {
+            JMenuItem item = new JMenuItem(fileItems[i],
+                                           fileShortCuts[i]);
+            item.setActionCommand(fileCmds[i]);
+            item.addActionListener(this);
+            fileMenu.add(item);
+        }
+        for(int i = 0; i < editItems.length; ++i) {
+            JMenuItem item = new JMenuItem(editItems[i],
+                                           editShortCuts[i]);
+            item.addActionListener(this);
+            editMenu.add(item);
+        }
+        ButtonGroup group = new ButtonGroup();
+        for(int i = 0; i < plafItems.length; ++i) {
+            JRadioButtonMenuItem item = new JRadioButtonMenuItem(plafItems[i],
+                                                                 plafState[i]);
+            group.add(item);
+            item.addActionListener(this);
+            plafMenu.add(item);
+        }
+        menubar.add(fileMenu);
+        menubar.add(editMenu);
+        menubar.add(plafMenu);
+        setJMenuBar(menubar);
+        consoleTextArea = new ConsoleTextArea(args);
+        JScrollPane scroller = new JScrollPane(consoleTextArea);
+        setContentPane(scroller);
+        consoleTextArea.setRows(24);
+        consoleTextArea.setColumns(80);
+        addWindowListener(new WindowAdapter() {
+                public void windowClosing(WindowEvent e) {
+                    System.exit(0);
+                }
+            });
+        pack();
+        setVisible(true);
+        // System.setIn(consoleTextArea.getIn());
+        // System.setOut(consoleTextArea.getOut());
+        // System.setErr(consoleTextArea.getErr());
+        Main.setIn(consoleTextArea.getIn());
+        Main.setOut(consoleTextArea.getOut());
+        Main.setErr(consoleTextArea.getErr());
+        Main.main(args);
+    }
+
+    public void actionPerformed(ActionEvent e) {
+        String cmd = e.getActionCommand();
+        String plaf_name = null;
+        if(cmd.equals("Load")) {
+            String f = chooseFile();
+            if(f != null) {
+                f = f.replace('\\', '/');
+                consoleTextArea.eval("load(\"" + f + "\");");
+            }
+        } else if(cmd.equals("Exit")) {
+            System.exit(0);
+        } else if(cmd.equals("Cut")) {
+            consoleTextArea.cut();
+        } else if(cmd.equals("Copy")) {
+            consoleTextArea.copy();
+        } else if(cmd.equals("Paste")) {
+            consoleTextArea.paste();
+        } else {
+            if(cmd.equals("Metal")) {
+                plaf_name = "javax.swing.plaf.metal.MetalLookAndFeel";
+            } else if(cmd.equals("Windows")) {
+                plaf_name = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
+            } else if(cmd.equals("Motif")) {
+                plaf_name = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
+            }
+            if(plaf_name != null) {
+                try {
+                    UIManager.setLookAndFeel(plaf_name);
+                    SwingUtilities.updateComponentTreeUI(this);
+                    consoleTextArea.postUpdateUI();
+                    // updateComponentTreeUI seems to mess up the file
+                    // chooser dialog, so just create a new one
+                    createFileChooser();
+                } catch(Exception exc) {
+                    JOptionPane.showMessageDialog(this,
+                                                  exc.getMessage(),
+                                                  "Platform",
+                                                  JOptionPane.ERROR_MESSAGE);
+                }
+            }
+        }
+
+    }
+
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java
new file mode 100644
index 0000000..de39a5e
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/JavaPolicySecurity.java
@@ -0,0 +1,240 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import java.security.*;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Enumeration;
+
+import org.mozilla.javascript.*;
+
+public class JavaPolicySecurity extends SecurityProxy
+{
+
+    public Class getStaticSecurityDomainClassInternal() {
+        return ProtectionDomain.class;
+    }
+
+    private static class Loader extends ClassLoader
+        implements GeneratedClassLoader
+    {
+        private ProtectionDomain domain;
+
+        Loader(ClassLoader parent, ProtectionDomain domain) {
+            super(parent != null ? parent : getSystemClassLoader());
+            this.domain = domain;
+        }
+
+        public Class defineClass(String name, byte[] data) {
+            return super.defineClass(name, data, 0, data.length, domain);
+        }
+
+        public void linkClass(Class cl) {
+            resolveClass(cl);
+        }
+    }
+
+    private static class ContextPermissions extends PermissionCollection
+    {
+        static final long serialVersionUID = -1721494496320750721L;
+
+// Construct PermissionCollection that permits an action only
+// if it is permitted by staticDomain and by security context of Java stack on
+// the moment of constructor invocation
+        ContextPermissions(ProtectionDomain staticDomain) {
+            _context = AccessController.getContext();
+            if (staticDomain != null) {
+                _statisPermissions = staticDomain.getPermissions();
+            }
+            setReadOnly();
+        }
+
+        public void add(Permission permission) {
+            throw new RuntimeException("NOT IMPLEMENTED");
+        }
+
+        public boolean implies(Permission permission) {
+            if (_statisPermissions != null) {
+                if (!_statisPermissions.implies(permission)) {
+                    return false;
+                }
+            }
+            try {
+                _context.checkPermission(permission);
+                return true;
+            }catch (AccessControlException ex) {
+                return false;
+            }
+        }
+
+        public Enumeration elements()
+        {
+            return new Enumeration() {
+                public boolean hasMoreElements() { return false; }
+                public Object nextElement() { return null; }
+            };
+        }
+
+        public String toString() {
+            StringBuffer sb = new StringBuffer();
+            sb.append(getClass().getName());
+            sb.append('@');
+            sb.append(Integer.toHexString(System.identityHashCode(this)));
+            sb.append(" (context=");
+            sb.append(_context);
+            sb.append(", static_permitions=");
+            sb.append(_statisPermissions);
+            sb.append(')');
+            return sb.toString();
+        }
+
+        AccessControlContext _context;
+        PermissionCollection _statisPermissions;
+    }
+
+    public JavaPolicySecurity()
+    {
+        // To trigger error on jdk-1.1 with lazy load
+        new CodeSource(null,  (java.security.cert.Certificate[])null);
+    }
+
+    protected void callProcessFileSecure(final Context cx,
+                                         final Scriptable scope,
+                                         final String filename)
+    {
+        AccessController.doPrivileged(new PrivilegedAction() {
+            public Object run() {
+                URL url = getUrlObj(filename);
+                ProtectionDomain staticDomain = getUrlDomain(url);
+                Main.processFileSecure(cx, scope, url.toExternalForm(),
+                                       staticDomain);
+                return null;
+            }
+        });
+    }
+
+    private URL getUrlObj(String url)
+    {
+        URL urlObj;
+        try {
+            urlObj = new URL(url);
+        } catch (MalformedURLException ex) {
+            // Assume as Main.processFileSecure it is file, need to build its
+            // URL
+            String curDir = System.getProperty("user.dir");
+            curDir = curDir.replace('\\', '/');
+            if (!curDir.endsWith("/")) {
+                curDir = curDir+'/';
+            }
+            try {
+                URL curDirURL = new URL("file:"+curDir);
+                urlObj = new URL(curDirURL, url);
+            } catch (MalformedURLException ex2) {
+                throw new RuntimeException
+                    ("Can not construct file URL for '"+url+"':"
+                     +ex2.getMessage());
+            }
+        }
+        return urlObj;
+    }
+
+    private ProtectionDomain getUrlDomain(URL url)
+    {
+        CodeSource cs;
+        cs = new CodeSource(url, (java.security.cert.Certificate[])null);
+        PermissionCollection pc = Policy.getPolicy().getPermissions(cs);
+        return new ProtectionDomain(cs, pc);
+    }
+
+    public GeneratedClassLoader
+    createClassLoader(ClassLoader parentLoader, Object securityDomain)
+    {
+        ProtectionDomain domain = (ProtectionDomain)securityDomain;
+        return new Loader(parentLoader, domain);
+    }
+
+    public Object getDynamicSecurityDomain(Object securityDomain)
+    {
+        ProtectionDomain staticDomain = (ProtectionDomain)securityDomain;
+        return getDynamicDomain(staticDomain);
+    }
+
+    private ProtectionDomain getDynamicDomain(ProtectionDomain staticDomain) {
+        ContextPermissions p = new ContextPermissions(staticDomain);
+        ProtectionDomain contextDomain = new ProtectionDomain(null, p);
+        return contextDomain;
+    }
+
+    public Object callWithDomain(Object securityDomain,
+                                 final Context cx,
+                                 final Callable callable,
+                                 final Scriptable scope,
+                                 final Scriptable thisObj,
+                                 final Object[] args)
+    {
+        ProtectionDomain staticDomain = (ProtectionDomain)securityDomain;
+        // There is no direct way in Java to intersect permitions according
+        // stack context with additional domain.
+        // The following implementation first constructs ProtectionDomain
+        // that allows actions only allowed by both staticDomain and current
+        // stack context, and then constructs AccessController for this dynamic
+        // domain.
+        // If this is too slow, alternative solution would be to generate
+        // class per domain with a proxy method to call to infect
+        // java stack.
+        // Another optimization in case of scripts coming from "world" domain,
+        // that is having minimal default privileges is to construct
+        // one AccessControlContext based on ProtectionDomain
+        // with least possible privileges and simply call
+        // AccessController.doPrivileged with this untrusted context
+
+        ProtectionDomain dynamicDomain = getDynamicDomain(staticDomain);
+        ProtectionDomain[] tmp = { dynamicDomain };
+        AccessControlContext restricted = new AccessControlContext(tmp);
+
+        PrivilegedAction action = new PrivilegedAction() {
+            public Object run() {
+                return callable.call(cx, scope, thisObj, args);
+            }
+        };
+
+        return AccessController.doPrivileged(action, restricted);
+    }
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Main.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Main.java
new file mode 100644
index 0000000..9120892
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/Main.java
@@ -0,0 +1,638 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Patrick Beard
+ *   Norris Boyd
+ *   Igor Bukanov
+ *   Rob Ginda
+ *   Kurt Westerfeld
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import java.io.*;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.MalformedURLException;
+import java.util.*;
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.tools.ToolErrorReporter;
+
+/**
+ * The shell program.
+ *
+ * Can execute scripts interactively or in batch mode at the command line.
+ * An example of controlling the JavaScript engine.
+ *
+ * @author Norris Boyd
+ */
+public class Main
+{
+    public static ShellContextFactory
+        shellContextFactory = new ShellContextFactory();
+
+    public static Global global = new Global();
+    static protected ToolErrorReporter errorReporter;
+    static protected int exitCode = 0;
+    static private final int EXITCODE_RUNTIME_ERROR = 3;
+    static private final int EXITCODE_FILE_NOT_FOUND = 4;
+    static boolean processStdin = true;
+    static Vector fileList = new Vector(5);
+    private static SecurityProxy securityImpl;
+
+    static {
+        global.initQuitAction(new IProxy(IProxy.SYSTEM_EXIT));
+    }
+
+    /**
+     * Proxy class to avoid proliferation of anonymous classes.
+     */
+    private static class IProxy implements ContextAction, QuitAction
+    {
+        private static final int PROCESS_FILES = 1;
+        private static final int EVAL_INLINE_SCRIPT = 2;
+        private static final int SYSTEM_EXIT = 3;
+
+        private int type;
+        String[] args;
+        String scriptText;
+
+        IProxy(int type)
+        {
+            this.type = type;
+        }
+
+        public Object run(Context cx)
+        {
+            if (type == PROCESS_FILES) {
+                processFiles(cx, args);
+            } else if (type == EVAL_INLINE_SCRIPT) {
+                Script script = loadScriptFromSource(cx, scriptText,
+                                                     "<command>", 1, null);
+                if (script != null) {
+                    evaluateScript(script, cx, getGlobal());
+                }
+            } else {
+                throw Kit.codeBug();
+            }
+            return null;
+        }
+
+        public void quit(Context cx, int exitCode)
+        {
+            if (type == SYSTEM_EXIT) {
+                System.exit(exitCode);
+                return;
+            }
+            throw Kit.codeBug();
+        }
+    }
+
+    /**
+     * Main entry point.
+     *
+     * Process arguments as would a normal Java program. Also
+     * create a new Context and associate it with the current thread.
+     * Then set up the execution environment and begin to
+     * execute scripts.
+     */
+    public static void main(String args[]) {
+        try {
+            if (Boolean.getBoolean("rhino.use_java_policy_security")) {
+                initJavaPolicySecuritySupport();
+            }
+        } catch (SecurityException ex) {
+            ex.printStackTrace(System.err);
+        }
+
+        int result = exec(args);
+        if (result != 0) {
+            System.exit(result);
+        }
+    }
+
+    /**
+     *  Execute the given arguments, but don't System.exit at the end.
+     */
+    public static int exec(String origArgs[])
+    {
+        errorReporter = new ToolErrorReporter(false, global.getErr());
+        shellContextFactory.setErrorReporter(errorReporter);
+        String[] args = processOptions(origArgs);
+        if (processStdin)
+            fileList.addElement(null);
+
+        if (!global.initialized) {
+            global.init(shellContextFactory);
+        }
+        IProxy iproxy = new IProxy(IProxy.PROCESS_FILES);
+        iproxy.args = args;
+        shellContextFactory.call(iproxy);
+
+        return exitCode;
+    }
+
+    static void processFiles(Context cx, String[] args)
+    {
+        // define "arguments" array in the top-level object:
+        // need to allocate new array since newArray requires instances
+        // of exactly Object[], not ObjectSubclass[]
+        Object[] array = new Object[args.length];
+        System.arraycopy(args, 0, array, 0, args.length);
+        Scriptable argsObj = cx.newArray(global, array);
+        global.defineProperty("arguments", argsObj,
+                              ScriptableObject.DONTENUM);
+
+        for (int i=0; i < fileList.size(); i++) {
+            processSource(cx, (String) fileList.elementAt(i));
+        }
+
+    }
+
+    public static Global getGlobal()
+    {
+        return global;
+    }
+
+    /**
+     * Parse arguments.
+     */
+    public static String[] processOptions(String args[])
+    {
+        String usageError;
+        goodUsage: for (int i = 0; ; ++i) {
+            if (i == args.length) {
+                return new String[0];
+            }
+            String arg = args[i];
+            if (!arg.startsWith("-")) {
+                processStdin = false;
+                fileList.addElement(arg);
+                String[] result = new String[args.length - i - 1];
+                System.arraycopy(args, i+1, result, 0, args.length - i - 1);
+                return result;
+            }
+            if (arg.equals("-version")) {
+                if (++i == args.length) {
+                    usageError = arg;
+                    break goodUsage;
+                }
+                int version;
+                try {
+                    version = Integer.parseInt(args[i]);
+                } catch (NumberFormatException ex) {
+                    usageError = args[i];
+                    break goodUsage;
+                }
+                if (!Context.isValidLanguageVersion(version)) {
+                    usageError = args[i];
+                    break goodUsage;
+                }
+                shellContextFactory.setLanguageVersion(version);
+                continue;
+            }
+            if (arg.equals("-opt") || arg.equals("-O")) {
+                if (++i == args.length) {
+                    usageError = arg;
+                    break goodUsage;
+                }
+                int opt;
+                try {
+                    opt = Integer.parseInt(args[i]);
+                } catch (NumberFormatException ex) {
+                    usageError = args[i];
+                    break goodUsage;
+                }
+                if (opt == -2) {
+                    // Compatibility with Cocoon Rhino fork
+                    opt = -1;
+                } else if (!Context.isValidOptimizationLevel(opt)) {
+                    usageError = args[i];
+                    break goodUsage;
+                }
+                shellContextFactory.setOptimizationLevel(opt);
+                continue;
+            }
+            if (arg.equals("-strict")) {
+                shellContextFactory.setStrictMode(true);
+                errorReporter.setIsReportingWarnings(true);
+                continue;
+            }
+            if (arg.equals("-fatal-warnings")) {
+                shellContextFactory.setWarningAsError(true);
+                continue;
+            }
+            if (arg.equals("-e")) {
+                processStdin = false;
+                if (++i == args.length) {
+                    usageError = arg;
+                    break goodUsage;
+                }
+                if (!global.initialized) {
+                    global.init(shellContextFactory);
+                }
+                IProxy iproxy = new IProxy(IProxy.EVAL_INLINE_SCRIPT);
+                iproxy.scriptText = args[i];
+                shellContextFactory.call(iproxy);
+                continue;
+            }
+            if (arg.equals("-w")) {
+                errorReporter.setIsReportingWarnings(true);
+                continue;
+            }
+            if (arg.equals("-f")) {
+                processStdin = false;
+                if (++i == args.length) {
+                    usageError = arg;
+                    break goodUsage;
+                }
+                fileList.addElement(args[i].equals("-") ? null : args[i]);
+                continue;
+            }
+            if (arg.equals("-sealedlib")) {
+                global.setSealedStdLib(true);
+                continue;
+            }
+            if (arg.equals("-debug")) {
+                shellContextFactory.setGeneratingDebug(true);
+                continue;
+            }
+            if (arg.equals("-?") ||
+                arg.equals("-help")) {
+                // print usage message
+                global.getOut().println(
+                    ToolErrorReporter.getMessage("msg.shell.usage", Main.class.getName()));
+                System.exit(1);
+            }
+            usageError = arg;
+            break goodUsage;
+        }
+        // print error and usage message
+        global.getOut().println(
+            ToolErrorReporter.getMessage("msg.shell.invalid", usageError));
+        global.getOut().println(
+            ToolErrorReporter.getMessage("msg.shell.usage", Main.class.getName()));
+        System.exit(1);
+        return null;
+    }
+
+    private static void initJavaPolicySecuritySupport()
+    {
+        Throwable exObj;
+        try {
+            Class cl = Class.forName
+                ("org.mozilla.javascript.tools.shell.JavaPolicySecurity");
+            securityImpl = (SecurityProxy)cl.newInstance();
+            SecurityController.initGlobal(securityImpl);
+            return;
+        } catch (ClassNotFoundException ex) {
+            exObj = ex;
+        } catch (IllegalAccessException ex) {
+            exObj = ex;
+        } catch (InstantiationException ex) {
+            exObj = ex;
+        } catch (LinkageError ex) {
+            exObj = ex;
+        }
+        throw Kit.initCause(new IllegalStateException(
+            "Can not load security support: "+exObj), exObj);
+    }
+
+    /**
+     * Evaluate JavaScript source.
+     *
+     * @param cx the current context
+     * @param filename the name of the file to compile, or null
+     *                 for interactive mode.
+     */
+    public static void processSource(Context cx, String filename)
+    {
+        if (filename == null || filename.equals("-")) {
+            PrintStream ps = global.getErr();
+            if (filename == null) {
+                // print implementation version
+                ps.println(cx.getImplementationVersion());
+            }
+
+            // Use the interpreter for interactive input
+            cx.setOptimizationLevel(-1);
+
+            BufferedReader in = new BufferedReader
+                (new InputStreamReader(global.getIn()));
+            int lineno = 1;
+            boolean hitEOF = false;
+            while (!hitEOF) {
+            	String[] prompts = global.getPrompts(cx);
+                if (filename == null)
+                    ps.print(prompts[0]);
+                ps.flush();
+                String source = "";
+
+                // Collect lines of source to compile.
+                while (true) {
+                    String newline;
+                    try {
+                        newline = in.readLine();
+                    }
+                    catch (IOException ioe) {
+                        ps.println(ioe.toString());
+                        break;
+                    }
+                    if (newline == null) {
+                        hitEOF = true;
+                        break;
+                    }
+                    source = source + newline + "\n";
+                    lineno++;
+                    if (cx.stringIsCompilableUnit(source))
+                        break;
+                    ps.print(prompts[1]);
+                }
+                Script script = loadScriptFromSource(cx, source, "<stdin>",
+                                                     lineno, null);
+                if (script != null) {
+                    Object result = evaluateScript(script, cx, global);
+                    // Avoid printing out undefined or function definitions.
+                    if (result != Context.getUndefinedValue() &&
+                        !(result instanceof Function &&
+                          source.trim().startsWith("function")))
+                    {
+                        try {
+                            ps.println(Context.toString(result));
+                        } catch (RhinoException rex) {
+                            ToolErrorReporter.reportException(
+                                cx.getErrorReporter(), rex);
+                        }
+                    }
+                    NativeArray h = global.history;
+                    h.put((int)h.getLength(), h, source);
+                }
+            }
+            ps.println();
+        } else {
+            processFile(cx, global, filename);
+        }
+        System.gc();
+    }
+
+    public static void processFile(Context cx, Scriptable scope,
+                                   String filename)
+    {
+        if (securityImpl == null) {
+            processFileSecure(cx, scope, filename, null);
+        } else {
+            securityImpl.callProcessFileSecure(cx, scope, filename);
+        }
+    }
+
+    static void processFileSecure(Context cx, Scriptable scope,
+                                  String path, Object securityDomain)
+    {
+        Script script;
+        if (path.endsWith(".class")) {
+            script = loadCompiledScript(cx, path, securityDomain);
+        } else {
+            String source = (String)readFileOrUrl(path, true);
+            if (source == null) {
+                exitCode = EXITCODE_FILE_NOT_FOUND;
+                return;
+            }
+
+            // Support the executable script #! syntax:  If
+            // the first line begins with a '#', treat the whole
+            // line as a comment.
+            if (source.length() > 0 && source.charAt(0) == '#') {
+                for (int i = 1; i != source.length(); ++i) {
+                    int c = source.charAt(i);
+                    if (c == '\n' || c == '\r') {
+                        source = source.substring(i);
+                        break;
+                    }
+                }
+            }
+            script = loadScriptFromSource(cx, source, path, 1, securityDomain);
+        }
+        if (script != null) {
+            evaluateScript(script, cx, scope);
+        }
+    }
+
+    public static Script loadScriptFromSource(Context cx, String scriptSource,
+                                              String path, int lineno,
+                                              Object securityDomain)
+    {
+        try {
+            return cx.compileString(scriptSource, path, lineno,
+                                    securityDomain);
+        } catch (EvaluatorException ee) {
+            // Already printed message.
+            exitCode = EXITCODE_RUNTIME_ERROR;
+        } catch (RhinoException rex) {
+            ToolErrorReporter.reportException(
+                cx.getErrorReporter(), rex);
+            exitCode = EXITCODE_RUNTIME_ERROR;
+        } catch (VirtualMachineError ex) {
+            // Treat StackOverflow and OutOfMemory as runtime errors
+            ex.printStackTrace();
+            String msg = ToolErrorReporter.getMessage(
+                "msg.uncaughtJSException", ex.toString());
+            exitCode = EXITCODE_RUNTIME_ERROR;
+            Context.reportError(msg);
+        }
+        return null;
+    }
+
+    private static Script loadCompiledScript(Context cx, String path,
+                                             Object securityDomain)
+    {
+        byte[] data = (byte[])readFileOrUrl(path, false);
+        if (data == null) {
+            exitCode = EXITCODE_FILE_NOT_FOUND;
+            return null;
+        }
+        // XXX: For now extract class name of compiled Script from path
+        // instead of parsing class bytes
+        int nameStart = path.lastIndexOf('/');
+        if (nameStart < 0) {
+            nameStart = 0;
+        } else {
+            ++nameStart;
+        }
+        int nameEnd = path.lastIndexOf('.');
+        if (nameEnd < nameStart) {
+            // '.' does not exist in path (nameEnd < 0)
+            // or it comes before nameStart
+            nameEnd = path.length();
+        }
+        String name = path.substring(nameStart, nameEnd);
+        try {
+            GeneratedClassLoader loader = SecurityController.createLoader(cx.getApplicationClassLoader(), securityDomain);
+            Class clazz = loader.defineClass(name, data);
+            loader.linkClass(clazz);
+            if (!Script.class.isAssignableFrom(clazz)) {
+                throw Context.reportRuntimeError("msg.must.implement.Script");
+            }
+            return (Script) clazz.newInstance();
+         } catch (RhinoException rex) {
+            ToolErrorReporter.reportException(
+                cx.getErrorReporter(), rex);
+            exitCode = EXITCODE_RUNTIME_ERROR;
+        } catch (IllegalAccessException iaex) {
+            exitCode = EXITCODE_RUNTIME_ERROR;
+            Context.reportError(iaex.toString());
+        } catch (InstantiationException inex) {
+            exitCode = EXITCODE_RUNTIME_ERROR;
+            Context.reportError(inex.toString());
+        }
+        return null;
+    }
+
+    public static Object evaluateScript(Script script, Context cx,
+                                        Scriptable scope)
+    {
+        try {
+            return script.exec(cx, scope);
+        } catch (RhinoException rex) {
+            ToolErrorReporter.reportException(
+                cx.getErrorReporter(), rex);
+            exitCode = EXITCODE_RUNTIME_ERROR;
+        } catch (VirtualMachineError ex) {
+            // Treat StackOverflow and OutOfMemory as runtime errors
+            ex.printStackTrace();
+            String msg = ToolErrorReporter.getMessage(
+                "msg.uncaughtJSException", ex.toString());
+            exitCode = EXITCODE_RUNTIME_ERROR;
+            Context.reportError(msg);
+        }
+        return Context.getUndefinedValue();
+    }
+
+    public static InputStream getIn() {
+        return getGlobal().getIn();
+    }
+
+    public static void setIn(InputStream in) {
+        getGlobal().setIn(in);
+    }
+
+    public static PrintStream getOut() {
+        return getGlobal().getOut();
+    }
+
+    public static void setOut(PrintStream out) {
+        getGlobal().setOut(out);
+    }
+
+    public static PrintStream getErr() {
+        return getGlobal().getErr();
+    }
+
+    public static void setErr(PrintStream err) {
+        getGlobal().setErr(err);
+    }
+
+    /**
+     * Read file or url specified by <tt>path</tt>.
+     * @return file or url content as <tt>byte[]</tt> or as <tt>String</tt> if
+     * <tt>convertToString</tt> is true.
+     */
+    private static Object readFileOrUrl(String path, boolean convertToString)
+    {
+        URL url = null;
+        // Assume path is URL if it contains dot and there are at least
+        // 2 characters in the protocol part. The later allows under Windows
+        // to interpret paths with driver letter as file, not URL.
+        if (path.indexOf(':') >= 2) {
+            try {
+                url = new URL(path);
+            } catch (MalformedURLException ex) {
+            }
+        }
+
+        InputStream is = null;
+        int capacityHint = 0;
+        if (url == null) {
+            File file = new File(path);
+            capacityHint = (int)file.length();
+            try {
+                is = new FileInputStream(file);
+            } catch (IOException ex) {
+                Context.reportError(ToolErrorReporter.getMessage(
+                    "msg.couldnt.open", path));
+                return null;
+            }
+        } else {
+            try {
+                URLConnection uc = url.openConnection();
+                is = uc.getInputStream();
+                capacityHint = uc.getContentLength();
+                // Ignore insane values for Content-Length
+                if (capacityHint > (1 << 20)) {
+                    capacityHint = -1;
+                }
+            } catch (IOException ex) {
+                Context.reportError(ToolErrorReporter.getMessage(
+                    "msg.couldnt.open.url", url.toString(), ex.toString()));
+                return null;
+            }
+        }
+        if (capacityHint <= 0) {
+            capacityHint = 4096;
+        }
+
+        byte[] data;
+        try {
+            try {
+                data = Kit.readStream(is, capacityHint);
+            } finally {
+                is.close();
+            }
+        } catch (IOException ex) {
+            Context.reportError(ex.toString());
+            return null;
+        }
+
+        Object result;
+        if (!convertToString) {
+            result = data;
+        } else {
+            // Convert to String using the default encoding
+            // XXX: Use 'charset=' argument of Content-Type if URL?
+            result = new String(data);
+        }
+        return result;
+    }
+
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/QuitAction.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/QuitAction.java
new file mode 100644
index 0000000..dcad90e
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/QuitAction.java
@@ -0,0 +1,50 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import org.mozilla.javascript.Context;
+
+/**
+ * Defines action to perform in response to quit command.
+ */
+public interface QuitAction
+{
+    public void quit(Context cx, int exitCode);
+}
+
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/SecurityProxy.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/SecurityProxy.java
new file mode 100644
index 0000000..8f029ea
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/SecurityProxy.java
@@ -0,0 +1,48 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import org.mozilla.javascript.*;
+
+public abstract class SecurityProxy extends SecurityController
+{
+    protected abstract void callProcessFileSecure(Context cx, Scriptable scope,
+                                                  String filename);
+
+}
diff --git a/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ShellContextFactory.java b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ShellContextFactory.java
new file mode 100644
index 0000000..ba7e62c
--- /dev/null
+++ b/infrastructure/rhino1_7R1/toolsrc/org/mozilla/javascript/tools/shell/ShellContextFactory.java
@@ -0,0 +1,114 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Bob Jervis
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.tools.shell;
+
+import org.mozilla.javascript.*;
+
+public class ShellContextFactory extends ContextFactory
+{
+    private boolean strictMode;
+    private boolean warningAsError;
+    private int languageVersion;
+    private int optimizationLevel;
+    private boolean generatingDebug;
+    private ErrorReporter errorReporter;
+
+    protected boolean hasFeature(Context cx, int featureIndex)
+    {
+        switch (featureIndex) {
+          case Context.FEATURE_STRICT_VARS:
+          case Context.FEATURE_STRICT_EVAL:
+          case Context.FEATURE_STRICT_MODE:
+            return strictMode;
+
+          case Context.FEATURE_WARNING_AS_ERROR:
+            return warningAsError;
+        }
+        return super.hasFeature(cx, featureIndex);
+    }
+
+    protected void onContextCreated(Context cx)
+    {
+        cx.setLanguageVersion(languageVersion);
+        cx.setOptimizationLevel(optimizationLevel);
+        if (errorReporter != null) {
+            cx.setErrorReporter(errorReporter);
+        }
+        cx.setGeneratingDebug(generatingDebug);
+        super.onContextCreated(cx);
+    }
+
+    public void setStrictMode(boolean flag)
+    {
+        checkNotSealed();
+        this.strictMode = flag;
+    }
+
+    public void setWarningAsError(boolean flag)
+    {
+        checkNotSealed();
+        this.warningAsError = flag;
+    }
+
+    public void setLanguageVersion(int version)
+    {
+        Context.checkLanguageVersion(version);
+        checkNotSealed();
+        this.languageVersion = version;
+    }
+
+    public void setOptimizationLevel(int optimizationLevel)
+    {
+        Context.checkOptimizationLevel(optimizationLevel);
+        checkNotSealed();
+        this.optimizationLevel = optimizationLevel;
+    }
+
+    public void setErrorReporter(ErrorReporter errorReporter)
+    {
+        if (errorReporter == null) throw new IllegalArgumentException();
+        this.errorReporter = errorReporter;
+    }
+
+    public void setGeneratingDebug(boolean generatingDebug)
+    {
+        this.generatingDebug = generatingDebug;
+    }
+}