This commit was manufactured by cvs2svn to create tag 'release_dec5'.

git-svn-id: svn://10.0.0.236/tags/release_dec5@55406 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/extensions/xmlterm/INSTALL

@@ -0,0 +1,170 @@
+INSTALL: Installation instructions for XMLterm source code
+----------------------------------------------------------
+
+*NOTE* This is work in progress. User beware!
+
+*NOTE* Check the XMLterm web site <http://xmlterm.org> for updates.
+
+29 Nov 1999
+
+In the following discussion, file and directory names are relative
+to the main ("mozilla/extensions/xmlterm") directory. See the end of the
+README file for a brief description of the subdirectories.
+
+
+1. Source tree (skip this step if XMLterm is already in the source tree)
+------------------------------------------------------------------------
+
+The XMLterm source code is distributed as a tarball, xmlterm.tar.gz
+
+This tar file needs to be untarred in the "mozilla/extensions" directory,
+or any any other "mozilla/dir" directory one level below the top-level.
+A subdirectory called "xmlterm" will be created there.
+("mozilla" denotes the root directory of the Mozilla source tree)
+
+If you have already untarred it elsewhere, simply move the "xmlterm" directory
+to the right place.
+
+
+2. Configuration
+----------------
+
+To recursively create all Makefiles from Makefile.in files, type the following:
+
+makemake -r
+
+The file "config/xmlterm_config.mk" contains XMLterm specific configuration
+information that is needed in addition to any Mozilla configuration
+information. It has already been hand-configured for Linux2.0/Linux2.2, and
+Solaris2.6 platforms. It may need to be modified slightly to compile XMLterm
+on other platforms.
+
+At present XMLterm has been tested only on Linux (RedHat6.0) and Solaris2.6
+platforms, using the M11 release as the base version of Mozilla.
+
+XMLterm typically uses the UNIX pseudo-TTY interface to communicate with the
+shell. At present, this interface is implemented only for Linux and Solaris
+platforms.
+
+XMLterm may compile on other Unix platforms, but it will use NSPR pipes,
+rather than a pseudo-TTY, for process communication; this means that the
+terminal control characters, such as Control-C for interrupting jobs, will not
+work on those platforms. (See the file doc/PORTABILITY for a discussion of
+portability issues)
+
+
+3. Creating the dynamically loaded XPCOM/XPCONNECT component
+------------------------------------------------------------
+
+To create the dynamically loaded XPCOM library, type the following in the main
+directory
+
+  make all
+
+This creates the self-registering library "libxmlterm.so" and installs it in
+the "mozilla/dist/bin/components" directory, along with some chrome
+files. After this step, the following interfaces become accessible in Mozilla
+through XPCOM/XPCONNECT:
+
+  mozIXMLTermShell     (interface to XMLterm)
+  mozILineTerm         (interface to the stand-alone LINETERM)
+
+To clean up completely, type
+
+ make clean
+
+
+4. Using the lightweight "xmlterm" stand-alone program
+----------------------------------------------------
+
+Step 3 creates an executable called "xmlterm" in the "mozilla/dist/bin"
+directory. This is a lightweight program implementing XMLterm using the Gecko
+layout engine only, without the added baggage of the full browser. Executing
+"xmlterm" will create an XMLterm window. Click on this window to give it focus
+before typing Unix commands.
+
+The command line can be edited using EMACS-style key bindings.
+Command completion should also work with TCSH and BASH, as should history
+recall.
+
+**NOTE**
+The command prompt is assumed to be terminated by one of the characters
+"#$%>?", followed by a space. If this is not the case, many features will not
+work. This restriction will be relaxed in the future.
+
+By default, blue coloring is used to indicate clickable display elements.
+Note that the prompt and the input command line are clickable.
+(Of course, the appearance of XMLterm is completely configurable
+using the CSS stylesheet chrome://xmlterm/skin/default/xmlterm.css)
+
+After typing one or two commands, click on the prompt string of any previous
+command to see what happens! Then click again on the same prompt string.
+Also click on "Hide all output" button at the top of the document.
+
+Clicking on a previous command line (to the right of the prompt) re-executes
+the command.
+
+The sample Perl script "xls", the iconic/hypertext version of the Unix "ls"
+command, is in the "tests" directory. Copy it to some directory in your path
+to use it.
+
+Note: At present, xmlterm only works with the GTK front end.
+
+
+5. Creating an XMLterm window using the browser
+-----------------------------------------------
+
+At this time, XMLterm cannot be accessed through the menu bar. Instead, load
+the URL "chrome://xmlterm/content/xmlterm.html" in the browser, either at the
+command line or by typing it in the URL box. Then click on the browser window
+with the mouse to shift focus and then start typing UNIX commands.
+
+
+6. Stand-alone mode (optional)
+------------------------------
+
+Although XMLterm resides in the Mozilla source tree, portions of it are
+capable of being compiled and linked completely independent of Mozilla. You
+may want to do this for testing purposes. The "config" directory contains
+make files that are used for this stand-alone mode. There is even a dumb
+script called "makemake" which can be used to re-create make files, if the
+corresponding Makefile.in files have been changed.
+
+*NOTE* The executable "lterm" requires the NCURSES include file "curses.h"
+
+To create the stand-alone executables, type
+
+ make STAND_ALONE=1 all
+
+(To clean up stand-alone modules, type "make STAND_ALONE=1 clean")
+
+This creates the stand-alone library in "base/lib" and some stand-alone
+executables in the "linetest/lib" directory, in particular, one called 
+"lterm".
+
+The executable "lterm" implements a line terminal (LINETERM), i.e., a
+non-graphical version of XMLterm. In the future, this may be implemented using
+NCURSES for full screen operation. At present, it only provides line-at-a-time
+functionality and is used only for testing.
+
+LINETERM acts as an "engine" for XMLterm, carrying out all the non-graphical
+tasks, completely independent of Mozilla. It is written in C and is licensed
+under both MPL and GPL. It provides functionality similar to the EMACS shell
+mode or the GNU readline package.
+
+LINETERM has various options where trace output may be redirected to a
+different TTY device, for debugging purposes. LINETERM may be used like the
+shell command "sh", e.g.,
+
+  prompt% lterm
+  prompt% ls
+         <listing>
+  prompt% exit
+
+The "tests/escape" program can be used to generate terminal escape sequences
+to test the XMLterm API. In particular, the following command enables
+extensive trace output, if executed within an XMLterm or LINETERM:
+
+  tests/escape 1 98 D
+
+-----------------------------------------------------------------------------

mozilla/extensions/xmlterm/Makefile.in

@@ -0,0 +1,78 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm root directory
+
+ifdef STAND_ALONE
+DEPTH      = .
+topsrcdir  = .
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../..
+topsrcdir  = @top_srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+
+# Debug option
+DEBUG = 1
+
+
+ifdef STAND_ALONE
+
+DIRS = base tests linetest
+
+else  # not STAND_ALONE
+
+DIRS = base ui geckoterm tests
+
+LIBRARY_NAME = 
+
+# Exported header files
+EXPORTS = 
+
+# Defines
+DEFINES = 
+
+# C++ Sources
+CPPSRCS = 
+
+endif
+
+include $(topsrcdir)/config/config.mk
+
+include config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlterm/README

@@ -0,0 +1,63 @@
+xmlterm --- A graphical command line interface
+==============================================
+
+An early prototype of XMLterm, an XTERM-like terminal program implemented
+using the open source Mozilla layout engine, is now available to tinker
+with. XMLterm aims to add graphical and hypertext capabilities to the XTERM
+command line interface, while maintaining backwards compatibility.
+
+The basic design philosophy of XMLterm is that the user interface is a dynamic
+XML document. The user and the computer interact by taking turns at appending
+to this XML document. The plain text content of the XML document, i.e.,
+excluding any markup, corresponds to the plain text that would be displayed by
+a plain XTERM. The markup in the XML document is used to add graphical and
+hypertext features. XMLterm uses the Mozilla layout engine to display the XML
+document.
+
+XMLterm is an open source project in its early stages. Comments and
+contributions are welcome!
+
+R. Saravanan <svn@xmlterm.org>
+28 Nov 1999
+===========
+
+NOTES:
+
+ 1. See the INSTALL file for configuration/installation instructions.
+
+ 2. See the file doc/INSTALL.xmlterm for binary installation instructions.
+
+ 3. Check the XMLterm web site <http://xmlterm.org> for updates.
+
+===========================================================================
+DOCUMENTATION
+
+ a. There is a README file in each directory that provides some basic
+    information.
+
+ b. The file "base/README" provides a brief overview of the XMLterm code
+    architecture.
+
+ c. The header files (*.idl, *.h) have comments describing class methods
+    and member variables in JAVADOC format. Look at them before delving
+    into the *.cpp files
+
+===========================================================================
+FILES:
+
+  INSTALL        installation instructions
+  README         this file
+  UUID.txt       list of UUIDs used by XMLterm
+
+The main subdirectories of the "xmlterm" directory are:
+
+  base/          base source code for XMLterm libraries
+  config/        make rules for stand-alone mode
+  dist/          holds include and library file for stand-alone LineTerm only
+  doc/           some documentation
+  geckoterm/     lightweight XMLterm executable
+  linetest/      stand-alone line terminal testing executables
+  tests/         XMLterm test programs and scripts, including "pagelets"
+  ui/*           user interface/chrome files
+
+--

mozilla/extensions/xmlterm/UUID.txt

@@ -0,0 +1,28 @@
+UUID.txt: UUIDs used by XMLTerm
+-------------------------------
+
+2 Dec 1999
+
+A block of 256 UUIDs was generated by running uuidgen,
+ranging from
+/* 0eb82b00-43a2-11d3-8e76-006008948af5 */
+to
+/* 0eb82bff-43a2-11d3-8e76-006008948af5 */
+with the 7th and 8th hex digits varying from 00 to ff.
+
+Of these, the following UUIDs are being used as IIDs and CIDs:
+
+mozILineTerm        IID    "0eb82b00-43a2-11d3-8e76-006008948af5"
+mozLineTerm         CID    "0eb82b01-43a2-11d3-8e76-006008948af5"
+mozILineTermAux     IID    "0eb82b10-43a2-11d3-8e76-006008948af5"
+mozIXMLTerminal     IID    "0eb82b20-43a2-11d3-8e76-006008948af5"
+mozXMLTerminal      CID    "0eb82b21-43a2-11d3-8e76-006008948af5"
+mozIXMLTermShell    IID    "0eb82b30-43a2-11d3-8e76-006008948af5"
+mozXMLTermShell     CID    "0eb82b31-43a2-11d3-8e76-006008948af5"
+mozIXMLTermStream   IID    "0eb82b40-43a2-11d3-8e76-006008948af5"
+mozXMLTermStream    CID    "0eb82b41-43a2-11d3-8e76-006008948af5"
+
+mozISimpleContainer IID    "0eb82bF0-43a2-11d3-8e76-006008948af5"
+mozSimpleContainer  CID    "0eb82bF1-43a2-11d3-8e76-006008948af5"
+
+--

mozilla/extensions/xmlterm/base/Makefile.in

@@ -0,0 +1,120 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/base directory
+
+ifdef STAND_ALONE
+DEPTH      = ..
+topsrcdir  = ..
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../..
+topsrcdir  = @top_srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+
+# Debug option
+DEBUG = 1
+
+# Library name
+LIBRARY_NAME = xmlterm
+
+# C Sources
+ifdef NO_PTY
+CSRCS   = ltermManager.c ltermIO.c ltermInput.c ltermOutput.c ltermEscape.c \
+          tracelog.c unistring.c
+else
+CSRCS   = ltermManager.c ltermIO.c ltermInput.c ltermOutput.c ltermEscape.c \
+          tracelog.c unistring.c ptystream.c
+endif
+
+ifdef STAND_ALONE
+# Defines
+DEFINES +=
+
+# Exported header files
+EXPORTS = lineterm.h tracelog.h unistring.h ptystream.h
+
+# C++ Sources
+CPPSRCS =
+
+else # not STAND_ALONE
+# Defines
+DEFINES += $(TK_CFLAGS)
+
+# Exported header files (excluding XPCONNECT interfaces)
+EXPORTS = lineterm.h tracelog.h unistring.h ptystream.h mozXMLT.h mozXMLTermUtils.h mozIXMLTerminal.h mozIXMLTermStream.h
+
+# C++ Sources
+CPPSRCS = \
+	mozLineTerm.cpp		 \
+	mozXMLTermUtils.cpp	 \
+	mozXMLTerminal.cpp       \
+	mozXMLTermSession.cpp    \
+	mozXMLTermListeners.cpp	 \
+	mozXMLTermShell.cpp	 \
+	mozXMLTermFactory.cpp    \
+	$(NULL)
+
+MODULE = xmlterm
+IS_COMPONENT = 1
+
+EXTRA_DSO_LDOPTS = $(TK_LIBS) \
+                   -L$(DIST)/bin $(NSPR_LIBS) \
+                   -L$(DIST)/bin -lxpcom
+
+XPIDLSRCS = \
+	mozILineTerm.idl     \
+	mozIXMLTermShell.idl \
+	$(NULL)
+endif
+
+# Also create static library libxmlterm.a
+override NO_STATIC_LIB=
+
+REQUIRES =
+
+include $(topsrcdir)/config/config.mk
+
+include ../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk
+
+ifndef STAND_ALONE
+ifeq ($(OS_ARCH),Linux)
+OS_CFLAGS += -ansi
+endif
+endif

mozilla/extensions/xmlterm/base/README

@@ -0,0 +1,127 @@
+base --- core source code for XMLterm and LineTerm
+
+              XMLterm control-flow/layering hierarchy
+              =======================================
+  
+          mozilla-executable                xmlterm-executable
+                 |                                 |
+       ../ui/content/xmlterm.html                  |
+                 |                                 |
+          mozXMLTermShell              ../geckoterm/mozGeckoTerm
+                 |                              |        |
+                 +--------------+---------------+        |
+                                |                  mozSimpleContainer
+                          mozXMLTerminal
+                                |
+            +-------------------+--------------------+
+            |                   |                    |
+     mozXMLTermSession    mozLineTermAux      mozXMLTermListeners
+            |                   |                    |
+            |                   |                    |
+   mozXMLTermStream...      (LineTerm)          (user input)
+   (rendering ...)      (pseudo-TTY/shell)
+
+
+XMLterm may be invoked one of two ways:
+ 1. By loading the URL chrome://xmlterm/content/xmlterm.html in mozilla, or
+ 2. By running the stand-alone executable "../geckoterm/xmlterm".
+The diagram above shows the control-flow/layering hierarchy for both ways
+of invoking XMLterm.
+
+28 Nov 1999
+===========================================================================
+FILES:
+
+The core source code for XMLterm in this directory consists of two distinct
+families of files, those with names that begin with the prefix "moz" and all
+the other files. The former are the Mozilla-specific portions of XMLterm,
+written in C++. The remaining files constitute the Mozilla-independent portion
+of XMLterm, referred to as "LineTerm".
+
+============================================================================
+LINETERM:
+
+LineTerm is a line-oriented terminal program, in some respects similar in
+functionality to the GNU Readline package. It is completely independent of the
+Mozilla source code, is written in plain C, and dually licensed under GPL and
+MPL.
+
+============================================================================
+INTERFACES:
+
+lineterm.h              Plain C interface to LineTerm
+                          (used by mozLineTerm)
+
+mozILineTerm.idl        Scriptable XPCOM/XPCONNECT interface to LineTerm
+                          (not used at the moment)
+
+mozILineTermAux.h       XPCOM interface to LineTerm, with extra features
+                          (used by mozXMLTerminal)
+ 
+mozIXMLTermShell.h      Scriptable XPCOM/XPCONNECT interface to XMLterm
+                          (used by the Javascript glue code in the XMLterm
+                           start page at ../ui/content/xmlterm.html)
+
+mozIXMLTerminal.h       XPCOM interface to XMLterm
+                          (used by mozXMLTermShell, ../geckoterm/mozGeckoterm)
+
+mozIXMLTermStream.h     XPCOM interface for displaying HTML/XML streams in
+                          IFRAMES (used by mozXMLTermSession)
+
+
+IMPLEMENTATIONS:
+
+
+mozLineTerm.h/cpp          Implementation of mozILineTerm, mozILineTermAux
+                             Uses LineTerm to access shell
+
+mozXMLTermShell.h/cpp      Implementation of mozIXMLTermShell
+                             Uses mozIXMLTerminal to create XMLterm
+
+mozXMLTerminal.h/cpp       Implementation of mozIXMLTerminal,
+                                             nsIDocumentLoaderObserver, and
+                                             nsIObserver
+                             Uses mozILineTermAux to create LineTerm
+                             Uses mozXMLTermListeners to capture user input
+                             Uses mozXMLTermSession to display input/output
+
+mozXMLTermListeners.h/cpp  Implementations of nsIDOMKeyListener,
+                                              nsIDOMTextListener,
+                                              nsIDOMMouseListener,
+                                              nsIDOMDragListener
+
+mozXMLTermStream.h/cpp     Implementation of mozIXMLTermStream
+
+
+CLASSES:
+
+
+mozXMLTermSession.h/cpp    Class to manage session input/output display
+                             (used by mozXMLTerminal)
+                             Uses mozIXMLTermStream to display streams
+
+mozXMLTermUtils.h/cpp      Abstract class for static utility functions
+                             (for use by all classes)
+
+============================================================================
+The following are dually licensed under MPL and GPL:
+
+LineTerm package:
+
+lineterm.h        Public interface to LineTerm
+
+ltermPrivate.h    Private common header file
+
+ltermManager.c    LineTerm manager
+ltermIO.c         Overlapping I/O functions
+ltermInput.c      Input handler
+ltermOutput.c     Output handler
+ltermEscape.c     Escape sequence handler
+
+Low-level packages:
+
+ptystream.h/c     Stream-like interface to Unix pseudo-TTY
+tracelog.h/c      Simple tracing/logging diagnostic library
+unistring.h/c     Simple Unicode manipulation library
+
+============================================================================

mozilla/extensions/xmlterm/base/lineterm.h

@@ -0,0 +1,387 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* lineterm.h: Line terminal (LTERM) public interface header file
+ * LINETERM provides a "stream" interface to an XTERM-like terminal,
+ * using line-oriented input/output.
+ */
+
+#ifndef _LINETERM_H
+
+#define _LINETERM_H   1
+
+#ifndef _UNISTRING_H
+#include "unistring.h"
+#endif
+
+/* Define LTERM read callback function type */
+#ifdef USE_GTK_WIDGETS
+#include <gtk/gtk.h>
+typedef void (*lterm_callback_func_t)(gpointer, gint, GdkInputCondition);
+#else
+typedef void* lterm_callback_func_t;
+#endif
+
+/* Unicode character style information (same type as UNICHAR) */
+typedef UNICHAR UNISTYLE;
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* lineterm functions */
+
+/* LTERM module number (used for trace/log operations) */
+#define LTERM_TLOG_MODULE  1
+
+/* Initializes all LTERM operations;
+ * needs to be called before any calls to lterm_new.
+ * @return 0 on success, or -1 on error.
+ *
+ * MESSAGELEVEL specifies the diagnostic message display level:
+ *  0 => (normal) only fatal errors cause diagnostic messages to be printed.
+ * -1 => (silent) no diagnostic messages are printed, even for fatal errors.
+ *  1 => (warning) print non-fatal warning messages as well as error messages.
+ * >9 and <= 99 (debugging)
+ *       print debugging messages at selected procedure levels/sublevels
+ * (See tracelog.h for more information on messageLevel)
+ *
+ * Returns 0 on successful initialization, -1 otherwise.
+ */
+
+int lterm_init(int messageLevel);
+
+
+/** Creates a new LTERM object and returns its descriptor index but
+ *  does not open it for I/O
+ * (documented in the LTERM interface)
+ * @return lterm descriptor index (>= 0) on success, or
+ *         -1 on error
+ */
+
+int lterm_new();
+
+/* Opens line terminal indexed by LTERM for input/output and creates
+ * a process attached to it to execute the command line contained in string
+ * array ARGV.
+ * Called from the adminstrative/output thread of LTERM.
+ * @return 0 on success, or -1 on error.
+ *
+ * COOKIE contains a cookie string used for stream security. If it is null,
+ *  or a null string, all streams are considered insecure.
+ *  (only MAXCOOKIESTR-1 characters of the cookie string are used for checking)
+ *
+ * PROMPT_REGEXP contains a REGEXP string describing the command prompt.
+ * (**NOTE** For the moment, only a list of prompt delimiters is accepted;
+ *           a typical list of prompt delimiters would be "#$%>?")
+ *
+ * OPTIONS is a bitmask controlling the following options:
+ * LTERM_NOCANONICAL_FLAG  disable TTY canonical mode
+ * LTERM_NOEDIT_FLAG       disable input line editing
+ * LTERM_NOCOMPLETION_FLAG disable command line completion
+ * LTERM_NOMETA_FLAG       disable meta input
+ * LTERM_NOPARTLINE_FLAG   disable returning of partial line output
+ * LTERM_NOMARKUP_FLAG     disable HTML/XML element processing in command line
+ * LTERM_NOECHO_FLAG       disable TTY echo
+ * LTERM_NOPTY_FLAG        do not use pseudo-TTY
+ * LTERM_NOSTDERR_FLAG     do not use separate STDERR
+ * LTERM_NONUL_FLAG        do not process any NUL characters (discard them)
+ * LTERM_NOLINEWRAP_FLAG   disable line wrapping
+ * LTERM_NOEXPORT_FLAG     disable export of current environment to new process
+ *
+ * PROCESS_TYPE specifies the subordinate process type, if set to one
+ * of the following:
+ *   LTERM_DETERMINE_PROCESS
+ *   LTERM_UNKNOWN_PROCESS
+ *   LTERM_SH_PROCESS
+ *   LTERM_KSH_PROCESS
+ *   LTERM_BASH_PROCESS
+ *   LTERM_CSH_PROCESS
+ *   LTERM_TCSH_PROCESS
+ * If it is set to LTERM_DETERMINE_PROCESS, the process type is determined
+ * from the path name.
+ *
+ * CALLBACK_FUNC is a pointer to a GTK-style callback function,
+ * or NULL for no callback.
+ * The function is called whenever there is data available for
+ * LTERM_READ to process, with CALLBACK_DATA as the data argument.
+ * The callback function should call LTERM_READ immediately;
+ * otherwise the callback function will be called repeatedly.
+ * (The type LTERM_CALLBACK_FUNC_T is defined at the top of this include file)
+ *
+ * In canonical mode, no input line editing is permitted.
+ * In editing mode, EMACS-style keyboard line editing commands are allowed.
+ * In completion mode, incomplete command/file names are transmitted to
+ * the subordinate process for complettion, as in TCSH.
+ * Meta input refers to input lines that begin with a colon,
+ * or with a "protocol" name followed by a colon, such as
+ * "http: ...".
+ * Meta input lines are not sent to the subordinate process, but simply
+ * echoed as LTERM output through LTERM_READ for further processing.
+ * If command line completion is not disabled, incomplete meta input may
+ * also be echoed for completion. In this case, the completed meta input
+ * should be supplied to the LTERM through a call to LTERM_WRITE as if the
+ * user had entered it.
+ */
+
+int lterm_open(int lterm, char *const argv[], const char* cookie,
+               const UNICHAR* prompt_regexp, int options, int process_type,
+               lterm_callback_func_t callback_func, void *callback_data);
+
+
+/* Closes line terminal indexed by LTERM.
+ * The default action is to block until active calls to lterm_write
+ * and lterm_read to complete.
+ * Called from the administrative/output thread of LTERM.
+ * @return 0 on success, or -1 on error.
+ */
+int lterm_close(int lterm);
+
+
+/** Deletes an LTERM object, closing it if necessary.
+ * @return 0 on success, or -1 on error.
+ */
+
+int lterm_delete(int lterm);
+
+
+/* Closes all LTERMs, but does not delete them.
+ * This may be used to free any resources associated with LTERMs for clean up.
+ * The closed LTERMs should still be deleted, if possible.
+ */
+void lterm_close_all(void);
+
+
+/* Set input echo flag for line terminal indexed by LTERM.
+ * Called from the output thread of LTERM.
+ * @return 0 on success, or -1 on error.
+ */
+
+int lterm_setecho(int lterm, int echo_flag);
+
+
+/* Resizes the line terminal indexed by LTERM.
+ * Called from the output thread of LTERM.
+ * @return 0 on success, or -1 on error.
+ */
+
+int lterm_resize(int lterm, int rows, int cols,
+                            int xpix, int ypix);
+
+
+/* Sets cursor position in line terminal indexed by LTERM.
+ * Called from the output thread of LTERM.
+ * @return 0 on success, or -1 on error.
+ */
+
+int lterm_setcursor(int lterm, int row, int col);
+
+
+/* Writes supplied to Unicode string in BUF of length COUNT to
+ * line terminal indexed by LTERM.
+ * (May be called from any thread, since it uses a pipe to communicate
+ *  with the output thread.)
+ * DATATYPE may be set to one of the following values:
+ *   LTERM_WRITE_PLAIN_INPUT     Plain text user input
+ *   LTERM_WRITE_XML_INPUT       XML element user input
+ *   LTERM_WRITE_PLAIN_OUTPUT    Plain text server output
+ *   LTERM_WRITE_CLOSE_MESSAGE   End of file message
+ * NOTE: This is a non-blocking call
+ * Returns the number of characters written.
+ * Returns -1 on error, and
+ *         -2 if pseudo-TTY has been closed.
+ * If the return value is less than COUNT, it usually indicates an error.
+ * If the return value is -1, any further operations on the LTERM,
+ * other than LTERM_CLOSE, will always fail with an error return value.
+ */
+
+int lterm_write(int lterm, const UNICHAR *buf, int count, int dataType);
+
+
+/* Completes meta input in line terminal indexed by LTERM with the
+ * supplied to Unicode string in BUF of length COUNT.
+ * Called from the output thread of the LTERM.
+ * @return 0 on success, or -1 on error.
+ */
+
+int lterm_metacomplete(int lterm, const UNICHAR *buf, int count);
+
+
+/* reads upto COUNT Unicode characters from a single line of output
+ * from line terminal indexed by LTERM into BUF.
+ * Called from the output thread of the LTERM.
+ * Returns the number of characters read (>=0) on a successful read.
+ * Returns -1 if an error occurred while reading,
+ *         -2 if pseudo-TTY has been closed,
+ *         -3 if more than COUNT characters are present in the line
+ *            (in this case the first COUNT characters are returned in BUF,
+ *             and the rest are discarded).
+ * If the return value is -1, any further operations on the LTERM,
+ * other than LTERM_CLOSE, will always fail with an error return value.
+ * (If return value is -2, it means that the subordinate process has closed
+ *  the pseudo-TTY. In this case, the LTERM still needs to be explicitly
+ *  closed by calling LTERM_CLOSE for proper clean-up.)
+ *
+ * TIMEOUT is the number of platform-dependent time units
+ * (usually milliseconds on Unix) to wait to read data.
+ * A zero value implies no waiting.
+ * A negative TIMEOUT value implies infinite timeout, i.e., a blocking read.
+ * Non-zero values of TIMEOUT should be used only when the output thread
+ * is allowed to block.
+ *
+ * STYLE should be an array of same length as BUF, and contains
+ * the style bits associated with each character on return (see below).
+ *
+ * OPCODES contains a bit mask describing the type of output (see below).
+ * Using Extended Backus-Naur Form notation:
+ *
+ * OPCODES ::= STREAMDATA NEWLINE? COOKIESTR? XMLSTREAM? DOCSTREAM? WINSTREAM?
+ * if StreamMode data is being returned.
+ *
+ * OPCODES ::= SCREENDATA BELL? (  CLEAR
+ *                               | INSERT MOVEDOWN?
+ *                               | DELETE MOVEDOWN?
+ *                               | OUTPUT )
+ * if ScreenMode data is being returned.
+ *
+ * OPCODES ::= LINEDATA BELL? (  CLEAR
+ *                             | ( PROMPT | OUTPUT)? INPUT ( NEWLINE HIDE? )?
+ *                             | PROMPT? INPUT META ( COMPLETION | NEWLINE HIDE? )
+ *                             | OUTPUT NEWLINE? )
+ * if LineMode data is being returned.
+ *
+ * If OPCODES == 0, then it means that no data has been read.
+ *
+ * If the returned OPCODES has META and COMPLETION bits set, then the completed
+ * version of the meta input should be supplied through a call to
+ * LTERM_WRITE, with an input data type, as if the user had typed it.
+ *
+ * BUF_ROW and BUF_COL denote the row and starting column at which to
+ * display the data in BUF.
+ * (If character count returned by lterm_read is zero, implying there is no
+ *  data in BUF, then values of BUF_ROW and BUF_COL should be ignored.)
+ * In ScreenMode or LineMode, CURSOR_ROW and CURSOR_COL denote the final
+ * cursor position after any data in BUF is displayed.
+ *
+ * The bottom left corner of the screen corresponds to row 0, column 0.
+ * BUF_COL, CURSOR_COL are always >= 0, with 0 denoting the leftmost column.
+ * (BUF_COL is always zero if NOPARTLINE flag is set for LTERM.)
+ * (CURRENT IMPLEMENTATION: BUF_COL is always zero.)
+ * BUF_ROW, CURSOR_ROW are always set to -1 when LTERM is in line mode,
+ * BUF_ROW, CURSOR_ROW are always >=0 when LTERM is in screen mode,
+ * with 0 denoting the bottom row.
+ */
+
+int lterm_read(int lterm, int timeout, UNICHAR *buf, int count,
+               UNISTYLE *style, int *opcodes,
+               int *buf_row, int *buf_col, int *cursor_row, int *cursor_col);
+
+/* opcodes describing terminal operations:
+ */
+#define LTERM_STREAMDATA_CODE  0x0001U  /* Stream mode */
+#define LTERM_SCREENDATA_CODE  0x0002U  /* Screen mode */
+#define LTERM_LINEDATA_CODE    0x0004U  /* Line mode */
+#define LTERM_BELL_CODE        0x0008U  /* Ring bell */
+#define LTERM_CLEAR_CODE       0x0010U  /* Clear screen */
+#define LTERM_INSERT_CODE      0x0020U  /* Insert row at cursor */
+#define LTERM_DELETE_CODE      0x0040U  /* Delete row at cursor */
+#define LTERM_MOVEDOWN_CODE    0x0080U  /* Move text down on insert/delete */
+#define LTERM_INPUT_CODE       0x0100U  /* Contains STDIN at end of line */
+#define LTERM_PROMPT_CODE      0x0200U  /* Contains prompt at beginning */
+#define LTERM_OUTPUT_CODE      0x0400U  /* Contains STDOUT/STDERR/ALTOUT */
+#define LTERM_META_CODE        0x0800U  /* Meta input */
+#define LTERM_COMPLETION_CODE  0x1000U  /* Completion requested */
+#define LTERM_NEWLINE_CODE     0x2000U  /* Complete (new) line */
+#define LTERM_HIDE_CODE        0x4000U  /* Hide output */
+
+#define LTERM_COOKIESTR_CODE   0x8000U  /* Stream prefixed with cookie */
+#define LTERM_XMLSTREAM_CODE  0x10000U  /* Stream contains XML, not HTML */
+#define LTERM_DOCSTREAM_CODE  0x20000U  /* Stream contains complete document */
+#define LTERM_WINSTREAM_CODE  0x40000U  /* Display stream in entire window */
+
+
+/* LTERM/XTERM 16-bit style mask:
+ * PROMPT, STDIN, STDOUT, STDERR, ALTOUT are mutually exclusive.
+ * The markup styles apply to STDIN/STDOUT/ALTOUT data.
+ * The highlighting styles only apply to STDOUT data.
+ * The VT100 foreground and background styles are not implemented.
+ */
+
+#define LTERM_PROMPT_STYLE     0x0001UL /* prompt string    */
+#define LTERM_STDIN_STYLE      0x0002UL /* standard input   */
+#define LTERM_STDOUT_STYLE     0x0004UL /* standard output  */
+#define LTERM_STDERR_STYLE     0x0008UL /* standard error   */
+#define LTERM_ALTOUT_STYLE     0x0010UL /* alternate output */
+
+#define LTERM_URI_STYLE        0x0020UL /* URI markup */
+#define LTERM_HTML_STYLE       0x0040UL /* HTML markup */
+#define LTERM_XML_STYLE        0x0080UL /* XML markup */
+
+#define LTERM_BOLD_STYLE       0x0100UL /* boldface */
+#define LTERM_ULINE_STYLE      0x0200UL /* underline */
+#define LTERM_BLINK_STYLE      0x0400UL /* blink */
+#define LTERM_DIM_STYLE        0x0800UL /* inverse video */
+
+/* LTERM option flags */
+#define LTERM_NOCANONICAL_FLAG   0x0001U
+#define LTERM_NOEDIT_FLAG        0x0002U
+#define LTERM_NOCOMPLETION_FLAG  0x0004U
+#define LTERM_NOMETA_FLAG        0x0008U
+#define LTERM_NOPARTLINE_FLAG    0x0010U
+#define LTERM_NOECHO_FLAG        0x0020U
+#define LTERM_NOMARKUP_FLAG      0x0040U
+#define LTERM_NOPTY_FLAG         0x0080U
+#define LTERM_NOSTDERR_FLAG      0x0100U
+#define LTERM_NONUL_FLAG         0x0200U
+#define LTERM_NOLINEWRAP_FLAG    0x0400U
+#define LTERM_NOEXPORT_FLAG      0x0800U
+
+/* Process type codes */
+#define LTERM_DETERMINE_PROCESS -1       /* Determine process type from name */
+#define LTERM_UNKNOWN_PROCESS    0       /* Unknown process type */
+#define LTERM_SH_PROCESS         1       /* Bourne shell */
+#define LTERM_KSH_PROCESS        2       /* Korn shell */
+#define LTERM_BASH_PROCESS       3       /* Bourne Again shell */
+#define LTERM_CSH_PROCESS        4       /* C shell */
+#define LTERM_TCSH_PROCESS       5       /* TC shell */
+
+/* lterm_write data type codes (XML server output not permitted) */
+#define LTERM_WRITE_PLAIN_INPUT     0    /* Plain text user input */
+#define LTERM_WRITE_XML_INPUT       1    /* XML element user input */
+#define LTERM_WRITE_PLAIN_OUTPUT    2    /* Plain text server output */
+#define LTERM_WRITE_CLOSE_MESSAGE   3    /* End of file message */
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  /* _LINETERM_H */

mozilla/extensions/xmlterm/base/ltermInput.c

@@ -0,0 +1,829 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ltermInput.c: LTERM PTY input data processing
+ */
+
+/* public declarations */
+#include "lineterm.h"
+
+/* private declarations */
+#include "ltermPrivate.h"
+
+
+static int ltermLineInput(struct lterms *lts, const UNICHAR *buf, int count,
+                          int *opcodes);
+static int ltermMetaInput(struct lterms *lts);
+static int ltermRequestCompletion(struct lterms *lts, UNICHAR uch);
+
+
+/** Processes plain text input data and returns
+ * OPCODES ::= LINEDATA  (  INPUT ( NEWLINE HIDE? )?
+ *                        | INPUT META ( COMPLETION | NEWLINE HIDE? ) )
+ * if echoable input data was processed.
+ * (OPCODES is set to zero if raw input data was processed)
+ * Called from ltermWrite
+ * @return 0 on success,
+ *        -1 on error, and
+ *        -2 if pseudo-TTY has been closed.
+ */
+int ltermPlainTextInput(struct lterms *lts,
+                        const UNICHAR *buf, int count, int *opcodes)
+{
+  struct LtermInput *lti = &(lts->ltermInput);
+  int returnCode;
+
+  LTERM_LOG(ltermPlainTextInput,20,
+    ("start lti->inputMode=%d\n", lti->inputMode));
+
+  if (lti->inputMode == LTERM0_RAW_MODE) {
+    /* Transmit characters immediately to child process; no buffering */
+
+    LTERM_LOG(ltermPlainTextInput,29,
+                                    ("Raw mode, transmitting %d characters\n",
+                                     count));
+
+    if (ltermSendData(lts, buf, count) != 0)
+      return -1;
+
+    *opcodes = 0;
+
+  } else {
+    /* Not raw input mode; process line mode input */
+    int processTrailingTab = 0;
+
+    LTERM_LOG(ltermPlainTextInput,21,
+              ("Line mode, lts->commandNumber=%d, inputMode=%d\n",
+               lts->commandNumber, lti->inputMode));
+
+    if ((lti->inputMode >= LTERM3_COMPLETION_MODE) &&
+        (lts->commandNumber == 0)) {
+      /* Downgrade input mode */
+      lti->inputMode = LTERM2_EDIT_MODE;
+
+      LTERM_LOG(ltermPlainTextInput,21,
+                ("------------ Downgraded input mode=%d\n\n",
+                 lti->inputMode));
+
+    } else  if ((lti->inputMode < lts->maxInputMode) &&
+                (lts->commandNumber != 0)) {
+      /* Upgrade input mode */
+      int priorInputMode = lti->inputMode;
+
+      /* Set input mode (possibly allowing completion) */
+      lti->inputMode = lts->maxInputMode;
+
+      /* Do not allow command completion without TTY echo */
+      if ( (lts->disabledInputEcho || lts->noTTYEcho) &&
+           (lti->inputMode > LTERM2_EDIT_MODE) )
+        lti->inputMode = LTERM2_EDIT_MODE;
+
+      if ((lti->inputChars > 0) &&
+          (priorInputMode < LTERM3_COMPLETION_MODE) &&
+          (lti->inputMode >= LTERM3_COMPLETION_MODE)) {
+        /* Process prior input TABs before switching to completion mode */
+        int j;
+
+        if ((count == 0) &&
+            (lti->inputCursorGlyph == lti->inputGlyphs) &&
+            (lti->inputGlyphColIndex[lti->inputGlyphs] == lti->inputCols) &&
+            (lti->inputColCharIndex[lti->inputCols] == lti->inputChars) &&
+            (lti->inputLine[lti->inputChars] == U_TAB)) {
+          /* Trailing TAB in prior input; delete it, and process it later */
+          if (ltermDeleteGlyphs(lti, 1) != 0)
+              return -1;
+          processTrailingTab = 1;
+        }
+
+        /* Replace all input TABs with spaces */
+        for (j=0; j < lti->inputChars; j++) {
+          if (lti->inputLine[j] == U_TAB)
+            lti->inputLine[j] = U_SPACE;
+        }
+      }
+
+      LTERM_LOG(ltermPlainTextInput,21,
+                ("------------ Upgraded input mode=%d, trailingTab=%d\n\n",
+                 lti->inputMode, processTrailingTab));
+
+    }
+
+    if (processTrailingTab) {
+      /* Re-process trailing TAB */
+      UNICHAR uch = U_TAB;
+
+      assert(count == 0);
+
+      LTERM_LOG(ltermPlainTextInput,21,("Reprocessing trailing TAB\n"));
+
+      returnCode= ltermLineInput(lts, &uch, 1, opcodes);
+      if (returnCode < 0)
+        return returnCode;
+
+    } else {
+      /* Process new input characters */
+      returnCode = ltermLineInput(lts, buf, count, opcodes) != 0;
+      if (returnCode < 0)
+        return returnCode;
+    }
+  }
+
+  return 0;
+}
+
+
+/** Cancels a prior command line completion request
+ * @return  0 on success,
+ *         -1 on error
+ */
+int ltermCancelCompletion(struct lterms *lts)
+{
+
+  LTERM_LOG(ltermCancelCompletion,40,
+            ("++++++++++++ CANCELED COMPLETION REQUEST\n\n"));
+
+  if (lts->completionRequest != LTERM_NO_COMPLETION) {
+
+    /* Kill input line transmitted to process */
+    if (ltermSendData(lts, lts->control+TTYKILL, 1) != 0)
+      return -1;
+
+    lts->completionRequest = LTERM_NO_COMPLETION;
+  }
+
+  return 0;
+}
+
+
+/** Inserts plain text character UCH as a single-column glyph at the
+ * current input cursor location, translating to escape sequence if needed.
+ * @return 0 on success, -1 on error.
+ */
+int ltermInsertChar(struct LtermInput *lti, UNICHAR uch)
+{
+  UNICHAR* escapeSequence;
+  int insChars, insertColIndex, insertCharIndex, j;
+
+  LTERM_LOG(ltermInsertChar,40,("inserting character 0x%x at glyph %d\n",
+                                   uch, lti->inputCursorGlyph));
+
+  /* Ignore null character */
+  if (uch == 0)
+    return 0;
+
+  escapeSequence = NULL;
+  insChars = 1;
+
+#if 0
+  /* COMMENTED OUT: Plain text not escaped; use code later in HTML insert */
+  /* Check if plain text character needs to be escaped for XML/HTML */
+  for (j=0; j<LTERM_PLAIN_ESCAPES; j++) {
+
+    if (uch == ltermGlobal.escapeChars[j]) {
+      /* Insert escape sequence rather than character */
+      escapeSequence = ltermGlobal.escapeSeq[j];
+      insChars =       ltermGlobal.escapeLen[j];
+      LTERM_LOG(ltermInsertChar,42,("escape index=%d\n", j));
+      break;
+    }
+  }
+#endif /* 0 */
+
+  if (lti->inputChars+insChars > MAXCOLM1) {
+    /* Input buffer overflow; ignore insert character */
+    LTERM_WARNING("ltermInsertChar: Warning - input line buffer overflow\n");
+    return 0;
+  }
+
+  assert(lti->inputChars >= 0);
+  assert(lti->inputCols >= 0);
+  assert(lti->inputGlyphs >= 0);
+  assert(lti->inputCursorGlyph >= 0);
+
+  assert(lti->inputCols <= lti->inputChars);
+  assert(lti->inputGlyphs <= lti->inputCols);
+
+  insertColIndex = lti->inputGlyphColIndex[lti->inputCursorGlyph];
+  insertCharIndex = lti->inputColCharIndex[insertColIndex];
+
+  LTERM_LOG(ltermInsertChar,41,("insertColIndex=%d, insertCharIndex=%d, insChars=%d\n",
+           insertColIndex, insertCharIndex, insChars));
+
+  /* Shift portion of input line to the right;
+     remember that the column/glyph index arrays have an extra element */
+  for (j=lti->inputChars - 1; j >= insertCharIndex; j--)
+    lti->inputLine[j+insChars] = lti->inputLine[j];
+
+  for (j=lti->inputCols; j >= insertColIndex; j--)
+    lti->inputColCharIndex[j+1] = lti->inputColCharIndex[j]+insChars;
+
+  for (j=lti->inputGlyphs; j >= lti->inputCursorGlyph; j--) {
+    lti->inputGlyphCharIndex[j+1] = lti->inputGlyphCharIndex[j]+insChars;
+    lti->inputGlyphColIndex[j+1] = lti->inputGlyphColIndex[j]+1;
+  }
+
+  /* Insert character(s) in input line */
+  if (escapeSequence == NULL) {
+    lti->inputLine[insertCharIndex] = uch;
+  } else {
+    for (j=0; j < insChars; j++)
+      lti->inputLine[j+insertCharIndex] = escapeSequence[j];
+  }
+
+  /* Insert column/glyph */
+  lti->inputColCharIndex[insertColIndex] = insertCharIndex;
+
+  lti->inputGlyphCharIndex[lti->inputCursorGlyph] = insertCharIndex;
+  lti->inputGlyphColIndex[lti->inputCursorGlyph] = insertColIndex;
+
+  lti->inputChars += insChars;       /* Increment character count */
+
+  lti->inputCols++;                  /* Increment column count */
+
+  lti->inputGlyphs++;                /* Increment glyph count */
+
+  lti->inputCursorGlyph++;           /* Reposition cursor */
+
+  return 0;
+}
+
+
+/** switches to raw input mode */
+void ltermSwitchToRawMode(struct lterms *lts)
+{
+  struct LtermInput *lti = &(lts->ltermInput);
+
+  LTERM_LOG(ltermSwitchToRawMode,40,("\n"));
+
+  if (lti->inputMode != LTERM0_RAW_MODE) {
+    /* Do other things ... */
+    lti->inputMode = LTERM0_RAW_MODE;
+  }
+}
+
+
+/** clears input line buffer and switches to regular input mode */
+void ltermClearInputLine(struct lterms *lts)
+{
+  struct LtermInput *lti = &(lts->ltermInput);
+
+  LTERM_LOG(ltermClearInputLine,40,("\n"));
+
+  lti->inputChars = 0;
+
+  lti->inputCols = 0;
+  lti->inputColCharIndex[0] = 0;
+
+  lti->inputGlyphs = 0;
+  lti->inputGlyphCharIndex[0] = 0;
+  lti->inputGlyphColIndex[0] = 0;
+
+  lti->inputCursorGlyph = 0;
+
+  if (lts->maxInputMode >= LTERM2_EDIT_MODE)
+    lti->inputMode = LTERM2_EDIT_MODE;
+  else
+    lti->inputMode = lts->maxInputMode;
+
+  lti->escapeFlag = 0;
+  lti->escapeCSIFlag = 0;
+  lti->escapeCSIArg = 0;
+}
+
+
+/** Processes an input string in canonical or higher mode and returns
+ * OPCODES ::= LINEDATA  (  INPUT (NEWLINE HIDE?)?
+ *                        | INPUT META (COMPLETION|NEWLINE HIDE?) )
+ * if echoable input data was processed.
+ * (OPCODES is set to zero if raw input data was processed)
+ * Called from ltermPlainTextInput
+ * @return 0 on success,
+ *        -1 on error, and
+ *        -2 if pseudo-TTY has been closed.
+ */
+static int ltermLineInput(struct lterms *lts,
+                          const UNICHAR *buf, int count, int *opcodes)
+{
+  struct LtermInput *lti = &(lts->ltermInput);
+  UNICHAR uch;
+  int charIndex, metaInput;
+
+  /* Default returned opcodes (maybe overridden) */
+  *opcodes = LTERM_LINEDATA_CODE | LTERM_INPUT_CODE;
+
+  charIndex = 0;
+
+  LTERM_LOG(ltermLineInput,30,
+            ("lti->inputMode=%d, inputCursorGlyph=%d\n",
+             lti->inputMode, lti->inputCursorGlyph));
+  LTERM_LOGUNICODE(ltermLineInput,31,(buf, count));
+  LTERM_LOG(ltermLineInput,31,("Glyphs=%d,Cols=%d,Chars=%d\n",
+                            lti->inputGlyphs, lti->inputCols, lti->inputChars));
+
+  while (charIndex < count) {
+    uch = buf[charIndex];
+
+    if (uch == U_ESCAPE) {
+      /* Escape */
+      lti->escapeFlag = 1;
+      uch = U_NUL;
+
+    } else if (lti->escapeFlag) {
+      /* Escaped character */
+      lti->escapeFlag = 0;
+
+      switch (uch) {
+
+      case U_LBRACKET:
+        /* Start of escape code sequence */
+        lti->escapeCSIFlag = 1;
+        lti->escapeCSIArg = 0;
+        uch = U_NUL;
+        break;
+
+      default:
+        uch = U_NUL;
+      }
+
+    } else if (lti->escapeCSIFlag) {
+      /* Character part of escape code sequence */
+
+      if ((uch >= U_ZERO && uch <= U_NINE)) {
+        /* Process numerical argument to escape code sequence */
+        lti->escapeCSIArg = lti->escapeCSIArg*10 + (uch - U_ZERO);
+        uch = U_NUL;
+
+      } else {
+        /* End of escape code sequence */
+        lti->escapeCSIFlag = 0;
+
+        /* SUN arrow key bindings */
+        switch (uch) {
+        case U_A_CHAR:
+          uch = U_CTL_P;
+          break;
+        case U_B_CHAR:
+          uch = U_CTL_N;
+          break;
+        case U_C_CHAR:
+          uch = U_CTL_F;
+          break;
+        case U_D_CHAR:
+          uch = U_CTL_B;
+          break;
+        default:
+          uch = U_NUL;
+        }
+      }
+    }
+
+    if ( ((uch >= U_SPACE) && (uch != U_DEL)) ||
+         ((uch == U_TAB) && (lti->inputMode <= LTERM2_EDIT_MODE)) ) {
+      /* printable character or non-completion mode TAB; insert in buffer */
+      /* (NEED TO UPDATE THIS CHECK FOR UNICODE PRINTABILITY) */
+
+      LTERM_LOG(ltermLineInput,39,("inserting printable character - %c\n",
+                   (char) uch));
+
+      /* Insert character */
+      if (ltermInsertChar(lti, uch) != 0)
+        return -1;
+
+    } else {
+      /* Control character */
+
+      /* Line break control characters */
+      if ( (uch == U_LINEFEED)               ||
+           (uch == lts->control[TTYDISCARD]) ||
+           (uch == lts->control[TTYSUSPEND]) ||
+           (uch == lts->control[TTYINTERRUPT])) {
+        /* Newline/TTYdiscard/TTYsuspend/TTYinterrupt character */
+
+        /* Assert that linebreak character occurs at end of buffer;
+         * enforced by lterm_write.
+         */
+        assert(charIndex == count-1);
+
+        /* Check if meta input line */
+        metaInput = ltermMetaInput(lts);
+
+        if ((uch == lts->control[TTYDISCARD]) && !metaInput
+            && (lts->commandNumber == 0)) {
+          /* Not meta/command line; simply transmit discard character */
+          if (ltermSendData(lts, lts->control+TTYDISCARD, 1) != 0)
+            return -1;
+
+        } else {
+          /* Newline behaviour, with hide option */
+          LTERM_LOG(ltermLineInput,31,("------------ NEWLINE (0x%x)\n\n",
+                                         uch));
+          LTERM_LOGUNICODE(ltermLineInput,31,( lti->inputLine,
+                                                 lti->inputChars));
+
+          /* The NEWLINE code tells ltermReturnInputLine to clear
+           * the input line buffer after copying it
+           */
+          *opcodes = LTERM_LINEDATA_CODE | LTERM_INPUT_CODE
+                                         | LTERM_NEWLINE_CODE;
+
+          if (uch == lts->control[TTYDISCARD]) {
+            *opcodes |= LTERM_HIDE_CODE;
+            uch = U_LINEFEED;   /* essentially newline behaviour otherwise */
+          }
+
+          if (metaInput) {
+            /* meta input; do not send line */
+            *opcodes |= LTERM_META_CODE;
+          } else {
+            /* Send line and copy to echo buffer */
+            if (ltermSendLine(lts, uch, (uch != U_LINEFEED),
+                              LTERM_NO_COMPLETION) != 0)
+              return -1;
+          }
+
+        }
+
+      } else if (uch == lts->control[TTYKILL]) {
+        /* kill line */
+        ltermClearInputLine(lts);
+
+        LTERM_LOG(ltermLineInput,31,("TTYKILL\n"));
+
+      } else if ((uch == U_BACKSPACE) ||
+                 (uch == lts->control[TTYERASE])) {
+        /* erase glyph */
+        if (ltermDeleteGlyphs(lti, 1) != 0)
+          return -1;
+
+        LTERM_LOG(ltermLineInput,39,("TTYERASE\n"));
+
+      } else {
+        /* other control characters */
+        if (lti->inputMode >= LTERM2_EDIT_MODE) {
+          switch (uch) {
+
+          case U_NUL:                /* Null character; ignore */
+            break;
+
+          case U_CTL_B:              /* move cursor backward */
+            LTERM_LOG(ltermLineInput,32,("^B\n"));
+            if (lti->inputCursorGlyph > 0) {
+              lti->inputCursorGlyph--;
+            }
+            break;
+
+          case U_CTL_F:              /* move cursor forward */
+            LTERM_LOG(ltermLineInput,32,("^F\n"));
+            if (lti->inputCursorGlyph < lti->inputGlyphs) {
+              lti->inputCursorGlyph++;
+            }
+            break;
+
+          case U_CTL_A:              /* position cursor at beginning of line */
+            LTERM_LOG(ltermLineInput,32,("^A\n"));
+            lti->inputCursorGlyph = 0;
+            break;
+
+          case U_CTL_E:              /* position cursor at end of line */
+            LTERM_LOG(ltermLineInput,32,("^E\n"));
+            lti->inputCursorGlyph = lti->inputGlyphs;
+            break;
+
+          case U_CTL_K:              /* delete to end of line */
+            LTERM_LOG(ltermLineInput,32,("^K\n"));
+            if (ltermDeleteGlyphs(lti,-(lti->inputGlyphs-lti->inputCursorGlyph))
+                != 0)
+              return -1;
+            break;
+
+          case U_CTL_L:              /* form feed */
+          case U_CTL_R:              /* redisplay */
+            LTERM_LOG(ltermLineInput,32,("^%c\n", uch+U_ATSIGN));
+            break;
+
+          case U_CTL_D:              /* ^D */
+          case U_CTL_N:              /* dowN history */
+          case U_CTL_P:              /* uP history */
+          case U_CTL_Y:              /* yank */
+          case U_TAB:                /* command completion */
+
+            /* Assert that completion character occurs at end of buffer;
+             * enforced by lterm_write.
+             */
+            assert(charIndex == count-1);
+
+            metaInput = ltermMetaInput(lts);
+
+            if (metaInput) {
+              /* Meta input command completion */
+              LTERM_LOG(ltermLineInput,40,
+                        ("++++++++++++ meta COMPLETION uch=0x%X\n\n", uch));
+              if (uch == U_TAB) {
+                *opcodes = LTERM_LINEDATA_CODE | LTERM_INPUT_CODE
+                                               | LTERM_META_CODE
+                                               | LTERM_COMPLETION_CODE;
+              } else {
+                LTERM_WARNING("ltermLineInput: Warning - meta command completion not yet implemented for uch=0x%x\n", uch);
+              }
+
+            } else if (lti->inputMode >= LTERM3_COMPLETION_MODE) {
+              /* Completion mode; non-completion TABs already processed */
+
+              if (ltermRequestCompletion(lts, uch) != 0)
+                return -1;
+            }
+
+            break;
+          }
+        }
+      }
+    }
+
+    /* Increment character index */
+    charIndex++;
+  }
+
+  return 0;
+}
+
+
+/** Check if input line contains a meta delimiter;
+ * @return 1 if it does, 0 otherwise.
+ */
+static int ltermMetaInput(struct lterms *lts)
+{
+  struct LtermInput *lti = &(lts->ltermInput);
+  UNICHAR *delimLoc, *ustr, *ustr2;
+
+  LTERM_LOG(ltermMetaInput,40,("\n"));
+
+  if (lts->options & LTERM_NOMETA_FLAG)
+    return 0;
+
+  /* Assert that there is at least one free character position in the buffer */
+  assert(lti->inputChars < MAXCOL);
+
+  /* Insert null character at the end of the input buffer */
+  lti->inputLine[lti->inputChars] = U_NUL;
+
+  /* Locate first occurrence of meta delimiter in input line */
+  delimLoc = ucschr(lti->inputLine, ltermGlobal.metaDelimiter);
+
+  if (delimLoc == NULL)
+    return 0;
+
+  for (ustr=lti->inputLine; ustr<delimLoc; ustr++)  /* skip spaces/TABs */
+    if ((*ustr != U_SPACE) && (*ustr != U_TAB)) break;
+
+  if (ustr == delimLoc) {
+    /* Nameless meta command */
+    LTERM_LOG(ltermMetaInput,41,("Nameless meta command\n"));
+    return 1;
+  }
+
+  if (!IS_ASCII_LETTER(*ustr)) /* meta command must start with a letter */
+    return 0;
+
+  for (ustr2=ustr+1; ustr2<delimLoc; ustr2++)
+    if (!IS_ASCII_LETTER(*ustr2) && !IS_ASCII_DIGIT(*ustr2))
+      return 0;
+
+  LTERM_LOG(ltermMetaInput,41,("Named meta command\n"));
+
+  return 1;
+}
+
+
+/** Requests command line completion from process corresponding to
+ * control character UCH.
+ * @return  0 on success,
+ *         -1 on error
+ */
+static int ltermRequestCompletion(struct lterms *lts, UNICHAR uch)
+{
+  LTERM_LOG(ltermRequestCompletion,40,
+            ("++++++++++++ COMPLETION REQUEST uch=0x%X\n\n", uch));
+
+  if ((uch == U_CTL_D) &&
+      !(lts->processType == LTERM_TCSH_PROCESS)){
+    /* If ^D and not TCSH, simply transmit character */
+    if (ltermSendData(lts, &uch, 1) != 0)
+      return -1;
+    return 0;
+  }
+
+  switch (uch) {
+  case U_TAB:
+    /* Send line and copy to echo buffer */
+    if (ltermSendLine(lts, uch, 0, LTERM_TAB_COMPLETION) != 0)
+      return -1;
+    break;
+  case U_CTL_P:
+  case U_CTL_N:
+    /* Send line and copy to echo buffer */
+    if (ltermSendLine(lts, uch, 0, LTERM_HISTORY_COMPLETION) != 0)
+      return -1;
+    break;
+  default:
+    LTERM_WARNING("ltermCompletionRequest: Warning - command completion not yet implemented for uch=0x%x\n", uch);
+  }
+
+  return 0;
+}
+
+
+/** Deletes glyphs from the input line.
+ * If COUNT > 0, glyphs are deleted to the left of the cursor.
+ * If COUNT < 0, glyphs are deleted to the right of the cursor.
+ * Called from ltermLineInput.
+ * @return 0 on success, -1 on error.
+ */
+int ltermDeleteGlyphs(struct LtermInput *lti, int count)
+{
+  int leftGlyph, leftColIndex, leftCharIndex;
+  int rightGlyph, rightColIndex, rightCharIndex;
+  int deleteGlyphs, deleteCols, deleteChars, j;
+
+  LTERM_LOG(ltermDeleteGlyphs,40,("deleting %d glyphs from glyph %d\n",
+            count, lti->inputCursorGlyph));
+
+  if (count >= 0) {
+    /* Delete to the left */
+    deleteGlyphs = count;
+
+    /* Limit the number of glyphs deleted to that present to the left */
+    if (deleteGlyphs > lti->inputCursorGlyph)
+      deleteGlyphs = lti->inputCursorGlyph;
+
+    rightGlyph = lti->inputCursorGlyph;
+    leftGlyph = rightGlyph - deleteGlyphs;
+
+  } else {
+    /* Delete to the right */
+    deleteGlyphs = -count;
+
+    /* Limit the number of glyphs deleted to that present to the right */
+    if (deleteGlyphs > (lti->inputGlyphs - lti->inputCursorGlyph))
+      deleteGlyphs = lti->inputGlyphs - lti->inputCursorGlyph;
+
+    leftGlyph = lti->inputCursorGlyph;
+    rightGlyph = leftGlyph + deleteGlyphs;
+  }
+
+  leftColIndex = lti->inputGlyphColIndex[leftGlyph];
+  leftCharIndex = lti->inputGlyphCharIndex[leftGlyph];
+
+  rightColIndex = lti->inputGlyphColIndex[rightGlyph];
+  rightCharIndex = lti->inputGlyphCharIndex[rightGlyph];
+
+  deleteCols =  rightColIndex  - leftColIndex;
+  deleteChars = rightCharIndex - leftCharIndex;
+
+  LTERM_LOG(ltermDeleteGlyphs,41,("deleteCols=%d, deleteChars=%d\n",
+                                    deleteCols, deleteChars));
+
+  LTERM_LOG(ltermDeleteGlyphs,42,("leftGlyph=%d, leftCol=%d, leftChar=%d\n",
+                                    leftGlyph, leftColIndex, leftCharIndex));
+
+  LTERM_LOG(ltermDeleteGlyphs,42,("rightGlyph=%d, rightCol=%d, rightChar=%d\n",
+                                    rightGlyph, rightColIndex, rightCharIndex));
+
+  /* Shift portion of input line to the left;
+     remember that the column/glyph index arrays have an extra element */
+  for (j = leftCharIndex; j < lti->inputChars-deleteChars; j++)
+    lti->inputLine[j] = lti->inputLine[j+deleteChars];
+
+  for (j = leftColIndex; j <= lti->inputCols-deleteCols; j++)
+    lti->inputColCharIndex[j] =  lti->inputColCharIndex[j+deleteCols]
+                               - deleteChars;
+
+  for (j = leftGlyph; j <= lti->inputGlyphs-deleteGlyphs; j++)
+    lti->inputGlyphColIndex[j] =  lti->inputGlyphColIndex[j+deleteGlyphs]
+                                - deleteCols;
+
+  lti->inputChars -= deleteChars;             /* Decrement character count */
+
+  lti->inputCols -= deleteCols;               /* Decrement column count */
+
+  lti->inputGlyphs -= deleteGlyphs;           /* Decrement glyph count */
+
+  if (count > 0)
+    lti->inputCursorGlyph -= deleteGlyphs;    /* Reposition glyph cursor */
+
+  return 0;
+}
+
+
+/** Transmits COUNT Unicode characters from BUF to child process
+ * after translating Unicode to UTF8 or Latin1, as appropriate.
+ * The data is transmitted in smallish chunks so as not to overflow the
+ * PTY input buffer.
+ * @return 0 on successful write, -1 on error.
+ */
+int ltermSendData(struct lterms *lts, const UNICHAR *buf, int count)
+{
+  char ch, ptyBuf[MAXPTYIN];
+  int remainingChars, chunkSize, success;
+
+  assert(lts != NULL);
+  assert(count >= 0);
+
+  LTERM_LOG(ltermSendData,40,("count=%d\n", count));
+  LTERM_LOGUNICODE(ltermSendData,41,(buf, count));
+
+  if ((count == 1) && (*buf < 0x80)) { 
+    /* Optimized code to transmit single ASCII character */
+    ch = (char) *buf;
+
+    if (lts->ptyMode)
+#ifndef USE_NSPR_IO
+      success = (write(lts->pty.ptyFD, &ch, 1) == 1);
+#else
+      assert(0);
+#endif
+    else
+      success = (WRITE(lts->ltermProcess.processIN, &ch, 1) == 1);
+
+    if (!success) {
+#if defined(DEBUG) && !defined(USE_NSPR_IO)
+      int errcode = errno;
+      perror("ltermSendData");
+#else
+      int errcode = 0;
+#endif
+      LTERM_ERROR("ltermSendData: Error %d in writing to child STDIN\n",
+                  errcode);
+      return -1;
+    }
+
+    return 0;
+  }
+
+  remainingChars = count;
+  while (remainingChars > 0) {
+    /* Convert Unicode to UTF8 */
+    ucstoutf8(&buf[count-remainingChars], remainingChars,
+              ptyBuf, MAXPTYIN,
+              &remainingChars, &chunkSize);
+
+    assert(chunkSize > 0);
+
+    LTERM_LOG(ltermSendData,42,("remainingChars=%d, chunkSize=%d\n",
+                                 remainingChars, chunkSize));
+
+    /* Send UTF8 to process */
+    if (lts->ptyMode)
+#ifndef USE_NSPR_IO
+      success = (write(lts->pty.ptyFD, &ptyBuf,
+                       (SIZE_T) chunkSize) == chunkSize);
+#else
+      assert(0);
+#endif
+    else
+      success = (WRITE(lts->ltermProcess.processIN, &ptyBuf,
+                       (SIZE_T) chunkSize) == chunkSize);
+
+    if (!success) {
+#if defined(DEBUG) && !defined(USE_NSPR_IO)
+      int errcode = errno;
+      perror("ltermSendData");
+#else
+      int errcode = 0;
+#endif
+      LTERM_ERROR("ltermSendData: Error %d in writing to child STDIN\n",
+                  errcode);
+      return -1;
+    }
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/base/ltermOutput.c

@@ -0,0 +1,895 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ltermOutput.c: LTERM PTY output processing
+ */
+
+/* public declarations */
+#include "lineterm.h"
+
+/* private declarations */
+#include "ltermPrivate.h"
+
+
+static int ltermAppendOutput(struct lterms *lts, const char *cbuf, int count,
+                             UNISTYLE style, int interleaveCheck,
+                             int *interleavedBytes, int rawIncompleteMax,
+                             int *rawIncompleteBytes, char *rawIncompleteBuf);
+static int ltermDecode(const char *rawBuf, int n_total,
+                       UNICHAR* decodedBuf, int decodeMax,
+                       int decodeNUL,
+                       int *rawIncompleteBytes);
+static int ltermPromptLocate(struct lterms *lts);
+
+
+/** Processes output from decoded output buffer and returns *opcodes:
+ * OPCODES ::= SCREENDATA BELL? (  CLEAR
+ *                               | INSERT MOVEDOWN?
+ *                               | DELETE MOVEDOWN?
+ *                               | OUTPUT )
+ * if ScreenMode data is being returned.
+ * OPCODES ::= LINEDATA BELL? (  CLEAR
+ *                             | OUTPUT NEWLINE?)
+ * if LineMode data is being returned.
+ * @return 0 on success and -1 on error.
+ */
+int ltermProcessOutput(struct lterms *lts, int *opcodes)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  UNICHAR uch;
+  UNISTYLE ustyle;
+  int charIndex, returnCode, consumedChars, remainingChars, j;
+  int bellFlag;
+
+  LTERM_LOG(ltermProcessOutput,30,("lto->outputMode=%d, cursorChar=%d, Chars=%d\n",
+                lto->outputMode, lto->outputCursorChar, lto->outputChars));
+
+  LTERM_LOG(ltermProcessOutput,32, ("lts->commandNumber=%d\n",
+                                      lts->commandNumber));
+
+  *opcodes = 0;
+  charIndex = 0;
+  bellFlag = 0;
+
+  while ((*opcodes == 0) && (charIndex < lto->decodedChars)) {
+    uch = lto->decodedOutput[charIndex];
+    ustyle = lto->decodedStyle[charIndex] | lto->styleMask;
+
+    consumedChars = 1;
+
+    if (uch == U_ESCAPE) {
+      /* Process escape sequence */
+      int savedOutputMode = lto->outputMode;
+
+      LTERM_LOG(ltermProcessOutput,31,("ESCAPE sequence\n"));
+
+      returnCode = ltermProcessEscape(lts, lto->decodedOutput+charIndex,
+                                      lto->decodedChars-charIndex,
+                                      lto->decodedStyle+charIndex,
+                                      &consumedChars, opcodes);
+      if (returnCode < 0)
+        return -1;
+
+      if (returnCode == 1) {
+        /* Incomplete escape sequence */
+        lto->incompleteEscapeSequence = 1;
+        if (lto->outputMode == LTERM1_SCREEN_MODE)
+          *opcodes = LTERM_SCREENDATA_CODE | LTERM_OUTPUT_CODE;
+        else
+          *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
+      }
+
+      /* Assert that change in output mode is a loop terminating condition */
+      if (lto->outputMode != savedOutputMode)
+        assert(*opcodes != 0);
+
+    } else if (lto->outputMode == LTERM1_SCREEN_MODE) {
+      /* Screen mode processing */
+
+      if ((uch >= U_SPACE) && (uch != U_DEL)) {
+        /* Printable non-TAB character */
+
+        LTERM_LOG(ltermProcessOutput,39,("Screen mode, printable char - %c\n",
+                      (char) uch));
+
+        if (lto->insertMode) {
+          /* Insert blank character at cursor position */
+          if (ltermInsDelEraseChar(lts, 1, LTERM_INSERT_CHAR) != 0)
+            return -1;
+        }
+
+        /* Mark column as being modified */
+        if ((lto->modifiedCol[lto->cursorRow] == -1) ||
+            (lto->modifiedCol[lto->cursorRow] > lto->cursorCol))
+          lto->modifiedCol[lto->cursorRow] = lto->cursorCol;
+
+        /* Replace character and style info at current cursor location */
+        j = lto->cursorRow*lts->nCols + lto->cursorCol;
+
+        assert(j < lts->screenSize);
+
+        lto->screenChar[j] = uch;
+        lto->screenStyle[j] = ustyle;
+
+        if (lto->cursorCol < lts->nCols-1) {
+          /* Move cursor right */
+          lto->cursorCol++;
+
+          /* Increase row column count, if necessary */
+          if (lto->rowCols[lto->cursorRow] < lto->cursorCol)
+            lto->rowCols[lto->cursorRow] = lto->cursorCol;
+
+        } else {
+          /* Set row column count to maximum value */
+          lto->rowCols[lto->cursorRow] = lts->nCols;
+        }
+
+      } else {
+        /* Control character */
+
+        switch (uch) {
+        case U_BACKSPACE:                 /* Backspace */
+          LTERM_LOG(ltermProcessOutput,32,("Screen mode, BACKSPACE\n"));
+          if (lto->cursorCol > 0)
+            lto->cursorCol--;
+          break;
+
+        case U_BEL:                       /* Bell */
+          LTERM_LOG(ltermProcessOutput,32,("************ Screen mode, BELL\n"));
+          bellFlag = 1;
+          break;
+
+        default:
+          /* Ignore other control characters (including NULs) */
+          break;
+        }
+      }
+
+    } else {
+      /* Line mode processing */
+
+      if ( ((uch >= U_SPACE) && (uch != U_DEL)) ||
+           (uch == U_TAB)) {
+        /* Printable/TAB character; replace/insert at current cursor location
+           or append to end of line */
+
+        LTERM_LOG(ltermProcessOutput,39,("Line mode, printable char - %c\n",
+                      (char) uch));
+
+        if (lto->outputCursorChar == lto->outputChars) {
+          /* Append single character to end of line */
+
+          if (lto->outputChars+1 > MAXCOLM1) {
+            /* Output buffer overflow; ignore character */
+            LTERM_WARNING("ltermProcessOutput: Warning - output line buffer overflow\n");
+          }
+
+          lto->outputLine[lto->outputChars] = uch;
+          lto->outputStyle[lto->outputChars] = ustyle;
+          lto->outputChars++;           /* Insert character in output line */
+
+          lto->outputCursorChar++;      /* Reposition cursor */
+
+        } else {
+          /* Replace/insert single character in the middle of line */
+
+          if (lto->insertMode) {
+            /* Insert blank character at cursor position */
+            if (ltermInsDelEraseChar(lts, 1, LTERM_INSERT_CHAR) != 0)
+              return -1;
+          }
+
+          /* Overwrite single character in the middle of line */
+          lto->outputLine[lto->outputCursorChar] = uch;
+          lto->outputStyle[lto->outputCursorChar] = ustyle;
+
+          /* Note modifications */
+          if (lto->outputCursorChar < lto->outputModifiedChar)
+            lto->outputModifiedChar = lto->outputCursorChar;
+
+          lto->outputCursorChar++;      /* Reposition cursor */
+        }
+
+      } else {
+        /* Control character */
+
+        switch (uch) {
+        case U_BACKSPACE:                /* Backspace */
+          LTERM_LOG(ltermProcessOutput,32,("Line mode, BACKSPACE\n"));
+          if (lto->outputCursorChar > 0)
+            lto->outputCursorChar--;
+          break;
+
+        case U_CRETURN:                  /* Carriage return */
+          LTERM_LOG(ltermProcessOutput,32,("Line mode, CRETURN\n"));
+          lto->outputCursorChar = 0;
+          break;
+
+        case U_BEL:                      /* Bell */
+          LTERM_LOG(ltermProcessOutput,32,("************ Line mode, BELL\n"));
+          bellFlag = 1;
+          break;
+
+        case U_CTL_L:                    /* Formfeed; clear line and return */
+          LTERM_LOG(ltermProcessOutput,32,("************ Line mode, FORMFEED\n\n"));
+
+          ltermClearOutputLine(lts);
+          *opcodes = LTERM_LINEDATA_CODE | LTERM_CLEAR_CODE;
+          break;
+
+        case U_LINEFEED:                  /* Newline; return complete line */
+          LTERM_LOG(ltermProcessOutput,32,("************ Line mode, NEWLINE\n\n"));
+
+          *opcodes =  LTERM_LINEDATA_CODE
+                     | LTERM_OUTPUT_CODE
+                     | LTERM_NEWLINE_CODE;
+          break;
+
+        default:
+          /* Ignore other control characters (including NULs) */
+          break;
+        }
+      }
+    }
+
+    /* Increment character index */
+    charIndex += consumedChars;
+  }
+
+  /* Determine count of unprocessed characters */
+  remainingChars = lto->decodedChars - charIndex;
+
+  if (remainingChars > 0) {
+    /* Move unprocessed output to beginning of decode buffer */
+
+    LTERM_LOG(ltermProcessOutput,32,("Moved %d chars to beginning of decodedOutput\n", remainingChars));
+    for (j=0; j<remainingChars; j++) {
+      lto->decodedOutput[j] = lto->decodedOutput[j+charIndex];
+      lto->decodedStyle[j] = lto->decodedStyle[j+charIndex];
+    }
+  }
+
+  /* Update remaining decoded character count */
+  lto->decodedChars = remainingChars;
+
+  if (*opcodes == 0) {
+    /* All output processed; without any special terminating condition */
+    if (lto->outputMode == LTERM1_SCREEN_MODE) {
+      /* Full screen mode */
+      *opcodes = LTERM_SCREENDATA_CODE | LTERM_OUTPUT_CODE;
+
+    } else {
+      /* Line mode */
+      *opcodes = LTERM_LINEDATA_CODE | LTERM_OUTPUT_CODE;
+    }
+  }
+
+  /* Set bell code */
+  if (bellFlag)
+    *opcodes |= LTERM_BELL_CODE;
+
+  if (*opcodes & LTERM_LINEDATA_CODE) {
+    /* Returning line mode data; check for prompt */
+
+    if ((lts->commandNumber == 0) ||
+        (lto->outputModifiedChar < lto->promptChars)) {
+      /* If not command line or if "prompt string" may have been modified,
+       * search for prompt
+       */
+      int promptLen;
+
+      LTERM_LOG(ltermProcessOutput,39,("Prompt? modifiedChar=%d, promptChars=%d\n",
+                     lto->outputModifiedChar, lto->promptChars));
+
+      /* Reset modification marker */
+      lto->outputModifiedChar = lto->outputChars;
+
+      /* Check if prompt string is present in output */
+      promptLen = ltermPromptLocate(lts);
+
+      if (promptLen > 0) {
+        /* Prompt string found */
+        lto->promptChars = promptLen;
+
+        if (lts->commandNumber == 0) {
+          /* Set command number */
+
+          /* New command number */
+          if (lts->lastCommandNum == 0xFFFF)
+            lts->lastCommandNum = 0;
+          lts->lastCommandNum++;
+
+          lts->commandNumber = lts->lastCommandNum;
+
+          LTERM_LOG(ltermProcessOutput,32,
+                    ("************ Prompt found; commandNumber=%d\n\n",
+                     lts->commandNumber));
+        }
+
+      } else {
+        /* No prompt string */
+        if (lts->commandNumber != 0) {
+          /* Unset command number and prompt columns */
+          UNICHAR temLine[2] = {0, LTERM_WRITE_PLAIN_INPUT};
+
+          lts->commandNumber = 0;
+          lto->promptChars = 0;
+
+          /* Notify "input thread" by writing null input record */
+          WRITE(lts->writeBUFFER, temLine, 2*sizeof(UNICHAR));
+
+          LTERM_LOG(ltermProcessOutput,32,
+                    ("************  No prompt found; not command line\n\n"));
+        }
+      }
+    }
+  }
+
+  LTERM_LOG(ltermProcessOutput,31,("returned opcodes=0x%X\n", *opcodes));
+
+  return 0;
+}
+
+
+/** Clears output line buffer */
+void ltermClearOutputLine(struct lterms *lts)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+
+  LTERM_LOG(ltermClearOutputLine,40,("\n"));
+
+  lto->outputChars = 0;
+  lto->outputCursorChar = 0;
+  lto->outputModifiedChar = 0;
+  lto->promptChars = 0;
+
+  lts->commandNumber = 0;
+}
+
+
+/** Clears output screen buffer (allocating memory, if first time) */
+int ltermClearOutputScreen(struct lterms *lts)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  int j;
+
+  LTERM_LOG(ltermClearOutputScreen,40,("\n"));
+
+  if (lto->screenChar == NULL) {
+    /* Allocate memory for full screen */
+    lto->screenChar = (UNICHAR *) MALLOC(lts->screenSize * sizeof(UNICHAR));
+
+    if (lto->screenChar == NULL) {
+      LTERM_ERROR("ltermClearOutputScreen: Error - failed to allocate memory for chars\n");
+      return -1;
+    }
+
+    assert(lto->screenStyle == NULL);
+    lto->screenStyle = (UNISTYLE *) MALLOC(lts->screenSize * sizeof(UNISTYLE));
+
+    if (lto->screenStyle == NULL) {
+      LTERM_ERROR("ltermClearOutputScreen: Error - failed to allocate memory for style\n");
+      return -1;
+    }
+  }  
+
+  lto->cursorRow = lts->nRows - 1;
+  lto->cursorCol = 0;
+
+  for (j=0; j<lts->nRows; j++) {
+    lto->rowCols[j] = 0;
+    lto->modifiedCol[j] = -1;
+  }
+
+  return 0;
+}
+
+
+/** Saves current output mode value and switches to stream output mode,
+ * with specified opcodes and terminator string.
+ * @return 0 on success and -1 on error.
+ */
+int ltermSwitchToStreamMode(struct lterms *lts, int streamOpcodes,
+                                    const UNICHAR *streamTerminator)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  int strLength;
+
+  LTERM_LOG(ltermSwitchToStreamMode,40,("streamOpcodes=0x%s\n",streamOpcodes));
+
+  if (streamTerminator != NULL) {
+    /* Save terminator string (may be null) */
+    strLength = ucslen(streamTerminator);
+    ucsncpy( lto->streamTerminator, streamTerminator, MAXSTREAMTERM);
+
+    LTERM_LOGUNICODE(ltermSwitchToStreamMode,41,(streamTerminator,
+                                                 (int) strLength));
+  } else {
+    /* Null terminator */
+    strLength = 0;
+    lto->streamTerminator[0] = U_NUL;
+  }
+
+  if (strLength > MAXSTREAMTERM-1) {
+    LTERM_ERROR("ltermSwitchToStreamMode: Error - terminator string too long\n");
+    return -1;
+  }
+
+  if (lts->options & LTERM_NONUL_FLAG) {
+    /* No decoding of NUL characters */
+    if (strLength == 0) {
+      LTERM_ERROR("ltermSwitchToStreamMode: Error - null terminator string not allowed\n");
+      return -1;
+    }
+  } else {
+    /* Decoding NUL characters */
+    if (strLength > 0) {
+      LTERM_ERROR("ltermSwitchToStreamMode: Error - terminator string must be NUL\n");
+      return -1;
+    }
+  }
+
+  lto->savedOutputMode = lto->outputMode;
+  lto->outputMode = LTERM0_STREAM_MODE;
+  lto->streamOpcodes = streamOpcodes;
+  return 0;
+}
+
+
+/** Switches to screen output mode.
+ * @return 0 on success and -1 on error.
+ */
+int ltermSwitchToScreenMode(struct lterms *lts)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+
+  LTERM_LOG(ltermSwitchToScreenMode,40,("\n"));
+
+  if (lto->outputMode == LTERM1_SCREEN_MODE) {
+    /* Switching from line mode to screen mode */
+
+    if (ltermClearOutputScreen(lts) != 0)
+      return -1;
+
+    /* Clear styleMask */
+    lto->styleMask = 0;
+  }
+
+  lto->outputMode = LTERM1_SCREEN_MODE;
+  return 0;
+}
+
+
+/** Switches to line output mode.
+ * @return 0 on success and -1 on error.
+ */
+int ltermSwitchToLineMode(struct lterms *lts)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  int j;
+
+  LTERM_LOG(ltermSwitchToLineMode,40,("\n"));
+
+  if (lto->outputMode == LTERM1_SCREEN_MODE) {
+    /* Switching from screen mode to line mode */
+    ltermClearOutputLine(lts);
+
+    /* Copy bottom line to line output buffer */
+    lto->outputChars = lto->rowCols[0];
+
+    assert(lto->rowCols[0] < MAXCOL);
+
+    for (j=0; j<lto->rowCols[0]; j++) {
+      lto->outputLine[j] =  lto->screenChar[j];
+      lto->outputStyle[j] = lto->screenStyle[j];
+    }
+
+    /* Clear styleMask */
+    lto->styleMask = 0;
+
+  }
+
+  lto->outputMode = LTERM2_LINE_MODE;
+  return 0;
+}
+
+
+/** Reads data from process STDOUT and/or STDERR using file descriptors
+ * from the LTERM POLL structure, and converts to Unicode, saving
+ * incomplete character encodings in corresponding incomplete raw buffers.
+ * Decoded characters are appended to the decodedOutput buffer,
+ * with appropriate style settings.
+ * If READERR is false, STDERR is never read.
+ * @return the number of decoded characters appended (>=0) if successful,
+ *         -1 if an error occurred during processing, or
+ *         -2 if pseudo-TTY has been closed.
+ */
+int ltermReceiveData(struct lterms *lts, int readERR)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  char temERRBuf[MAXCOL], temOUTBuf[MAXCOL];
+  int readERRMax, readOUTMax;
+  int nReadERR, nTotalERR, nReadOUT, nTotalOUT;
+  int interleavedBytes, n_decoded, n_decoded_tot, j;
+
+  LTERM_LOG(ltermReceiveData,30,("\n"));
+
+  nTotalERR = 0;
+  if (readERR && (lto->pollFD[POLL_STDERR].POLL_REVENTS != 0)) {
+    /* Read data from STDERR */
+
+    /* Read maximum number of bytes that will all fit into decodedOutput
+       when decoded, assuming number of decoded characters will not exceed
+       the number of encoded bytes */
+
+    readERRMax = MAXCOLM1 - lto->decodedChars - lto->rawERRBytes;
+
+    /* Reduce by half to leave some space for STDOUT data */
+    readERRMax = readERRMax / 2;
+
+    if (readERRMax <= 0) {
+      /* Decoded buffer overflow */
+      LTERM_WARNING("ltermReceiveData: Warning - decoded buffer overflow\n");
+
+      /* Non-fatal error recovery; return without reading */
+      return 0;
+    }
+
+    /* Copy any incomplete raw output to beginning of buffer */
+    for (j=0; j<lto->rawERRBytes; j++)
+      temERRBuf[j] = lto->rawERRBuf[j];
+
+    /* Read STDERRdata (blocking mode) */
+    nReadERR = READ(lto->pollFD[POLL_STDERR].fd,
+                    temERRBuf + lto->rawERRBytes, (SIZE_T) readERRMax);
+
+    if (nReadERR < 0) {
+#if defined(DEBUG) && !defined(USE_NSPR_IO)
+      int errcode = errno;
+      /*    perror("ltermReceiveData"); */
+#else
+      int errcode = 0;
+#endif
+      LTERM_ERROR( "ltermReceiveData: Error %d in reading from process STDERR\n",
+                   errcode);
+      return -1;
+    }
+
+    if (nReadERR == 0) {
+      /* End of file => pseudo-TTY has been closed */
+      LTERM_LOG(ltermReceiveData,31,("pseudo-TTY has been closed\n"));
+
+      /* Suspend LTERM */
+      lts->suspended = 1;
+
+      return -2;
+    }
+
+
+    LTERM_LOG(ltermReceiveData,32,("Read %d raw bytes from STDERR\n", nReadERR));
+    nTotalERR = nReadERR + lto->rawERRBytes;
+  }
+
+  nTotalOUT = 0;
+  if (lto->pollFD[POLL_STDOUT].POLL_REVENTS != 0) {
+    /* Read data from STDOUT */
+
+    /* Read maximum number of bytes that will all fit into decodedOutput
+       when decoded, assuming number of decoded characters will not exceed
+       the number of encoded bytes */
+    readOUTMax = MAXCOLM1 - lto->decodedChars - lto->rawOUTBytes - nTotalERR;
+
+    if (readOUTMax <= 0) {
+      /* Decoded buffer overflow */
+      LTERM_WARNING("ltermReceiveData: Warning - decoded buffer overflow\n");
+
+      /* Non-fatal error recovery; return without reading */
+      return 0;
+    }
+
+    /* Copy any incomplete raw output to beginning of buffer */
+    for (j=0; j<lto->rawOUTBytes; j++)
+      temOUTBuf[j] = lto->rawOUTBuf[j];
+
+    /* Read STDOUTdata (blocking mode) */
+    nReadOUT = READ(lto->pollFD[POLL_STDOUT].fd,
+                    temOUTBuf + lto->rawOUTBytes, (SIZE_T) readOUTMax);
+
+    if (nReadOUT < 0) {
+#if defined(DEBUG) && !defined(USE_NSPR_IO)
+      int errcode = errno;
+      /*    perror("ltermReceiveData"); */
+#else
+      int errcode = 0;
+#endif
+      LTERM_ERROR( "ltermReceiveData: Error %d in reading from process STDOUT\n",
+                   errcode);
+      return -1;
+    }
+
+    if (nReadOUT == 0) {
+      /* End of file => pseudo-TTY has been closed */
+      LTERM_LOG(ltermReceiveData,31,("pseudo-TTY has been closed\n"));
+
+      /* Suspend LTERM */
+      lts->suspended = 1;
+
+      return -2;
+    }
+
+    LTERM_LOG(ltermReceiveData,32,("Read %d raw bytes from STDOUT\n", nReadOUT));
+
+    nTotalOUT = nReadOUT + lto->rawOUTBytes;
+  }
+
+  n_decoded_tot = 0;
+
+  if (lts->readERRfirst) {
+    /* Decode STDERR data first */
+    interleavedBytes = 0;
+    n_decoded = ltermAppendOutput(lts, temERRBuf, nTotalERR,
+                                  LTERM_STDERR_STYLE,
+                                  lts->interleave, &interleavedBytes,
+                                  MAXRAWINCOMPLETE,
+                                  &(lto->rawERRBytes), lto->rawERRBuf);
+    if (n_decoded < 0)
+      return -1;
+    n_decoded_tot += n_decoded;
+
+    /* Decode STDOUT data next */
+    n_decoded = ltermAppendOutput(lts, temOUTBuf, nTotalOUT,
+                                  LTERM_STDOUT_STYLE,
+                                  0, NULL,
+                                  MAXRAWINCOMPLETE,
+                                  &(lto->rawOUTBytes), lto->rawOUTBuf);
+    if (n_decoded < 0)
+      return -1;
+    n_decoded_tot += n_decoded;
+
+    if (interleavedBytes > 0) {
+      /* Decode remaining STDERR data */
+      n_decoded = ltermAppendOutput(lts, temERRBuf+interleavedBytes,
+                                    nTotalERR-interleavedBytes,
+                                    LTERM_STDERR_STYLE,
+                                    0, NULL,
+                                    MAXRAWINCOMPLETE,
+                                    &(lto->rawERRBytes), lto->rawERRBuf);
+      if (n_decoded < 0)
+        return -1;
+      n_decoded_tot += n_decoded;
+    }
+
+  } else {
+    /* Decode STDOUT data first */
+    interleavedBytes = 0;
+    n_decoded = ltermAppendOutput(lts, temOUTBuf, nTotalOUT,
+                                  LTERM_STDOUT_STYLE,
+                                  lts->interleave, &interleavedBytes,
+                                  MAXRAWINCOMPLETE,
+                                  &(lto->rawOUTBytes), lto->rawOUTBuf);
+    if (n_decoded < 0)
+      return -1;
+    n_decoded_tot += n_decoded;
+
+    /* Decode STDERR data next */
+    n_decoded = ltermAppendOutput(lts, temERRBuf, nTotalERR,
+                                  LTERM_STDERR_STYLE,
+                                  0, NULL,
+                                  MAXRAWINCOMPLETE,
+                                  &(lto->rawERRBytes), lto->rawERRBuf);
+    if (n_decoded < 0)
+      return -1;
+    n_decoded_tot += n_decoded;
+
+    if (interleavedBytes > 0) {
+      /* Decode remaining STDOUT data */
+      n_decoded = ltermAppendOutput(lts, temOUTBuf+interleavedBytes,
+                                    nTotalOUT-interleavedBytes,
+                                    LTERM_STDOUT_STYLE,
+                                    0, NULL,
+                                    MAXRAWINCOMPLETE,
+                                    &(lto->rawOUTBytes), lto->rawOUTBuf);
+      if (n_decoded < 0)
+        return -1;
+      n_decoded_tot += n_decoded;
+    }
+  }
+
+  if (n_decoded_tot > 0) {
+    /* New characters have been decoded; no longer incomplete escape seq. */
+    lto->incompleteEscapeSequence = 0;
+  }
+
+  return n_decoded_tot;
+}
+
+
+/** Process COUNT bytes raw data from CBUF, converting complete
+ * character encodings to Unicode, saving RAWINCOMPLETEBYTES in
+ * RAWINCOMPLETEBUF, whose maximum size is specified by RAWINCOMPLETEMAX.
+ * If INTERLEAVECHECK, check for starting NEWLINE and other interleavable
+ * characters, and if found "decode" just those characters and set
+ * INTERLEAVEDBYTES to the number of bytes consumed on return;
+ * otherwise INTERLEAVEDBYTES is set to 0.
+ * The decoded characters are appended to the decodedOutput buffer,
+ * with style STYLE.
+ * @return the number of characters appended (>=0) if successful,
+ *         -1 if an error occurred during processing, or
+ *         -2 if pseudo-TTY has been closed.
+ */
+static int ltermAppendOutput(struct lterms *lts, const char *cbuf, int count,
+                             UNISTYLE style, int interleaveCheck,
+                             int *interleavedBytes, int rawIncompleteMax,
+                             int *rawIncompleteBytes, char *rawIncompleteBuf)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  int decodeMax, n_decoded, decodeNUL, j;
+
+  LTERM_LOG(ltermAppendOutput,30,("count=%d, style=0x%X, iCheck=%d, rawIncMax=%d\n",
+            count, style, interleaveCheck, rawIncompleteMax));
+
+  if (interleaveCheck && (count > 0) && (cbuf[0] == '\n')) {
+    /* Raw buffer starts with NEWLINE character; interleave */
+
+    assert(lto->decodedChars < MAXCOLM1);
+
+    /* "Decode" just the NEWLINE character */
+    lto->decodedOutput[lto->decodedChars] = U_LINEFEED;
+    lto->decodedStyle[lto->decodedChars] = LTERM_STDOUT_STYLE;
+
+    lto->decodedChars++;
+
+    *interleavedBytes = 1;
+
+    LTERM_LOG(ltermAppendOutput,32,("INTERLEAVED %d bytes\n",
+                                    *interleavedBytes));
+
+    return 1;
+  }
+
+  if (interleavedBytes != NULL)
+    *interleavedBytes = 0;
+
+  if (count == 0)
+    return 0;
+
+  /* Decode all complete encoded character sequences */
+  decodeMax = MAXCOLM1 - lto->decodedChars;
+  decodeNUL = (lts->options & LTERM_NONUL_FLAG) == 0;
+  n_decoded = ltermDecode(cbuf, count,
+                          lto->decodedOutput+lto->decodedChars,
+                          decodeMax, decodeNUL,
+                          rawIncompleteBytes);
+
+  if (n_decoded < 0)
+    return -1;
+
+  /* Save any incomplete raw byte encodings */
+  if (*rawIncompleteBytes > rawIncompleteMax) {
+    LTERM_ERROR("ltermAppendOutput: Error - too many incomplete raw characters\n");
+    return -1;
+  }
+
+  for (j=0; j<*rawIncompleteBytes; j++)
+    rawIncompleteBuf[j] = cbuf[j+count-*rawIncompleteBytes];
+
+  /* Set decoded character styles */
+  for (j=lto->decodedChars; j<lto->decodedChars+n_decoded; j++)
+    lto->decodedStyle[j] = style;
+
+  /* Increment decoded character count */
+  lto->decodedChars += n_decoded;
+
+  LTERM_LOG(ltermAppendOutput,32,("Appended %d bytes\n", n_decoded));
+
+  return n_decoded;
+}
+
+
+/** Decodes N_TOTAL bytes in RAWBUF, returning upto DECODEMAX Unicode
+ * characters in DECODEDBUF, leaving *RAWINCOMPLETEBYTES at the end of
+ * RAWBUF undecoded.
+ * Any NUL (zero) characters in RAWBUF are skipped, unless
+ * decodeNUL is true.
+ * If there is not enough space in DECODEDBUF for all characters to be
+ * decoded, an error is returned.
+ * @return the number of Unicoded characters decoded (>=0) or -1 on error.
+ */
+static int ltermDecode(const char *rawBuf, int n_total,
+                       UNICHAR* decodedBuf, int decodeMax,
+                       int decodeNUL,
+                       int *rawIncompleteBytes)
+{
+  int n_decoded, result;
+
+  LTERM_LOG(ltermDecode,40,("\n"));
+
+  if (decodeMax < n_total) {
+    LTERM_ERROR("ltermDecode: Error - decode buffer overflow\n");
+    return -1;
+  }
+
+  result = utf8toucs(rawBuf, n_total, decodedBuf, decodeMax,
+                     !decodeNUL, rawIncompleteBytes, &n_decoded);
+
+  if (result != 0) {
+    LTERM_WARNING("ltermDecode: Warning - Invalid UTF8 data encountered\n");
+  }
+
+  LTERM_LOG(ltermDecode,41,("result=%d, incomplete=%d, n_decoded=%d\n",
+                            result, rawIncompleteBytes, n_decoded));
+  LTERM_LOGUNICODE(ltermDecode,42,(decodedBuf, n_decoded));
+
+  return n_decoded;
+}
+
+
+/** Search for prompt string in the output line buffer.
+ * TEMPORARY implementation: assume promptRegexp is just a list of delimiters
+ * @return the length of the matching prompt string, or
+ *         0 if there is no match.
+ */
+static int ltermPromptLocate(struct lterms *lts)
+{
+  struct LtermOutput *lto = &(lts->ltermOutput);
+  int prefixCount, promptLen;
+
+  LTERM_LOG(ltermPromptLocate,49,("lto->outputChars=%d\n",
+                lto->outputChars));
+
+  /* Assert that there is at least one free character in the buffer */
+  assert(lto->outputChars < MAXCOL);
+
+  if (lto->outputChars == 0)
+    return 0;
+
+  /* Insert null character at the end of the output buffer */
+  lto->outputLine[lto->outputChars] = U_NUL;
+
+  /* Determine length of initial non-delimiter prefix */
+  prefixCount = ucscspn(lto->outputLine, lts->promptRegexp);
+
+  if (prefixCount+1 >= lto->outputChars) {
+    promptLen = 0;
+
+  } else {
+    /* Skip any spaces following the delimiter */
+    const UNICHAR spaceStr[2] = {U_SPACE, U_NUL};
+    int spaceCount = ucsspn(lto->outputLine+prefixCount+1, spaceStr);
+
+    promptLen = prefixCount + 1 + spaceCount;
+
+    LTERM_LOGUNICODE(ltermPromptLocate,41,(lto->outputLine, promptLen));
+  }
+
+  return promptLen;
+}

mozilla/extensions/xmlterm/base/ltermPrivate.h

@@ -0,0 +1,560 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ltermPrivate.h: Line terminal (LTERM) private header file
+ * LTERM provides a "stream" interface to an XTERM-like terminal,
+ * using line input/output.
+ * CPP options:
+ *   LINUX:          for Linux2.0/glibc
+ *   SOLARIS:        for Solaris2.6
+ *   DEBUG:          to enable some debugging output
+ *   NO_PTY:         force use of pipes rather than PTY for process
+ *                   communication
+ *   MOZILLA_CLIENT: set if embedded in Mozilla
+ *   USE_NSPR_BASE:  use basic NSPR API (excluding I/O and process creation)
+ *   USE_NSPR_LOCK:  use NSPR lock API instead of Unix mutex API
+ *   USE_NSPR_IO:    use NSPR I/O and process API instead of Unix API
+ *             (current implementation of pseudo-TTY is incompatible with
+ *              the NSPR I/O API; set the USE_NSPR_IO option only on platforms
+ *              where PTYSTREAM is not implemented)
+ */
+
+#ifndef _LTERMPRIVATE_H
+
+#define _LTERMPRIVATE_H 1
+
+/* Standard C header files */
+#ifndef _STRING_H
+#include <string.h>
+#endif
+
+/* public declarations */
+#include "lineterm.h"
+#include "tracelog.h"
+
+/* private declarations */
+
+/* Force use of basic NSPR API if MOZILLA_CLIENT or USE_NSPR_IO are defined */
+#if defined(MOZILLA_CLIENT) || defined(USE_NSPR_IO)
+#define USE_NSPR_BASE 1
+#endif
+
+/* pseudo-TTY stream interface */
+#ifndef _PTYSTREAM_H
+#include "ptystream.h"
+#endif
+
+#define LTERM_ERROR                           TLOG_ERROR
+#define LTERM_WARNING                         TLOG_WARNING
+#define LTERM_LOG(procname,level,args)        TLOG_PRINT(LTERM_TLOG_MODULE,procname,level,args)
+#define LTERM_LOGUNICODE(procname,level,args) TLOG_UNICHAR(LTERM_TLOG_MODULE,procname,level,args)
+
+#ifdef USE_NSPR_BASE           /* Use basic NSPR API (excluding I/O) */
+
+#include "nspr.h"
+
+#define assert       PR_ASSERT
+
+#define int32        PRInt32
+
+#define getenv       PR_GetEnv
+
+#define MALLOC(x)    PR_Malloc(x)
+#define REALLOC(x,y) PR_Realloc((x),(y))
+#define CALLOC(x,y)  PR_Calloc((x),(y))
+#define FREE(x)      PR_Free(x)
+
+#else   /* not USE_NSPR_BASE */
+
+#include <assert.h>
+
+#define int32        long
+
+#define MALLOC(x)    malloc(x)
+#define REALLOC(x,y) realloc((x),(y))
+#define CALLOC(x,y)  calloc((x),(y))
+#define FREE(x)      free(x)
+
+#endif  /* not USE_NSPR_BASE */
+
+
+#ifdef USE_NSPR_IO           /* Use NSPR I/O API (no PTY implementation) */
+
+#ifdef LINUX
+#include <sys/poll.h>
+#endif
+
+typedef PRFileDesc  *FILEDESC;
+#define NULL_FILEDESC     0
+#define VALID_FILEDESC(x) (x != 0)
+
+typedef PRFileDesc FILESTREAM;
+
+#define SIZE_T   PRInt32
+#define WRITE    PR_Write
+#define READ     PR_Read
+#define CLOSE(x) (PR_Close(x) != PR_SUCCESS)
+#define PIPE(x)  (PR_CreatePipe((x),(x)+1) != PR_SUCCESS)
+
+#define POLL(x,y,z)  PR_Poll((x),(y),(z))
+#define POLLFD       PRPollDesc
+#define POLL_EVENTS  in_flags
+#define POLL_REVENTS out_flags
+#define POLL_READ    PR_POLL_READ
+
+#define PROCESS           PRProcess *
+#define NULL_PROCESS      0
+#define VALID_PROCESS(x)  (x != 0)
+
+#else   /* not USE_NSPR_IO */
+
+/* system header files */
+#include <unistd.h>
+#include <signal.h>
+
+/* Diagnostic/debugging files */
+#include <stdio.h>
+#include <errno.h>
+#include <stdarg.h>
+
+#if defined(SOLARIS)
+#include <poll.h>
+#elif defined(LINUX)
+#include <sys/poll.h>
+#endif
+
+typedef int FILEDESC;
+#define NULL_FILEDESC     -1
+#define VALID_FILEDESC(x) (x >= 0)
+
+typedef FILE FILESTREAM;
+
+#define SIZE_T   size_t
+#define WRITE    write
+#define READ     read
+#define CLOSE(x) close(x)
+#define PIPE(x)  pipe(x)
+
+#define POLL(x,y,z)  poll((x),(y),(z))
+#define POLLFD       pollfd
+#define POLL_EVENTS  events
+#define POLL_REVENTS revents
+#define POLL_READ    POLLIN
+
+#define PROCESS          long
+#define NULL_PROCESS     0
+#define VALID_PROCESS(x) (x > 0)
+
+#endif  /* not USE_NSPR_IO */
+
+
+#ifdef USE_NSPR_LOCK           /* Use NSPR lock API */
+
+#define MUTEX_DECLARE(x)     PRLock *x
+#define MUTEX_INITIALIZE(x)  ((x=PR_NewLock()) == NULL)
+#define MUTEX_LOCK(x)        PR_Lock(x)
+#define MUTEX_UNLOCK(x)      PR_Unlock(x)
+#define MUTEX_DESTROY(x)     PR_DestroyLock(x)
+
+#define THREAD_DECLARE(x)    PRThread *x
+#define THREAD_CREATE        ((x=PR_CreateThread(PR_USER_THREAD, (y), (z), \
+                                  PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,    \
+                                  PR_JOINABLE_THREAD, 0)) == NULL)
+#define THREAD_SELF          PR_GetCurrentThread
+#define THREAD_EQUAL(x,y)    ((x) == (y))
+#define THREAD_JOIN(x)       (PR_JoinThread(x) != PR_SUCCESS)
+
+#else   /* not USE_NSPR_LOCK */
+
+#include <pthread.h>
+
+#define MUTEX_DECLARE(x)     pthread_mutex_t x
+#define MUTEX_INITIALIZE(x)  pthread_mutex_init(&(x), NULL)
+#define MUTEX_LOCK(x)        pthread_mutex_lock(&(x))
+#define MUTEX_UNLOCK(x)      pthread_mutex_unlock(&(x))
+#define MUTEX_DESTROY(x)     pthread_mutex_destroy(&(x))
+
+#define THREAD_DECLARE(x)    pthread_t x
+#define THREAD_CREATE(x,y,z) pthread_create(&(x),NULL,(y),(z))
+#define THREAD_SELF          pthread_self
+#define THREAD_EQUAL(x,y)    pthread_equal(x,y)
+#define THREAD_JOIN(x)       pthread_join((x),NULL)
+
+#endif  /* not USE_NSPR_LOCK */
+
+
+#define MAXTERM 256            /* Maximum number of LTERMs;
+                                * affects static memory "footprint"
+                                */
+
+#define MAXCOL 4096            /* Maximum columns in line buffer;
+                                * affects static memory "footprint";
+                                * the only limitation on this value is that
+                                * it must fit into a UNICHAR, because of the
+                                * way lterm_write and ltermWrite implement
+                                * the input buffer pipe.
+                                */
+
+#define MAXROW 1024            /* Maximum rows in screen;
+                                * primarily affects dynamically allocated
+                                * memory
+                                */
+
+/* The only obvious limitation on the following is that they should be
+ * significantly less than MAXCOL
+ */
+#define MAXPROMPT 256          /* Maximum length of prompt regexp+1 */
+#define MAXRAWINCOMPLETE 5     /* Maximum incomplete raw buffer size */
+#define MAXSTREAMTERM 11       /* Maximum stream terminator buffer size */
+#define MAXCOOKIESTR 64        /* Maximum length of cookie string+1 */
+#define MAXESCAPEPARAMS 16     /* Maximum no. of numeric ESCAPE parameters */
+#define MAXSTRINGPARAM  512    /* Maximum length of string ESCAPE parameters */
+
+#define MAXPTYIN 128           /* 1/2 POSIX minimum MAX_INPUT for PTY */
+
+#define MAXCOLM1 (MAXCOL-1)    /* Maximum columns in line buffer - 1 */
+
+#define MAXTTYCONTROL   8      /* Maximum TTY control character list */
+#define TTYINTERRUPT    0
+#define TTYERASE        1
+#define TTYKILL         2
+#define TTYEOF          3
+#define TTYSUSPEND      4
+#define TTYREPRINT      5
+#define TTYDISCARD      6
+#define TTYWERASE       7
+
+/* input modes */
+#define LTERM0_RAW_MODE         0
+#define LTERM1_CANONICAL_MODE   1
+#define LTERM2_EDIT_MODE        2
+#define LTERM3_COMPLETION_MODE  3
+
+/* completion request codes */
+#define LTERM_NO_COMPLETION       0
+#define LTERM_TAB_COMPLETION      1
+#define LTERM_HISTORY_COMPLETION  2
+
+/* output modes */
+#define LTERM0_STREAM_MODE  0
+#define LTERM1_SCREEN_MODE  1
+#define LTERM2_LINE_MODE    2
+
+/* character operation codes */
+#define LTERM_INSERT_CHAR 0
+#define LTERM_DELETE_CHAR 1
+#define LTERM_ERASE_CHAR  2
+
+/* List of characters escaped in XML */
+#define LTERM_AMP_ESCAPE    0
+#define LTERM_LT_ESCAPE     1
+#define LTERM_GT_ESCAPE     2
+#define LTERM_QUOT_ESCAPE   3
+#define LTERM_APOS_ESCAPE   4
+
+#define LTERM_XML_ESCAPES   5
+#define LTERM_PLAIN_ESCAPES 3
+
+/* input buffer pipe header "character" count */
+#define PIPEHEADER  2
+
+/* input buffer pipe header components */
+#define PHDR_CHARS  0
+#define PHDR_TYPE   1
+
+/* LTERM read in/out parameter structure */
+struct LtermRead {
+  UNICHAR *buf;     /* Pointer to Unicode character buffer   (IN param) */
+  UNISTYLE *style;  /* Pointer to character style buffer     (IN param) */
+  int max_count;    /* max. number of characters in buffers  (IN param) */
+  int read_count;   /* actual number of characters in buffers */
+  int opcodes;     /* Returned opcodes */
+  int buf_row;     /* row at which to display buffer data */
+  int buf_col;     /* starting column at which to display buffer data */
+  int cursor_row;  /* final cursor row position */
+  int cursor_col;  /* final cursor column position */
+};
+
+/* LTERM input structure: managed by lterm_write */
+struct LtermInput {
+
+  UNICHAR inputBuf[PIPEHEADER+MAXCOL]; /* holds data read from input buffer
+                                        * pipe
+                                        */
+  int inputBufBytes;           /* Count of bytes already read in */
+
+  int inputMode;               /* input mode:
+                                * 0 = raw mode
+                                * 1 = canonical mode
+                                * 2 = edit + canonical mode
+                                * 3 = completion + edit + canonical mode
+                                */
+
+  int escapeFlag;              /* processing ESCAPE in line mode */
+  int escapeCSIFlag;           /* processing ESCAPE Code Sequence Introducer */
+  int escapeCSIArg;            /* ESCAPE Code Sequence Argument value */
+
+  int inputOpcodes;            /* input opcodes */
+
+  int clearInputLine;          /* true if input line buffer needs to be
+                                * cleared (after echoing) */
+
+  UNICHAR inputLine[MAXCOL];   /* input line buffer:
+                                  only MAXCOL-1 characters should actually
+                                  be inserted in the buffer, to allow
+                                  one character padding if necessary */
+
+  int inputChars;              /* length of input line (characters);
+                                * should never exceed MAXCOL-1,
+                                * to allow for null termination
+                                */
+  int inputCols;               /* number of displayed columns in input line;
+                                * a column corresponds to a single
+                                * plain text character transmitted to the
+                                * subordinate process, although it may occupy
+                                * multiple character positions, e.g.,
+                                * e.g., &lt represents "<"
+                                */
+  int inputGlyphs;             /* number of displayed glyphs in input line;
+                                * a glyph corresponds to a logical column
+                                * on the layout, i.e., a single Unicode
+                                * character or an XML element, such as an
+                                * iconic representiion of an URI.
+                                */
+
+  unsigned short inputColCharIndex[MAXCOL]; /* starting character index of
+                                             * each column, including the
+                                             * cursor column at end of line.
+                                             * (inputCols+1 values should be
+                                             * defined)
+                                             */
+
+  unsigned short inputGlyphCharIndex[MAXCOL]; /* starting character index
+                                               * of each glyph, including
+                                               * empty glyph at the end of
+                                               * the line.
+                                               * (inputGlyphs+1 values
+                                               * should be defined)
+                                               */
+  unsigned short inputGlyphColIndex[MAXCOL]; /* starting column index of
+                                              * each glyph
+                                              * (inputGlyphs+1 values)
+                                              */
+
+  int inputCursorGlyph;           /* current input cursor glyph number (>=0) */
+};
+
+/* LtermOutput poll structure index count and values */
+#define POLL_COUNT 3
+#define POLL_INPUTBUF 0
+#define POLL_STDOUT   1
+#define POLL_STDERR   2
+
+/* LTERM output structure: managed by lterm_read */
+struct LtermOutput {
+  struct POLLFD pollFD[POLL_COUNT];  /* output polling structure */
+  long callbackTag[POLL_COUNT]; /* GTK callback tag for each FD (0 if none) */
+  int nfds;                     /* count of "files" to be polled */
+  int outputMode;               /* output mode:
+                                 * 0 = full screen mode
+                                 * 1 = line mode
+                                 * 2 = command line mode
+                                 */
+
+  UNICHAR streamTerminator[MAXSTREAMTERM]; /* stream terminator buffer */
+  int streamOpcodes;            /* Stream opcodes */
+  int savedOutputMode;          /* saved output mode (prior to stream mode) */
+
+  int insertMode;               /* character insert mode */
+  int automaticNewline;         /* automatic newline mode */
+
+  UNISTYLE styleMask;           /* current output style mask */
+
+  char rawOUTBuf[MAXRAWINCOMPLETE]; /* incomplete raw STDOUT buffer */
+  int rawOUTBytes;               /* incomplete raw STDOUT byte count */
+
+  char rawERRBuf[MAXRAWINCOMPLETE]; /* incomplete raw STDERR buffer */
+  int rawERRBytes;               /* incomplete raw STDERR byte count */
+
+  UNICHAR decodedOutput[MAXCOL]; /* decoded output buffer:
+                                    only MAXCOL-1 characters should actually
+                                    be inserted in the buffer, to allow
+                                    one character padding if necessary */
+  UNISTYLE decodedStyle[MAXCOL]; /* decoded output style buffer */
+  int decodedChars;              /* decoded character count;
+                                    should never exceed MAXCOL-1 */
+  int incompleteEscapeSequence;  /* Incomplete ESCAPE sequence flag */
+
+  UNICHAR outputLine[MAXCOL];  /* output line buffer (processed);
+                                  only MAXCOL-1 characters should actually
+                                  be inserted in the buffer, to allow
+                                  one character padding if necessary */
+  UNISTYLE outputStyle[MAXCOL]; /* output style buffer for each character */
+
+  int outputChars;             /* length of output line (characters)
+                                  should never exceed MAXCOL-1 */
+  int outputCursorChar;        /* output cursor character position (>=0) */
+  int promptChars;             /* prompt character count */
+  int outputModifiedChar;      /* leftmost modified character in output line */
+
+  int cursorRow, cursorCol;    /* screen cursor row and column */
+
+  int rowCols[MAXROW];         /* count of columns in each row (>=0) */
+
+  int modifiedCol[MAXROW];     /* first modified column in each row;
+                                  -1 if no column has been modified */
+
+  UNICHAR  *screenChar;        /* Screen character array (screenSize long) */
+  UNISTYLE *screenStyle;       /* Screen style array (screenSize long) */
+};
+
+/* LTERM process structure: managed by lterm_create, lterm_close */
+struct LtermProcess {
+  PROCESS processID;           /* process ID */
+  FILEDESC processIN;          /* process input pipe */
+  FILEDESC processOUT;         /* process output pipe */
+  FILEDESC processERR;         /* process error pipe */
+};
+
+/* line terminal (LTERM) structure: managed by lterm_open, lterm_close */
+struct lterms { 
+  int opened;                      /* LTERM opened status flag */
+  int suspended;                   /* LTERM suspended flag:
+                                    * an LTERM is suspended when an error
+                                    * occurs, to prevent further I/O operations
+                                    * which have unpredictable results.
+                                    * The LTERM still needs to be closed to
+                                    * release any resources used by it.
+                                    * (a suspended LTERM is still open)
+                                    */
+
+  MUTEX_DECLARE(adminMutex);       /* LTERM administrative mutex */
+  MUTEX_DECLARE(outputMutex);      /* LTERM output thread mutex */
+
+  int adminMutexLocked;            /* administrative mutex lock status */
+  int outputMutexLocked;           /* output mutex lock status */
+
+  FILEDESC writeBUFFER, readBUFFER; /* input character BUFFER pipe */
+
+  int options;                     /* TTY options */
+  int ptyMode;                     /* pseudo-TTY mode flag */
+  int noTTYEcho;                   /* no TTY echo flag */
+  int disabledInputEcho;           /* disabled input echo flag */
+
+  int processType;                 /* Process type code */
+  int maxInputMode;                /* maximum allowed input mode value */
+  int readERRfirst;                /* Read STDERR before STDOUT */
+  int interleave;                  /* interleave STDERR/STDOUT flag */
+  UNICHAR control[MAXTTYCONTROL];  /* TTY control characters */
+
+  int commandNumber;               /* output command number
+                                    * (0 if not command line)
+                                    */
+  unsigned short lastCommandNum;   /* last command number */
+  int completionRequest;           /* command completion request code:
+                                    * LTERM_NO_COMPLETION, or
+                                    * LTERM_TAB_COMPLETION, or
+                                    * LTERM_HISTORY_COMPLETION
+                                    */
+  int completionChars;             /* command completion insert count */
+
+  int inputBufRecord;              /* True if input buffer contains record */
+
+  int inputLineBreak;              /* True if input line was transmitted
+                                    * and plain text copy saved in echo buffer
+                                    */
+  UNICHAR echoLine[MAXCOL];        /* Plain text of echo line */
+  int echoChars;                   /* Count of echo characters */
+
+  int nRows;                       /* Number of rows */
+  int nCols;                       /* Number of columns */
+  long screenSize;                 /* Screen size, in characters
+                                      = nRows*nCols */
+
+  UNICHAR promptRegexp[MAXPROMPT]; /* prompt regular expression
+                                      JUST A LIST OF DELIMITERS AT PRESENT */
+
+  char cookie[MAXCOOKIESTR];       /* cookie string */
+
+  struct ptys pty;                 /* pseudo-tty (PTY) stream info for LTERM */
+  struct LtermProcess ltermProcess; /* LTERM process structure */
+  struct LtermInput ltermInput;     /* LTERM input structure */
+  struct LtermOutput ltermOutput;   /* LTERM output structure */
+};
+
+/* LTERM global variables */
+typedef struct { 
+  int initialized;                  /* Initialization flag */
+  struct lterms *termList[MAXTERM]; /* List of LTERMS */
+  MUTEX_DECLARE(listMutex);         /* Thread lock to access to LTERM list */
+  UNICHAR metaDelimiter;            /* Meta command delimiter (usually :) */
+  char escapeChars[LTERM_XML_ESCAPES+1]; /* String of chars escaped in XML */
+  UNICHAR* escapeSeq[LTERM_XML_ESCAPES]; /* XML character escape sequences */
+  int escapeLen[LTERM_XML_ESCAPES];     /* XML char. escape sequence lengths */
+} LtermGlobal;
+
+extern LtermGlobal ltermGlobal;
+
+
+/* Visible prototypes */
+
+/* ltermIO.c */
+int ltermSendLine(struct lterms *lts, UNICHAR uch,
+                  int echoControl, int completionCode);
+int ltermRead(struct lterms *lts, struct LtermRead *ltr, int timeout);
+
+/* ltermInput.c */
+int ltermPlainTextInput(struct lterms *lts,
+                        const UNICHAR *buf, int count, int *opcodes);
+int ltermCancelCompletion(struct lterms *lts);
+int ltermInsertChar(struct LtermInput *lti, UNICHAR uch);
+void ltermSwitchToRawMode(struct lterms *lts);
+void ltermClearInputLine(struct lterms *lts);
+int ltermDeleteGlyphs(struct LtermInput *lti, int count);
+int ltermSendData(struct lterms *lts, const UNICHAR *buf, int count);
+
+/* ltermOutput.c */
+int ltermProcessOutput(struct lterms *lts, int *opcodes);
+int ltermReceiveData(struct lterms *lts, int readERR);
+void ltermClearOutputLine(struct lterms *lts);
+int ltermClearOutputScreen(struct lterms *lts);
+int ltermSwitchToStreamMode(struct lterms *lts, int streamOpcodes,
+                            const UNICHAR *streamTerminator);
+int ltermSwitchToScreenMode(struct lterms *lts);
+int ltermSwitchToLineMode(struct lterms *lts);
+
+/* ltermEscape.c */
+int ltermProcessEscape(struct lterms *lts, const UNICHAR *buf,
+                int count, const UNISTYLE *style, int *consumed, int *opcodes);
+int ltermInsDelEraseChar(struct lterms *lts, int count, int action);
+
+#endif  /* _LTERMPRIVATE_H */

mozilla/extensions/xmlterm/base/mozILineTerm.idl

@@ -0,0 +1,88 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+/* mozILineTerm.idl: Javascript-accessible interface to LineTerm
+ */
+
+#include "nsISupports.idl"
+#include "domstubs.idl"
+
+%{C++
+class nsIDOMDocument;
+%}
+
+[scriptable, uuid(0eb82b00-43a2-11d3-8e76-006008948af5)]
+
+interface mozILineTerm : nsISupports
+{
+  attribute long cursorRow;
+  attribute long cursorColumn;
+  attribute boolean echoFlag;
+
+  /** Opens LineTerm, a line-oriented terminal interface (without graphics)
+   * @param command name of command to be executed; usually a shell,
+   *        e.g., "/bin/sh"; if set to null string, the command name is
+   *        determined from the environment variable SHELL
+   * @param promptRegexp command prompt regular expression (for future use);
+   *        at the moment, any string terminated by one of the characters
+   *        "#$%>?", followed by a space, is assumed to be a prompt
+   * @param options LineTerm option bits (usually 0; see lineterm.h)
+   * @param processType command shell type; if set to -1, type is determined
+   *        from the command name
+   * @param domDoc DOM document object associated with the LineTerm
+   *        (document.cookie will be defined for this document on return)
+   */
+  void Open(in wstring command, in wstring promptRegexp,
+            in PRInt32 options, in PRInt32 processType,
+            in nsIDOMDocument domDoc);
+
+  /** Closes LineTerm
+   * @param aCookie document.cookie string for authentication
+   */
+  void Close(in wstring aCookie);
+
+  /** Writes string to LineTerm as if the user had typed it (command input)
+   * @param buf string to be transmitted to LineTerm
+   * @param aCookie document.cookie string for authentication
+   */
+  void Write(in wstring buf, in wstring aCookie);
+
+  /** Read output data string and parameters from LineTerm (command output)
+   * @param opcodes (output) output data descriptor bits (see lineterm.h)
+   * @param buf_row (output) row number (>=-1)
+                   (-1 denotes line mode and 0 represents bottom row)
+   * @param buf_col (output) column number (>=0)
+   * @param aCookie document.cookie string for authentication
+   * @return output data string from LineTerm
+   */
+  wstring Read(out PRInt32 opcodes, out PRInt32 buf_row,
+               out PRInt32 buf_col, in wstring aCookie);
+};
+
+
+%{ C++
+#define MOZLINETERM_CID                      \
+{ /* 0eb82b01-43a2-11d3-8e76-006008948af5 */ \
+   0x0eb82b01, 0x43a2, 0x11d3,               \
+{0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5} }
+
+extern nsresult
+NS_NewLineTerm(mozILineTerm** aLineTerm);
+%}

mozilla/extensions/xmlterm/base/mozILineTermAux.h

@@ -0,0 +1,122 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozILineTermAux.h: auxiliary interface for LineTerm (not XPCONNECTed)
+// This adds some XPCOM-only methods to the XPCOM/XPCONNECT interface
+// mozILineTerm (unregistered)
+
+#ifndef mozILineTermAux_h___
+#define mozILineTermAux_h___
+
+#include "nsISupports.h"
+
+#include "nscore.h"
+
+#include "nsIObserver.h"
+#include "mozILineTerm.h"
+
+/* {0eb82b10-43a2-11d3-8e76-006008948af5} */
+#define MOZILINETERMAUX_IID_STR "0eb82b10-43a2-11d3-8e76-006008948af5"
+#define MOZILINETERMAUX_IID \
+  {0x0eb82b10, 0x43a2, 0x11d3, \
+    { 0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5 }}
+
+class mozILineTermAux : public mozILineTerm {
+ public: 
+  NS_DEFINE_STATIC_IID_ACCESSOR(MOZILINETERMAUX_IID)
+
+  // mozILineTerm interface
+  NS_IMETHOD GetCursorRow(PRInt32 *aCursorRow) = 0;
+  NS_IMETHOD SetCursorRow(PRInt32 aCursorRow) = 0;
+
+  NS_IMETHOD GetCursorColumn(PRInt32 *aCursorColumn) = 0;
+  NS_IMETHOD SetCursorColumn(PRInt32 aCursorColumn) = 0;
+
+  NS_IMETHOD Open(const PRUnichar *command,
+                  const PRUnichar *promptRegexp,
+                  PRInt32 options, PRInt32 processType,
+                  nsIDOMDocument *domDoc) = 0;
+
+  NS_IMETHOD Close(const PRUnichar* aCookie) = 0;
+
+  NS_IMETHOD Write(const PRUnichar *buf, const PRUnichar* aCookie) = 0;
+
+  NS_IMETHOD Read(PRInt32 *opcodes,
+                  PRInt32 *buf_row, PRInt32 *buf_col,
+                  const PRUnichar* aCookie,
+                  PRUnichar **_retval) = 0;
+
+  // mozILineTermAux interface add ons
+  // (not scriptable, no authentication cookie required)
+
+  /** Opens LineTerm, a line-oriented terminal interface (without graphics)
+   * @param command name of command to be executed; usually a shell,
+   *        e.g., "/bin/sh"; if set to null string, the command name is
+   *        determined from the environment variable SHELL
+   * @param promptRegexp command prompt regular expression (for future use);
+   *        at the moment, any string terminated by one of the characters
+   *        "#$%>?", followed by a space, is assumed to be a prompt
+   * @param options LineTerm option bits (usually 0; see lineterm.h)
+   * @param processType command shell type; if set to -1, type is determined
+   *        from the command name
+   * @param domDoc DOM document object associated with the LineTerm
+   *        (document.cookie will be defined for this document on return)
+   * @param aCookie (output) cookie associated with LineTerm
+   */
+  NS_IMETHOD OpenAux(const PRUnichar *command,
+                     const PRUnichar *promptRegexp,
+                     PRInt32 options, PRInt32 processType,
+                     nsIDOMDocument *domDoc,
+                     nsIObserver* anObserver,
+                     nsString& aCookie) = 0;
+
+  /** Suspend/restores LineTerm operation
+   * @param aSuspend suspension state flag
+   */
+  NS_IMETHOD SuspendAux(PRBool aSuspend) = 0;
+
+  /** Closes LineTerm
+   */
+  NS_IMETHOD CloseAux(void) = 0;
+
+  /** Close all LineTerms, not just this one
+   */
+  NS_IMETHOD CloseAllAux(void) = 0;
+
+  /** Read output data and style strings and parameters from LineTerm
+   * @param opcodes (output) output data descriptor bits (see lineterm.h)
+   * @param buf_row (output) row number (>=-1)
+                   (-1 denotes line mode and 0 represents bottom row)
+   * @param buf_col (output) column number (>=0)
+   * @param _retval (output) success code
+   * @param retstyle (output) output style string
+   * @return output data string from LineTerm
+   */
+  NS_IMETHOD ReadAux(PRInt32 *opcodes,
+                     PRInt32 *buf_row, PRInt32 *buf_col,
+                     PRUnichar **_retval, PRUnichar **retstyle) = 0;
+};
+
+// Factory for mozILineTermAux
+
+extern nsresult
+NS_NewLineTermAux(mozILineTermAux** aLineTermAux);
+
+#endif /* mozILineTermAux_h___ */

mozilla/extensions/xmlterm/base/mozIXMLTermShell.idl

@@ -0,0 +1,86 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+/* mozIXMLTermShell.idl: Javascript-accessible wrapper for mozIXMLTerminal
+ */
+
+#include "nsISupports.idl"
+#include "domstubs.idl"
+#include "mozILineTerm.idl"
+
+%{C++
+class nsILineTerm;
+class nsIDOMWindow;
+%}
+
+[scriptable, uuid(0eb82b30-43a2-11d3-8e76-006008948af5)]
+
+interface mozIXMLTermShell : nsISupports
+{
+  readonly attribute long currentEntryNumber; /* current entry (command) no. */
+  attribute long     history;                /* command history buffer count */
+  attribute wstring  prompt;                 /* HTML prompt string */
+
+  /** Initializes XMLterm in specified window
+   * @param contentWin content window object
+   * @param URL URL of document to be loaded in the window
+   *            (set to null string if document is already loaded in window)
+   * @param args argument string to be passed to XMLterm
+   *             (at the moment this just contains any initial input data)
+   */
+  void Init(in nsIDOMWindow contentWin, in wstring URL, in wstring args);
+
+  /** Finalizes (closes) XMLterm
+   */
+  void Finalize();
+  
+  /** Polls for readable data from XMLterm
+   */
+  void Poll();
+
+  /** Writes string to terminal as if the user had typed it (command input)
+   * @param buf string to be transmitted to terminal
+   * @param aCookie document.cookie string for authentication
+   */
+  void SendText(in wstring buf, in wstring cookie);
+
+  /** Opens new XMLterm window with specified args (not yet implemented)
+   * @param args argument string to be passed to XMLterm
+   *             (at the moment this just contains any initial input data)
+   */
+  void NewXMLTermWindow(in wstring args);
+
+  /** Exit browser, closing all windows (not yet implemented)
+   */ 
+  void Exit();
+};
+
+
+%{C++
+
+#define MOZXMLTERMSHELL_CID                  \
+{ /* 0eb82b31-43a2-11d3-8e76-006008948af5 */ \
+   0x0eb82b31, 0x43a2, 0x11d3,               \
+{0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5} }
+
+extern nsresult
+NS_NewXMLTermShell(mozIXMLTermShell** aXMLTermShell);
+%}
+

mozilla/extensions/xmlterm/base/mozIXMLTermStream.h

@@ -0,0 +1,78 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozIXMLTermStream.h: interface to display HTML/XML streams as documents
+//                      (unregistered)
+
+#ifndef mozIXMLTermStream_h___
+#define mozIXMLTermStream_h___
+
+#include "nscore.h"
+
+#include "nsISupports.h"
+#include "nsIDOMDocument.h"
+#include "nsIWebShell.h"
+#include "nsIPresShell.h"
+#include "nsIScriptContext.h"
+#include "nsIInputStream.h"
+
+/* {0eb82b40-43a2-11d3-8e76-006008948af5} */
+#define MOZIXMLTERMSTREAM_IID_STR "0eb82b40-43a2-11d3-8e76-006008948af5"
+#define MOZIXMLTERMSTREAM_IID \
+  {0x0eb82b40, 0x43a2, 0x11d3, \
+    { 0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5 }}
+
+class mozIXMLTermStream : public nsIInputStream
+{
+  public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(MOZIXMLTERMSTREAM_IID);
+
+  // mozIXMLTermStream interface
+
+  /** Open stream in specified frame, or in current frame if frameName is null
+   * @param aDOMWindow parent window
+   * @param frameName name of child frame in which to display stream, or null
+   *                  to display in parent window
+   * @param contentURL URL of stream content
+   * @param contentType MIME type of stream content
+   * @param maxResizeHeight maximum resize height (0=> do not resize)
+   * @return NS_OK on success
+   */
+  NS_IMETHOD Open(nsIDOMWindow* aDOMWindow,
+                  const char* frameName,
+                  const char* contentURL,
+                  const char* contentType,
+                  PRInt32 maxResizeHeight) = 0;
+
+  /** Write Unicode string to stream (blocks until write is completed)
+   * @param buf string to write
+   * @return NS_OK on success
+   */
+  NS_IMETHOD Write(const PRUnichar* buf) = 0;
+};
+
+#define MOZXMLTERMSTREAM_CID                 \
+{ /* 0eb82b41-43a2-11d3-8e76-006008948af5 */ \
+   0x0eb82b41, 0x43a2, 0x11d3,               \
+{0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5} }
+extern nsresult
+NS_NewXMLTermStream(mozIXMLTermStream** aXMLTermStream);
+
+#endif /* mozIXMLTermStream_h___ */

mozilla/extensions/xmlterm/base/mozIXMLTerminal.h

@@ -0,0 +1,127 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozIXMLTerminal.h: primary interface for XMLterm operations
+//                    (unregistered)
+
+#ifndef mozIXMLTerminal_h___
+#define mozIXMLTerminal_h___
+
+#include "nscore.h"
+
+#include "nsISupports.h"
+#include "nsIDOMDocument.h"
+#include "nsIWebShell.h"
+#include "nsIPresShell.h"
+#include "nsIScriptContext.h"
+
+#include "mozIXMLTermShell.h"
+
+/* {0eb82b20-43a2-11d3-8e76-006008948af5} */
+#define MOZIXMLTERMINAL_IID_STR "0eb82b20-43a2-11d3-8e76-006008948af5"
+#define MOZIXMLTERMINAL_IID \
+  {0x0eb82b20, 0x43a2, 0x11d3, \
+    { 0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5 }}
+
+class mozIXMLTerminal : public nsISupports {
+
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(MOZIXMLTERMINAL_IID)
+
+  /** Initializes XMLterm in specified web shell
+   * @param aWebShell web shell in which to embed XMLterm
+   * @param aXMLTermShell scriptable wrapper shell for XMLterm
+   * @param URL URL of document to be loaded in the window
+   *            (set to null string if document is already loaded in window)
+   * @param args argument string to be passed to XMLterm
+   *             (at the moment this just contains any initial input data)
+   */
+  NS_IMETHOD Init(nsIWebShell* aWebShell,
+                  mozIXMLTermShell* aXMLTermShell,
+                  const PRUnichar* aURL,
+                  const PRUnichar* args) = 0;
+
+  /** Finalizes (closes) XMLterm
+   */
+  NS_IMETHOD Finalize(void) = 0;
+
+  /** Polls for readable data from XMLterm
+   */
+  NS_IMETHOD Poll(void) = 0;
+
+  /** Gets current entry (command) number
+   * @param aNumber (output) current entry number
+   */
+  NS_IMETHOD GetCurrentEntryNumber(PRInt32 *aNumber) = 0;
+
+  /** Gets command history buffer count
+   * @param aHistory (output) history buffer count
+   */
+  NS_IMETHOD GetHistory(PRInt32 *aHistory) = 0;
+
+  /** Sets command history buffer count
+   * @param aHistory history buffer count
+   */
+  NS_IMETHOD SetHistory(PRInt32 aHistory) = 0;
+
+  /** Gets prompt string
+   * @param aPrompt (output) prompt string
+   */
+  NS_IMETHOD GetPrompt(PRUnichar **aPrompt) = 0;
+
+  /** Sets prompt string
+   * @param aPrompt prompt string
+   */
+  NS_IMETHOD SetPrompt(const PRUnichar* aPrompt) = 0;
+
+  /** Writes string to terminal as if the user had typed it (without authenitcation)
+   * @param aString string to be transmitted to terminal
+   */
+  NS_IMETHOD SendTextAux(const nsString& aString) = 0;
+
+  /** Writes string to terminal as if the user had typed it (command input)
+   * @param aString string to be transmitted to terminal
+   * @param aCookie document.cookie string for authentication
+   */
+  NS_IMETHOD SendText(const nsString& aString, const PRUnichar* aCookie) = 0;
+
+  /** Paste data from clipboard into XMLterm at current input line cursor location
+   */
+  NS_IMETHOD Paste() = 0;
+
+  /** Gets document associated with XMLterm
+   * @param aDoc (output) DOM document
+   */
+  NS_IMETHOD GetDocument(nsIDOMDocument** aDoc) = 0;
+
+  /** Gets presentation shell with XMLterm
+   * @param aPresShell (output) presentation shell
+   */
+  NS_IMETHOD GetPresShell(nsIPresShell** aPresShell) = 0;
+};
+
+#define MOZXMLTERMINAL_CID                       \
+{ /* 0eb82b21-43a2-11d3-8e76-006008948af5 */ \
+   0x0eb82b21, 0x43a2, 0x11d3,               \
+{0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5} }
+extern nsresult
+NS_NewXMLTerminal(mozIXMLTerminal** aXMLTerminal);
+
+#endif /* mozIXMLTerminal_h___ */

mozilla/extensions/xmlterm/base/mozLineTerm.cpp

@@ -0,0 +1,681 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozLineTerm.cpp: class implementing mozILineTerm/mozILineTermAux interfaces,
+// providing an XPCOM/XPCONNECT wrapper for the LINETERM module
+
+#include "stdio.h"
+
+#include "nspr.h"
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "prlog.h"
+#include "nsIAllocator.h"
+
+#include "nsIServiceManager.h"
+#include "nsIPref.h"
+#include "nsIPrincipal.h"
+
+#include "nsIDocument.h"
+#include "nsIDOMHTMLDocument.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermUtils.h"
+#include "mozLineTerm.h"
+#include "lineterm.h"
+
+#define MAXCOL 4096            // Maximum columns in line buffer
+
+static NS_DEFINE_IID(kISupportsIID,     NS_ISUPPORTS_IID);
+static NS_DEFINE_CID(kPrefServiceCID,     NS_PREF_CID);
+
+static NS_DEFINE_IID(kILineTermIID,     MOZILINETERM_IID);
+static NS_DEFINE_IID(kILineTermAuxIID,  MOZILINETERMAUX_IID);
+
+static NS_DEFINE_IID(kLineTermCID,      MOZLINETERM_CID);
+
+/////////////////////////////////////////////////////////////////////////
+// mozLineTerm, mozLineTermAux factories
+/////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewLineTerm(mozILineTerm** aLineTerm)
+{
+    NS_PRECONDITION(aLineTerm != nsnull, "null ptr");
+    if (! aLineTerm)
+        return NS_ERROR_NULL_POINTER;
+
+    *aLineTerm = new mozLineTerm();
+    if (! *aLineTerm)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aLineTerm);
+    return NS_OK;
+}
+
+nsresult
+NS_NewLineTermAux(mozILineTermAux** aLineTermAux)
+{
+    NS_PRECONDITION(aLineTermAux != nsnull, "null ptr");
+    if (! aLineTermAux)
+        return NS_ERROR_NULL_POINTER;
+
+    *aLineTermAux = new mozLineTerm();
+    if (! *aLineTermAux)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aLineTermAux);
+    return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////
+// mozLineTerm implementaion
+/////////////////////////////////////////////////////////////////////////
+PRBool mozLineTerm::mLoggingEnabled = false;
+
+mozLineTerm::mozLineTerm() :
+  mCursorRow(0),
+  mCursorColumn(0),
+  mSuspended(false),
+  mEchoFlag(true),
+  mObserver(nsnull),
+  mCookie(""),
+  mLastTime(LL_ZERO)
+{
+  NS_INIT_REFCNT();
+  mLTerm = lterm_new();
+}
+
+
+mozLineTerm::~mozLineTerm()
+{
+  lterm_delete(mLTerm);
+  mObserver = nsnull;
+}
+
+
+// Implement AddRef and Release
+NS_IMPL_ADDREF(mozLineTerm)
+NS_IMPL_RELEASE(mozLineTerm)
+
+
+NS_IMETHODIMP 
+mozLineTerm::QueryInterface(REFNSIID aIID,void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  //XMLT_LOG(mozLineTerm::QueryInterface,30,("0x%x\n",aIID));
+
+  if ( aIID.Equals(kISupportsIID)) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(mozILineTermAux*,this));
+
+  } else if ( aIID.Equals(mozILineTerm::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(mozILineTerm*,
+                                   NS_STATIC_CAST(mozILineTermAux*,this));
+
+  } else if ( aIID.Equals(mozILineTermAux::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(mozILineTermAux*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+/** Checks if preference settings are secure for LineTerm creation and use
+ */
+NS_IMETHODIMP mozLineTerm::ArePrefsSecure(PRBool *_retval)
+{
+  nsresult result;
+
+  XMLT_LOG(mozLineTerm::ArePrefsSecure,30,("\n"));
+
+  if (!_retval)
+    return NS_ERROR_FAILURE;
+
+  *_retval = false;
+
+  nsIPref* prefService;
+  nsServiceManager::GetService(kPrefServiceCID, NS_GET_IID(nsIPref), 
+                               (nsISupports**) &prefService);
+  if (!prefService)
+    return NS_ERROR_FAILURE;
+
+  // Check if Components JS object is secure
+  PRBool checkXPC;
+  result = prefService->GetBoolPref("security.checkxpconnect", &checkXPC);
+  if (NS_FAILED(result))
+    return NS_ERROR_FAILURE;
+
+  if (!checkXPC) {
+    XMLT_ERROR("mozLineTerm::ArePrefsSecure: Error - Please add the line\n"
+    "  pref(\"security.checkxpcconnect\",true);\n"
+    "to your preferences file (.mozilla/prefs.js)\n");
+    *_retval = false;
+#if 0  // Temporarily comented out
+    return NS_OK;
+#endif
+  }
+
+  nsCAutoString secString ("security.policy.");
+  /* Get global policy name. */
+  char *policyStr;
+
+  result = prefService->CopyCharPref("javascript.security_policy", &policyStr);
+  if (NS_SUCCEEDED(result) && policyStr) {
+    secString.Append(policyStr);
+    nsAllocator::Free(policyStr);
+  } else {
+    secString.Append("default");
+  }
+
+  secString.Append(".htmldocument.cookie");
+
+  char* prefStr = secString.ToNewCString();
+  XMLT_LOG(mozLineTerm::ArePrefsSecure,32, ("prefStr=%s\n", prefStr));
+
+  char *secLevelString;
+  result = prefService->CopyCharPref(prefStr, &secLevelString);
+  nsAllocator::Free(prefStr);
+
+  if (NS_FAILED(result) || !secLevelString)
+    return NS_ERROR_FAILURE;
+
+  XMLT_LOG(mozLineTerm::ArePrefsSecure,32,
+           ("secLevelString=%s\n", secLevelString));
+
+  *_retval = (PL_strcmp(secLevelString, "sameOrigin") == 0);
+  nsAllocator::Free(secLevelString);
+
+  if (!(*_retval)) {
+    XMLT_ERROR("mozLineTerm::ArePrefsSecure: Error - Please add the line\n"
+    "  pref(\"security.policy.default.htmldocument.cookie\",\"sameOrigin\");\n"
+    "to your preferences file (.mozilla/prefs.js)\n");
+  }
+
+  return NS_OK;
+}
+
+
+/** Checks document principal to ensure it has LineTerm creation privileges.
+ * Returns the principal string if the principal is secure,
+ * and a (zero length) null string if the principal is insecure.
+ */
+NS_IMETHODIMP mozLineTerm::GetSecurePrincipal(nsIDOMDocument *domDoc,
+                                              char** aPrincipalStr)
+{
+  XMLT_LOG(mozLineTerm::GetSecurePrincipal,30,("\n"));
+
+  if (!aPrincipalStr)
+    return NS_ERROR_FAILURE;
+
+  *aPrincipalStr = nsnull;
+
+  // Get principal string
+  nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+  if (!doc)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPrincipal> principal=dont_AddRef(doc->GetDocumentPrincipal());
+
+#if 0  // Temporarily comented out, because ToString is not immplemented
+  result = principal->ToString(aPrincipalStr);
+  if (NS_FAILED(result) || !*aPrincipalStr)
+    return NS_ERROR_FAILURE;
+#else
+  const char temStr[] = "unknown";
+  PRInt32 temLen = strlen(temStr);
+  *aPrincipalStr = strncpy((char*) nsAllocator::Alloc(temLen+1),
+                           temStr, temLen+1);
+#endif
+
+  XMLT_LOG(mozLineTerm::GetSecurePrincipal,32,("aPrincipalStr=%s\n",
+                                               *aPrincipalStr));
+
+  // Check if principal is secure
+  PRBool insecure = false;
+  if (insecure) {
+    // Return null string
+    XMLT_ERROR("mozLineTerm::GetSecurePrincipal: Error - "
+               "Insecure document principal %s\n", *aPrincipalStr);
+    nsAllocator::Free(*aPrincipalStr);
+    *aPrincipalStr = (char*) nsAllocator::Alloc(1);
+    **aPrincipalStr = '\0';
+  }
+
+  return NS_OK;
+}
+
+
+/** Open LineTerm without callback
+ */
+NS_IMETHODIMP mozLineTerm::Open(const PRUnichar *command,
+                                const PRUnichar *promptRegexp,
+                                PRInt32 options, PRInt32 processType,
+                                nsIDOMDocument *domDoc)
+{
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::Open: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  nsAutoString aCookie;
+  return OpenAux(command, promptRegexp, options, processType, domDoc,
+                 nsnull, aCookie);
+}
+
+
+/** Open LineTerm, with an Observer for callback to process new input/output
+ */
+NS_IMETHODIMP mozLineTerm::OpenAux(const PRUnichar *command,
+                                   const PRUnichar *promptRegexp,
+                                   PRInt32 options, PRInt32 processType,
+                                   nsIDOMDocument *domDoc,
+                                   nsIObserver* anObserver,
+                                   nsString& aCookie)
+{
+  nsresult result;
+
+  XMLT_LOG(mozLineTerm::Open,20,("\n"));
+
+  // Ensure that preferences are secure for LineTerm creation and use
+  PRBool arePrefsSecure;
+  result = ArePrefsSecure(&arePrefsSecure);
+#if 0  // Temporarily comented out
+  if (NS_FAILED(result) || !arePrefsSecure)
+    return NS_ERROR_FAILURE;
+#endif
+
+  // Ensure that document principal is secure for LineTerm creation
+  char* securePrincipal;
+  result = GetSecurePrincipal(domDoc, &securePrincipal);
+  if (NS_FAILED(result))
+    return NS_ERROR_FAILURE;
+
+  if (strlen(securePrincipal) == 0) {
+    nsAllocator::Free(securePrincipal);
+    XMLT_ERROR("mozLineTerm::OpenAux: Error - "
+               "Failed to create LineTerm for insecure document principal\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMHTMLDocument> domHTMLDoc = do_QueryInterface(domDoc);
+  if (!domHTMLDoc)
+      return NS_ERROR_FAILURE;
+
+  // Ensure that cookie attribute of document is defined
+  nsAutoString cookiePrefix ( "xmlterm=" );
+  nsAutoString cookieStr;
+  result = domHTMLDoc->GetCookie(cookieStr);
+
+  if (NS_SUCCEEDED(result) &&
+      (cookieStr.Length() > cookiePrefix.Length()) &&
+      (cookieStr.Find(cookiePrefix) == 0)) {
+    // Cookie value already defined for document; simply copy it
+    mCookie = cookieStr;
+
+  } else {
+    // Create random session cookie
+    nsAutoString cookieValue;
+    result = mozXMLTermUtils::RandomCookie(cookieValue);
+    if (NS_FAILED(result))
+      return result;
+
+    mCookie = cookiePrefix;
+    mCookie += cookieValue;
+
+    // Set new cookie value
+    result = domHTMLDoc->SetCookie(mCookie);
+    if (NS_FAILED(result))
+      return result;
+  }
+
+  // Return copy of cookie to caller
+  aCookie = mCookie;
+
+  mObserver = anObserver;  // non-owning reference
+
+  // Convert cookie to CString
+  char* cookieCStr = mCookie.ToNewCString();
+  XMLT_LOG(mozLineTerm::Open,22, ("mCookie=%s\n", cookieCStr));
+
+  if (anObserver != nsnull) {
+    result = lterm_open(mLTerm, NULL, cookieCStr, L"#$%>?", options,
+                        processType, mozLineTerm::Callback, (void *) this);
+  } else {
+    result = lterm_open(mLTerm, NULL, cookieCStr, L"#$%>?", options,
+                        processType, NULL, NULL);
+  }
+
+  // Free cookie CString
+  nsAllocator::Free(cookieCStr);
+
+  if (mLoggingEnabled) {
+    // Log time stamp for LineTerm open operation
+    nsAutoString timeStamp;
+    result = mozXMLTermUtils::TimeStamp(0, mLastTime, timeStamp);
+    if (NS_SUCCEEDED(result)) {
+      char* temStr = timeStamp.ToNewCString();
+      fprintf(stderr, "<TS %s> LineTerm %d opened by principal %s\n",
+              temStr, mLTerm, securePrincipal);
+      nsAllocator::Free(temStr);
+    }
+  }
+
+  if (result == 0) {
+    return NS_OK;
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+/** GTK-style callback funtion for mozLineTerm object
+ */
+void mozLineTerm::Callback(gpointer data,
+                           gint source,
+                           GdkInputCondition condition)
+{
+  mozLineTerm* lineTerm = (mozLineTerm*) data;
+
+  //XMLT_LOG(mozLineTerm::Callback,50,("\n"));
+
+  PR_ASSERT(lineTerm != nsnull);
+  PR_ASSERT(lineTerm->mObserver != nsnull);
+
+  lineTerm->mObserver->Observe((nsISupports*) lineTerm, nsnull, nsnull);
+  return;
+}
+
+/** Suspends (or restores) LineTerm activity depending upon aSuspend
+ */
+NS_IMETHODIMP mozLineTerm::SuspendAux(PRBool aSuspend)
+{
+  mSuspended = aSuspend;
+  return NS_OK;
+}
+
+
+/** Close LineTerm (a Finalize method)
+ */
+NS_IMETHODIMP mozLineTerm::Close(const PRUnichar* aCookie)
+{
+  if (!mCookie.Equals(aCookie)) {
+    XMLT_ERROR("mozLineTerm::Close: Error - Cookie mismatch\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::Close: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  if (lterm_close(mLTerm) == 0) {
+    return NS_OK;
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+
+  mObserver = nsnull;
+}
+
+
+/** Close LineTerm (a Finalize method)
+ */
+NS_IMETHODIMP mozLineTerm::CloseAux(void)
+{
+  if (lterm_close(mLTerm) == 0) {
+    return NS_OK;
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+
+  mObserver = nsnull;
+}
+
+
+/** Close all LineTerm instances
+ */
+NS_IMETHODIMP mozLineTerm::CloseAllAux(void)
+{
+  lterm_close_all();
+  return NS_OK;
+}
+
+
+/** Writes a string to LTERM
+ */
+NS_IMETHODIMP mozLineTerm::Write(const PRUnichar *buf,
+                                 const PRUnichar* aCookie)
+{
+  if (!mCookie.Equals(aCookie)) {
+    XMLT_ERROR("mozLineTerm::Write: Error - Cookie mismatch\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::Write: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  XMLT_LOG(mozLineTerm::Write,30,("\n"));
+
+  nsresult result;
+  UNICHAR ubuf[MAXCOL];
+  int jLen, retCode;
+  PRBool newline = false;
+
+  jLen = 0;
+  while ((jLen < MAXCOL-1) && (buf[jLen] != 0)) {
+    if (buf[jLen] == U_LINEFEED)
+      newline = true;
+
+    ubuf[jLen++] = (UNICHAR) buf[jLen];
+  }
+
+  if (jLen >= MAXCOL-1) {
+    XMLT_ERROR("mozLineTerm::Write: Error - Buffer overflow\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (mLoggingEnabled && (jLen > 0)) {
+    /* Log all input to STDERR */
+    ucsprint(stderr, ubuf, jLen);
+
+    nsAutoString timeStamp;
+    result = mozXMLTermUtils::TimeStamp(60, mLastTime, timeStamp);
+
+    if (NS_SUCCEEDED(result) && (timeStamp.Length() > 0)) {
+      char* temStr = timeStamp.ToNewCString();
+      fprintf(stderr, "<TS %s>\n", temStr);
+      nsAllocator::Free(temStr);
+
+    } else if (newline) {
+      fprintf(stderr, "\n");
+    }
+  }
+
+  retCode = lterm_write(mLTerm, ubuf, jLen, LTERM_WRITE_PLAIN_INPUT);
+  if (retCode < 0)
+    return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozLineTerm::Read(PRInt32 *opcodes,
+                                PRInt32 *buf_row, PRInt32 *buf_col,
+                                const PRUnichar* aCookie,
+                                PRUnichar **_retval)
+{
+  if (!mCookie.Equals(aCookie)) {
+    XMLT_ERROR("mozLineTerm::Read: Error - Cookie mismatch\n");
+    return NS_ERROR_FAILURE;
+  }
+
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::Read: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  return ReadAux(opcodes, buf_row, buf_col, _retval, nsnull);
+}
+
+
+/** Reads a line from LTERM and returns it as a string (may be null string)
+ */
+NS_IMETHODIMP mozLineTerm::ReadAux(PRInt32 *opcodes,
+                                   PRInt32 *buf_row, PRInt32 *buf_col,
+                                   PRUnichar **_retval, PRUnichar **retstyle)
+{
+  UNICHAR ubuf[MAXCOL];
+  UNISTYLE ustyle[MAXCOL];
+  int cursor_row, cursor_col;
+  int retCode, j;
+
+  XMLT_LOG(mozLineTerm::ReadAux,30,("\n"));
+
+  retCode = lterm_read(mLTerm, 0, ubuf, MAXCOL-1,
+                       ustyle, opcodes,
+                       buf_row, buf_col, &cursor_row, &cursor_col);
+  if (retCode < 0)
+    return NS_ERROR_FAILURE;
+
+  if (*opcodes == 0) {
+    // Return null pointer(s)
+    *_retval = nsnull;
+
+    if (retstyle != nsnull)
+      *retstyle = nsnull;
+
+  } else {
+    // Return output string
+    mCursorRow = cursor_row;
+    mCursorColumn = cursor_col;
+
+    XMLT_LOG(mozLineTerm::Read,72,("cursor_col=%d\n", cursor_col));
+
+    int allocBytes = sizeof(PRUnichar)*(retCode + 1);
+    *_retval = (PRUnichar*) nsAllocator::Alloc(allocBytes);
+
+    for (j=0; j<retCode; j++)
+      (*_retval)[j] = (PRUnichar) ubuf[j];
+
+    // Insert null string terminator
+    (*_retval)[retCode] = 0;
+
+    if (retstyle != nsnull) {
+      // Return style array as well
+      *retstyle = (PRUnichar*) nsAllocator::Alloc(allocBytes);
+
+      for (j=0; j<retCode; j++)
+        (*retstyle)[j] = (PRUnichar) ustyle[j];
+
+      // Insert null string terminator
+      (*retstyle)[retCode] = 0;
+    }
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozLineTerm::GetCursorRow(PRInt32 *aCursorRow)
+{
+  *aCursorRow = mCursorRow;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozLineTerm::SetCursorRow(PRInt32 aCursorRow)
+{
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::SetCursorRow: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK; // Do nothing for the moment
+}
+
+
+NS_IMETHODIMP mozLineTerm::GetCursorColumn(PRInt32 *aCursorColumn)
+{
+  *aCursorColumn = mCursorColumn;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozLineTerm::SetCursorColumn(PRInt32 aCursorColumn)
+{
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::SetCursorColumn: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK; // Do nothing for the moment
+}
+
+
+NS_IMETHODIMP mozLineTerm::GetEchoFlag(PRBool *aEchoFlag)
+{
+  *aEchoFlag = mEchoFlag;
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozLineTerm::SetEchoFlag(PRBool aEchoFlag)
+{
+  int result;
+
+  if (mSuspended) {
+    XMLT_ERROR("mozLineTerm::SetEchoFlag: Error - LineTerm %d is suspended\n",
+               mLTerm);
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aEchoFlag) {
+    result = lterm_setecho(mLTerm, 1);
+  } else {
+    result = lterm_setecho(mLTerm, 0);
+  }
+
+  if (result != 0)
+    return NS_ERROR_FAILURE;
+
+  mEchoFlag = aEchoFlag;
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozLineTerm.h

@@ -0,0 +1,139 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozLineTerm.h: Declaration of mozLineTerm class
+// which implements the LineTerm and LineTermAux interfaces.
+// and provides an XPCOM/XPCONNECT wrapper to the LINETERM module
+
+#include "nspr.h"
+#include "nscore.h"
+#include "nsString.h"
+
+#include "nsIServiceManager.h"
+
+#include "nsIDocument.h"
+#include "nsIDOMHTMLDocument.h"
+
+#include "mozILineTermAux.h"
+
+#define MAXCOL 4096            // Maximum columns in line buffer
+
+class mozLineTerm : public mozILineTermAux
+{
+public:
+  mozLineTerm();
+  virtual ~mozLineTerm();
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+
+  // mozILineTerm interface
+  NS_IMETHOD GetCursorRow(PRInt32 *aCursorRow);
+  NS_IMETHOD SetCursorRow(PRInt32 aCursorRow);
+
+  NS_IMETHOD GetCursorColumn(PRInt32 *aCursorColumn);
+  NS_IMETHOD SetCursorColumn(PRInt32 aCursorColumn);
+
+  NS_IMETHOD GetEchoFlag(PRBool *aEchoFlag);
+  NS_IMETHOD SetEchoFlag(PRBool aEchoFlag);
+
+  NS_IMETHOD Open(const PRUnichar *command,
+                  const PRUnichar *promptRegexp,
+                  PRInt32 options, PRInt32 processType,
+                  nsIDOMDocument *domDoc);
+
+  NS_IMETHOD Close(const PRUnichar* aCookie);
+
+  NS_IMETHOD Write(const PRUnichar *buf, const PRUnichar* aCookie);
+
+  NS_IMETHOD Read(PRInt32 *opcodes,
+                  PRInt32 *buf_row, PRInt32 *buf_col,
+                  const PRUnichar* aCookie,
+                  PRUnichar **_retval);
+
+  // mozILineTermAux interface add ons
+  // (not scriptable, no authentication cookie required)
+  NS_IMETHOD OpenAux(const PRUnichar *command,
+                     const PRUnichar *promptRegexp,
+                     PRInt32 options, PRInt32 processType,
+                     nsIDOMDocument *domDoc,
+                     nsIObserver* anObserver,
+                     nsString& aCookie);
+
+  NS_IMETHOD SuspendAux(PRBool aSuspend);
+
+  NS_IMETHOD CloseAux(void);
+
+  NS_IMETHOD CloseAllAux(void);
+
+  NS_IMETHOD ReadAux(PRInt32 *opcodes,
+                     PRInt32 *buf_row, PRInt32 *buf_col,
+                     PRUnichar **_retval, PRUnichar **retstyle);
+  // others
+
+  /** GTK event callback function
+   */
+  static void Callback(gpointer data,
+                       gint source,
+                       GdkInputCondition condition);
+
+  /** Flag controlling logging of user input to STDERR */
+  static PRBool mLoggingEnabled;
+
+protected:
+  /** Checks if Mozilla preference settings are secure
+   * @param _retval (output) true if settings are secure
+   */
+  NS_IMETHOD ArePrefsSecure(PRBool *_retval);
+
+  /** Checks if document principal is secure and returns principal string
+   * @param domDOC DOM document object
+   * @param aPrincipalStr (output) document principal string
+   */
+  NS_IMETHOD GetSecurePrincipal(nsIDOMDocument *domDoc,
+                                char** aPrincipalStr);
+
+  /** lineterm descriptor index returned by lterm_new (>= 0) */
+  int mLTerm;
+
+  /** current cursor row position */
+  int mCursorRow;
+
+  /** current cursor column position */
+  int mCursorColumn;
+
+  /** flag controlling whether is LineTerm is suspended */
+  PRBool mSuspended;
+
+  /** flag controlling input echo in LineTerm */
+  PRBool mEchoFlag;
+
+  /** non-owning reference to Observer to be notified when data is available
+   * for reading from LineTerm
+   */
+  nsIObserver* mObserver;
+
+  /** cookie string used for authentication (stored in document.cookie) */
+  nsString mCookie;
+
+  /** record of last time when timestamp was displayed in user input log */
+  PRTime mLastTime;
+
+};

mozilla/extensions/xmlterm/base/mozXMLT.h

@@ -0,0 +1,67 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLT.h: XMLTerm common header
+
+#ifndef _MOZXMLT_H
+
+#define _MOZXMLT_H 1
+
+// Standard C header files
+#ifndef _STRING_H
+#include <string.h>
+#endif
+
+// public declarations
+#include "lineterm.h"
+#include "tracelog.h"
+
+// private declarations
+
+#define XMLT_TLOG_MODULE  2
+#define XMLT_ERROR                            TLOG_ERROR
+#define XMLT_WARNING                          TLOG_WARNING
+#define XMLT_LOG(procname,level,args)         TLOG_PRINT(XMLT_TLOG_MODULE,procname,level,args)
+
+// Tracing versions of NS_IMPL_ADDREF and NS_IMPL_RELEASE
+
+#define XMLT_IMPL_ADDREF(_class) \
+NS_IMETHODIMP_(nsrefcnt) _class::AddRef(void)  \
+{                                              \
+  NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt"); \
+  ++mRefCnt;                                   \
+  XMLT_WARNING(#_class ":AddRef, mRefCnt=%d\n", mRefCnt); \
+  return mRefCnt;                              \
+}
+
+#define XMLT_IMPL_RELEASE(_class) \
+NS_IMETHODIMP_(nsrefcnt) _class::Release(void)  \
+{                                               \
+  NS_PRECONDITION(0 != mRefCnt, "dup release"); \
+  --mRefCnt;                                    \
+  XMLT_WARNING(#_class ":Release, mRefCnt=%d\n", mRefCnt); \
+  if (mRefCnt == 0) {                           \
+    NS_DELETEXPCOM(this);                       \
+    return 0;                                   \
+  }                                             \
+  return mRefCnt;                               \
+}
+
+#endif  /* _MOZXMLT_H */

mozilla/extensions/xmlterm/base/mozXMLTermFactory.cpp

@@ -0,0 +1,298 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermFactory.cpp: XPCOM factory for mozIXMLTermShell, mozILineTerm
+
+#include "nsCOMPtr.h"
+#include "nscore.h"
+#include "nspr.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsXPComFactory.h"
+
+#include "mozXMLT.h"
+#include "mozLineTerm.h"
+#include "mozIXMLTermShell.h"
+
+static NS_DEFINE_IID(kISupportsIID,        NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIFactoryIID,         NS_IFACTORY_IID);
+static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
+static NS_DEFINE_CID(kXMLTermShellCID,     MOZXMLTERMSHELL_CID);
+static NS_DEFINE_CID(kLineTermCID,         MOZLINETERM_CID);
+
+class XMLTermFactory : public nsIFactory
+{
+public:
+  XMLTermFactory(const nsCID &aClass, const char* className, const char* progID);
+
+  // nsISupports methods
+  NS_DECL_ISUPPORTS
+
+  // nsIFactory methods
+  NS_IMETHOD CreateInstance(nsISupports *aOuter,
+                            const nsIID &aIID,
+                            void **aResult);
+
+  NS_IMETHOD LockFactory(PRBool aLock);
+
+protected:
+  virtual ~XMLTermFactory();
+
+protected:
+  nsCID       mClassID;
+  const char* mClassName;
+  const char* mProgID;
+};
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermFactory implementation
+/////////////////////////////////////////////////////////////////////////
+
+// Globals, useful to check if safe to unload module
+static PRInt32 gLockCnt = 0; 
+static PRInt32 gInstanceCnt = 0; 
+
+XMLTermFactory::XMLTermFactory(const nsCID &aClass, 
+                               const char* className,
+                               const char* progID):
+  mClassID(aClass),
+  mClassName(className),
+  mProgID(progID)
+{
+  // Zero reference counter
+  NS_INIT_REFCNT();
+  PR_AtomicIncrement(&gInstanceCnt);
+}
+
+
+XMLTermFactory::~XMLTermFactory()
+{
+  NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
+  PR_AtomicDecrement(&gInstanceCnt);
+}
+
+
+NS_IMETHODIMP
+XMLTermFactory::QueryInterface(const nsIID &aIID, void **aResult)
+{
+  if (!aResult)
+    return NS_ERROR_NULL_POINTER;
+
+  // Always NULL result, in case of failure
+  *aResult = nsnull;
+
+  if (aIID.Equals(kISupportsIID)) {
+    *aResult = NS_STATIC_CAST(nsISupports*, this);
+
+  } else if (aIID.Equals(kIFactoryIID)) {
+    *aResult = NS_STATIC_CAST(nsIFactory*, this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+NS_IMPL_ADDREF(XMLTermFactory);
+NS_IMPL_RELEASE(XMLTermFactory);
+
+
+NS_IMETHODIMP
+XMLTermFactory::CreateInstance(nsISupports *aOuter,
+                               const nsIID &aIID,
+                               void **aResult)
+{
+  if (!aResult)
+    return NS_ERROR_NULL_POINTER;
+
+  if (aOuter)
+    return NS_ERROR_NO_AGGREGATION;
+
+  *aResult = nsnull;
+
+  nsresult rv;
+
+  nsISupports *inst = nsnull;
+  if (mClassID.Equals(kXMLTermShellCID)) {
+    if (NS_FAILED(rv = NS_NewXMLTermShell((mozIXMLTermShell**) &inst)))
+      return rv;
+
+  } else if (mClassID.Equals(kLineTermCID)) {
+    if (NS_FAILED(rv = NS_NewLineTerm((mozILineTerm**) &inst)))
+      return rv;
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  if (! inst)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  if (NS_FAILED(rv = inst->QueryInterface(aIID, aResult))) {
+    // We didn't get the right interface.
+    NS_ERROR("didn't support the interface you wanted");
+  }
+
+  NS_IF_RELEASE(inst);
+  return rv;
+}
+
+
+NS_IMETHODIMP
+XMLTermFactory::LockFactory(PRBool aLock)
+{ 
+  if (aLock) { 
+    PR_AtomicIncrement(&gLockCnt); 
+  } else { 
+    PR_AtomicDecrement(&gLockCnt); 
+  } 
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Exported functions for loading, registering, unregistering, and unloading
+////////////////////////////////////////////////////////////////////////////
+
+// Return approptiate factory to the caller
+extern "C" NS_EXPORT nsresult
+NSGetFactory(nsISupports* aServMgr,
+             const nsCID &aClass,
+             const char *aClassName,
+             const char *aProgID,
+             nsIFactory **aFactory)
+{
+  static PRBool ltermInitialized = false;
+  static PRBool xmltermInitialized = false;
+
+  if (!ltermInitialized) {
+    // Initialize all LINETERM operations
+    // (This initialization needs to be done at factory creation time;
+    //  trying to do it earlier, i.e., at registration time,
+    //  does not work ... something to do with loading of static global
+    //  variables.)
+
+    int messageLevel = 8;
+    char* debugStr = (char*) PR_GetEnv("LTERM_DEBUG");
+
+    if (debugStr && (strlen(debugStr) == 1)) {
+      messageLevel = 98;
+      debugStr = nsnull;
+    }
+
+    int result = lterm_init(0);
+    if (result == 0) {
+      tlog_set_level(LTERM_TLOG_MODULE, messageLevel, debugStr);
+    }
+    ltermInitialized = true;
+
+    char* logStr = (char*) PR_GetEnv("LTERM_LOG");
+    if (logStr && (strlen(logStr) > 0)) {
+      // Enable LineTerm logging
+      mozLineTerm::mLoggingEnabled = true;
+    }
+  }
+
+  if (aClass.Equals(kXMLTermShellCID) && !xmltermInitialized) {
+    // Set initial debugging message level for XMLterm
+    int messageLevel = 8;
+    char* debugStr = (char*) PR_GetEnv("XMLT_DEBUG");
+                      
+    if (debugStr && (strlen(debugStr) == 1)) {
+      messageLevel = 98;
+      debugStr = nsnull;
+    }
+
+    tlog_set_level(XMLT_TLOG_MODULE, messageLevel, debugStr);
+    xmltermInitialized = true;
+  }
+
+  if (!aFactory)
+    return NS_ERROR_NULL_POINTER;
+
+  *aFactory = nsnull;
+
+  XMLTermFactory* factory = new XMLTermFactory(aClass, aClassName,
+                                               aProgID);
+  if (factory == nsnull)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  NS_ADDREF(factory);
+  *aFactory = factory;
+  return NS_OK;
+}
+
+
+extern "C" NS_EXPORT nsresult
+NSRegisterSelf(nsISupports* aServMgr , const char* aPath)
+{
+  nsresult result;
+
+  nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &result));
+  if (NS_FAILED(result)) return result;
+
+  NS_WITH_SERVICE(nsIComponentManager, compMgr, kComponentManagerCID, &result);
+  if (NS_FAILED(result)) return result;
+
+  printf("Registering lineterm interface\n");
+
+  result = compMgr->RegisterComponent(kLineTermCID,
+                                      "LineTerm Component",
+                                      "component://mozilla/xmlterm/lineterm",
+                                      aPath, PR_TRUE, PR_TRUE);
+
+  if (NS_FAILED(result)) return result;
+
+  printf("Registering xmlterm shell interface\n");
+
+  result = compMgr->RegisterComponent(kXMLTermShellCID,
+                                      "XMLTerm Shell Component",
+                                      "component://mozilla/xmlterm/xmltermshell",
+                                      aPath, PR_TRUE, PR_TRUE);
+
+  if (NS_FAILED(result)) return result;
+
+  return NS_OK;
+}
+
+
+extern "C" NS_EXPORT nsresult
+NSUnregisterSelf(nsISupports* aServMgr, const char* aPath)
+{
+  nsresult result;
+
+  nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &result));
+  if (NS_FAILED(result)) return result;
+
+  NS_WITH_SERVICE(nsIComponentManager, compMgr, kComponentManagerCID, &result);
+  if (NS_FAILED(result)) return result;
+
+  result = compMgr->UnregisterComponent(kLineTermCID, aPath);
+  if (NS_FAILED(result)) return result;
+
+  result = compMgr->UnregisterComponent(kXMLTermShellCID, aPath);
+  if (NS_FAILED(result)) return result;
+
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTermListeners.cpp

@@ -0,0 +1,604 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermListeners.cpp: implementation of classes in mozXMLTermListeners.h
+
+#include "nsIServiceManager.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermListeners.h"
+
+#include "nsIDOMKeyEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIDOMNSUIEvent.h"
+#include "nsIPrivateTextEvent.h"
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermKeyListener factory
+/////////////////////////////////////////////////////////////////////////
+
+nsresult 
+NS_NewXMLTermKeyListener(nsIDOMEventListener ** aInstancePtrResult, 
+                         mozIXMLTerminal *aXMLTerminal)
+{
+  mozXMLTermKeyListener* listener = new mozXMLTermKeyListener();
+  if (listener == nsnull) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // Save non-owning reference to embedding XMLTerminal object
+  listener->SetXMLTerminal(aXMLTerminal);
+
+  return listener->QueryInterface(nsIDOMEventListener::GetIID(),
+                                  (void **) aInstancePtrResult);
+}
+
+nsresult 
+NS_NewXMLTermTextListener(nsIDOMEventListener ** aInstancePtrResult, 
+                         mozIXMLTerminal *aXMLTerminal)
+{
+  mozXMLTermTextListener* listener = new mozXMLTermTextListener();
+  if (listener == nsnull) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // Save non-owning reference to embedding XMLTerminal object
+  listener->SetXMLTerminal(aXMLTerminal);
+
+  return listener->QueryInterface(nsIDOMEventListener::GetIID(),
+                                  (void **) aInstancePtrResult);
+}
+
+nsresult 
+NS_NewXMLTermMouseListener(nsIDOMEventListener ** aInstancePtrResult, 
+                         mozIXMLTerminal *aXMLTerminal)
+{
+  mozXMLTermMouseListener* listener = new mozXMLTermMouseListener();
+  if (listener == nsnull) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // Save non-owning reference to embedding XMLTerminal object
+  listener->SetXMLTerminal(aXMLTerminal);
+
+  return listener->QueryInterface(nsIDOMEventListener::GetIID(),
+                                  (void **) aInstancePtrResult);
+}
+
+nsresult 
+NS_NewXMLTermDragListener(nsIDOMEventListener ** aInstancePtrResult, 
+                         mozIXMLTerminal *aXMLTerminal)
+{
+  mozXMLTermDragListener* listener = new mozXMLTermDragListener();
+  if (listener == nsnull) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // Save non-owning reference to embedding XMLTerminal object
+  listener->SetXMLTerminal(aXMLTerminal);
+
+  return listener->QueryInterface(nsIDOMEventListener::GetIID(),
+                                  (void **) aInstancePtrResult);
+}
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermKeyListener implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozXMLTermKeyListener::mozXMLTermKeyListener()
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTermKeyListener::~mozXMLTermKeyListener() 
+{
+}
+
+
+NS_IMPL_ADDREF(mozXMLTermKeyListener)
+
+NS_IMPL_RELEASE(mozXMLTermKeyListener)
+
+
+NS_IMETHODIMP
+mozXMLTermKeyListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(nsIDOMKeyListener*,this));
+
+  } else if (aIID.Equals(nsIDOMEventListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
+
+  } else if (aIID.Equals(nsIDOMKeyListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMKeyListener*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+// Individual key handlers return NS_OK to indicate NOT consumed
+// by default, an error is returned indicating event is consumed
+
+NS_IMETHODIMP
+mozXMLTermKeyListener::HandleEvent(nsIDOMEvent* aEvent)
+{
+  return NS_OK;
+}
+
+
+// Process KeyDown events (handles control/alt modified key events)
+NS_IMETHODIMP
+mozXMLTermKeyListener::KeyDown(nsIDOMEvent* aKeyEvent)
+{
+  nsresult result;
+
+  nsCOMPtr<nsIDOMKeyEvent> keyEvent;
+  keyEvent = do_QueryInterface(aKeyEvent);
+  if (!keyEvent) {
+    // Non-key event passed to keydown, do not consume it
+    return NS_OK;
+  }
+
+  PRBool isShift, ctrlKey, altKey;
+  PRUint32 keyCode;
+
+  XMLT_LOG(mozXMLTermKeyListener::KeyDown,50,("\n"));
+
+  if (NS_SUCCEEDED(keyEvent->GetKeyCode(&keyCode)) && 
+      NS_SUCCEEDED(keyEvent->GetShiftKey(&isShift)) &&
+      NS_SUCCEEDED(keyEvent->GetCtrlKey(&ctrlKey)) &&
+      NS_SUCCEEDED(keyEvent->GetAltKey(&altKey)) ) {
+
+    XMLT_LOG(mozXMLTermKeyListener::KeyDown,52,
+          ("keyCode=0x%x, ctrlKey=%d, altKey=%d\n", keyCode, ctrlKey, altKey));
+
+    PRUint32 keyChar = 0;
+
+    if (!ctrlKey && !altKey) {
+      // Not control/alt key event
+      switch (keyCode) {
+      case nsIDOMKeyEvent::DOM_VK_LEFT:
+        keyChar = U_CTL_B;
+        break;
+      case nsIDOMKeyEvent::DOM_VK_RIGHT:
+        keyChar = U_CTL_F;
+        break;
+      case nsIDOMKeyEvent::DOM_VK_UP:
+        keyChar = U_CTL_P;
+        break;
+      case nsIDOMKeyEvent::DOM_VK_DOWN:
+        keyChar = U_CTL_N;
+        break;
+      case nsIDOMKeyEvent::DOM_VK_TAB: // Consume TAB to avoid scroll problems
+        keyChar = 0;
+        break;
+      default: // ignore event without consuming
+        return NS_OK;
+      }
+
+    } else if (ctrlKey == PR_TRUE) {
+      keyChar = keyCode - 0x40U;   // Is this portable?
+    }
+
+    XMLT_LOG(mozXMLTermKeyListener::KeyDown,52,("keyChar=0x%x\n", keyChar));
+
+    if ((keyChar > 0) && (keyChar < U_SPACE)) {
+      // Transmit valid non-null control character
+      const PRUnichar temUString[] = {keyChar,0};
+      nsAutoString keyString(temUString);
+      result = mXMLTerminal->SendTextAux(keyString);
+    }
+  }
+
+  // Consume key down event
+  return NS_ERROR_BASE;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermKeyListener::KeyUp(nsIDOMEvent* aKeyEvent)
+{
+  return NS_OK;
+}
+
+
+// Handle KeyPress events (non control/alt modified key events)
+NS_IMETHODIMP
+mozXMLTermKeyListener::KeyPress(nsIDOMEvent* aKeyEvent)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermKeyListener::KeyPress,50,("\n"));
+
+  nsCOMPtr<nsIDOMKeyEvent> keyEvent;
+  keyEvent = do_QueryInterface(aKeyEvent);
+  if (!keyEvent) {
+    // Non-key event passed to keydown, do not consume it
+    return NS_OK;
+  }
+
+  PRUint32 keyCode;
+  PRBool isShift, ctrlKey, altKey;
+  if (NS_SUCCEEDED(keyEvent->GetKeyCode(&keyCode)) && 
+      NS_SUCCEEDED(keyEvent->GetShiftKey(&isShift)) &&
+      NS_SUCCEEDED(keyEvent->GetCtrlKey(&ctrlKey)) &&
+      NS_SUCCEEDED(keyEvent->GetAltKey(&altKey)) ) {
+
+    PRUint32 keyChar = 0;
+    result = keyEvent->GetCharCode(&keyChar);
+
+    XMLT_LOG(mozXMLTermKeyListener::KeyPress,52,
+          ("keyChar=0x%x, ctrlKey=%d, altKey=%d\n", keyChar, ctrlKey, altKey));
+
+    if (ctrlKey == PR_TRUE) {
+      // Do nothing for Ctrl-Alt key events; just consume then
+
+      if (altKey == PR_FALSE) {
+        // Control character, without Alt
+
+        if ((keyChar > 0) && (keyChar < U_SPACE)) {
+          // Transmit valid non-null control character
+          const PRUnichar temUString[] = {keyChar,0};
+          nsAutoString keyString(temUString);
+          result = mXMLTerminal->SendTextAux(keyString);
+        }
+      }
+
+    } else {
+      // Unmodified key event (including TAB/BACKSPACE/RETURN/LINEFEED)
+
+      if (keyChar == 0) {
+        // Key that hasn't been mapped to a character code
+        switch (keyCode) {
+        case nsIDOMKeyEvent::DOM_VK_BACK_SPACE:
+        case nsIDOMKeyEvent::DOM_VK_DELETE:
+          keyChar = U_BACKSPACE;
+          break;
+        case nsIDOMKeyEvent::DOM_VK_TAB:
+          keyChar = U_TAB;
+          break;
+        case nsIDOMKeyEvent::DOM_VK_RETURN:
+          keyChar = U_LINEFEED;
+          break;
+        default: // ignore event without consuming
+          return NS_OK;
+        }
+      }
+
+      // Translate Carriage Return to LineFeed (may not be portable??)
+      if (keyChar == U_CRETURN) keyChar = U_LINEFEED;
+
+      if ((keyChar > 0) && (keyChar <= 0xFFFDU)) {
+        // Transmit valid non-null Unicode character
+        const PRUnichar temUString[] = {keyChar,0};
+        nsAutoString keyString(temUString);
+        result = mXMLTerminal->SendTextAux(keyString);
+      }
+    }
+  }
+
+  // Consume key press event
+  return NS_ERROR_BASE;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermTextListener implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozXMLTermTextListener::mozXMLTermTextListener()
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTermTextListener::~mozXMLTermTextListener() 
+{
+}
+
+
+NS_IMPL_ADDREF(mozXMLTermTextListener)
+
+NS_IMPL_RELEASE(mozXMLTermTextListener)
+
+
+NS_IMETHODIMP
+mozXMLTermTextListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(nsIDOMTextListener*,this));
+
+  } else if (aIID.Equals(nsIDOMEventListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
+
+  } else if (aIID.Equals(nsIDOMTextListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMTextListener*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermTextListener::HandleEvent(nsIDOMEvent* aEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermTextListener::HandleText(nsIDOMEvent* aTextEvent)
+{
+  nsCOMPtr<nsIPrivateTextEvent> textEvent (do_QueryInterface(aTextEvent));
+  if (!textEvent) {
+    // Soft failure
+    return NS_OK;
+  }
+
+  XMLT_LOG(mozXMLTermTextListener::HandleText,50,("\n"));
+
+  nsAutoString textStr;
+  textEvent->GetText(textStr);
+
+  // Transmit text to terminal
+  mXMLTerminal->SendTextAux(textStr);
+
+  return NS_OK;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermMouseListener implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozXMLTermMouseListener::mozXMLTermMouseListener()
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTermMouseListener::~mozXMLTermMouseListener() 
+{
+}
+
+
+NS_IMPL_ADDREF(mozXMLTermMouseListener)
+
+NS_IMPL_RELEASE(mozXMLTermMouseListener)
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(nsIDOMMouseListener*,this));
+
+  } else if (aIID.Equals(nsIDOMEventListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
+
+  } else if (aIID.Equals(nsIDOMMouseListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMMouseListener*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::HandleEvent(nsIDOMEvent* aEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseDown(nsIDOMEvent* aMouseEvent)
+{
+  if (!aMouseEvent)
+    return NS_OK;
+
+  nsCOMPtr<nsIDOMMouseEvent> mouseEvent;
+  mouseEvent = do_QueryInterface(aMouseEvent);
+  if (!mouseEvent) {
+    // Non-mouse event passed; do not consume it
+    return NS_OK;
+  }
+
+  PRUint16 buttonCode = 0;
+  mouseEvent->GetButton(&buttonCode);
+
+  XMLT_LOG(mozXMLTermMouseListener::MouseDown,50,("buttonCode=%d\n",
+                                                  buttonCode));
+
+  if (buttonCode == 2) {
+    // Middle-mouse button pressed; initiate paste
+    mXMLTerminal->Paste();
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseUp(nsIDOMEvent* aMouseEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseClick(nsIDOMEvent* aMouseEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseDblClick(nsIDOMEvent* aMouseEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseOver(nsIDOMEvent* aMouseEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermMouseListener::MouseOut(nsIDOMEvent* aMouseEvent)
+{
+  return NS_OK;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermDragListener implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozXMLTermDragListener::mozXMLTermDragListener()
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTermDragListener::~mozXMLTermDragListener() 
+{
+}
+
+
+NS_IMPL_ADDREF(mozXMLTermDragListener)
+
+NS_IMPL_RELEASE(mozXMLTermDragListener)
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(nsIDOMDragListener*,this));
+
+  } else if (aIID.Equals(nsIDOMEventListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMEventListener*,this);
+
+  } else if (aIID.Equals(nsIDOMDragListener::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDOMDragListener*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::HandleEvent(nsIDOMEvent* aEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::DragEnter(nsIDOMEvent* aDragEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::DragOver(nsIDOMEvent* aDragEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::DragExit(nsIDOMEvent* aDragEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::DragDrop(nsIDOMEvent* aDragEvent)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozXMLTermDragListener::DragGesture(nsIDOMEvent* aDragEvent)
+{
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTermListeners.h

@@ -0,0 +1,172 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermListeners.h: classes for key/text/mouse/drag event listeners
+// used by mozXMLTerminal:
+//   mozXMLTermKeyListener
+//   mozXMLTermTextListener
+//   mozXMLTermMouseListener
+//   mozXMLTermDragListener
+
+
+#ifndef mozXMLTermListeners_h__
+#define mozXMLTermListeners_h__
+
+#include "nsIDOMEvent.h"
+#include "nsIDOMKeyListener.h"
+#include "nsIDOMTextListener.h"
+#include "nsIDOMMouseListener.h"
+#include "nsIDOMDragListener.h"
+#include "nsCOMPtr.h"
+
+#include "mozIXMLTerminal.h"
+
+/* XMLTerm Key Listener */
+class mozXMLTermKeyListener : public nsIDOMKeyListener {
+public:
+  mozXMLTermKeyListener();
+  virtual ~mozXMLTermKeyListener();
+
+  /** Save non-owning reference to containing XMLTerminal object
+   * @param aXMLTerminal the XMLTerm instance
+   */
+  void SetXMLTerminal(mozIXMLTerminal *aXMLTerminal)
+    {mXMLTerminal = aXMLTerminal;}
+
+  // Interfaces for addref and release and queryinterface
+  NS_DECL_ISUPPORTS
+
+  // nsIDOMEventListener interface
+  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
+
+  // nsIDOMKeyListener interface
+  virtual nsresult KeyDown(nsIDOMEvent* aKeyEvent);
+  virtual nsresult KeyUp(nsIDOMEvent* aKeyEvent);
+  virtual nsresult KeyPress(nsIDOMEvent* aKeyEvent);
+
+protected:
+  /** non-owning reference to containing XMLTerminal object (for callback) */
+  mozIXMLTerminal* mXMLTerminal;
+};
+
+
+/* XMLTerm Text Listener */
+class mozXMLTermTextListener : public nsIDOMTextListener {
+public:
+  mozXMLTermTextListener();
+  virtual ~mozXMLTermTextListener();
+
+  /** Save non-owning reference to containing XMLTerminal object
+   * @param aXMLTerminal the XMLTerm instance
+   */
+  void SetXMLTerminal(mozIXMLTerminal *aXMLTerminal)
+    {mXMLTerminal = aXMLTerminal;}
+
+  // Interfaces for addref and release and queryinterface
+  NS_DECL_ISUPPORTS
+
+  // nsIDOMEventListener interface
+  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
+
+  // nsIDOMTextListener interface
+  virtual nsresult HandleText(nsIDOMEvent* aTextEvent);
+
+protected:
+  /** non-owning reference to containing XMLTerminal object (for callback) */
+  mozIXMLTerminal* mXMLTerminal;
+};
+
+
+/* XMLTerm Mouse Listener */
+class mozXMLTermMouseListener : public nsIDOMMouseListener {
+public:
+  mozXMLTermMouseListener();
+  virtual ~mozXMLTermMouseListener();
+
+  /** Save non-owning reference to containing XMLTerminal object
+   * @param aXMLTerminal the XMLTerm instance
+   */
+  void SetXMLTerminal(mozIXMLTerminal *aXMLTerminal)
+    {mXMLTerminal = aXMLTerminal;}
+
+  // Interfaces for addref and release and queryinterface
+  NS_DECL_ISUPPORTS
+
+  // nsIDOMEventListener interface
+  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
+
+  // nsIDOMMouseListener interface
+  virtual nsresult MouseDown(nsIDOMEvent* aMouseEvent);
+  virtual nsresult MouseUp(nsIDOMEvent* aMouseEvent);
+  virtual nsresult MouseClick(nsIDOMEvent* aMouseEvent);
+  virtual nsresult MouseDblClick(nsIDOMEvent* aMouseEvent);
+  virtual nsresult MouseOver(nsIDOMEvent* aMouseEvent);
+  virtual nsresult MouseOut(nsIDOMEvent* aMouseEvent);
+
+protected:
+  /** non-owning reference to containing XMLTerminal object (for callback) */
+  mozIXMLTerminal* mXMLTerminal;
+};
+
+
+/* XMLTerm Drag Listener */
+class mozXMLTermDragListener : public nsIDOMDragListener {
+public:
+  mozXMLTermDragListener();
+  virtual ~mozXMLTermDragListener();
+
+  /** Save non-owning reference to containing XMLTerminal object
+   * @param aXMLTerminal the XMLTerm instance
+   */
+  void SetXMLTerminal(mozIXMLTerminal *aXMLTerminal)
+    {mXMLTerminal = aXMLTerminal;}
+
+  // Interfaces for addref and release and queryinterface
+  NS_DECL_ISUPPORTS
+
+  // nsIDOMEventListener interface
+  virtual nsresult HandleEvent(nsIDOMEvent* aEvent);
+
+  // nsIDOMDragListener interface
+  virtual nsresult DragEnter(nsIDOMEvent* aDragEvent);
+  virtual nsresult DragOver(nsIDOMEvent* aDragEvent);
+  virtual nsresult DragExit(nsIDOMEvent* aDragEvent);
+  virtual nsresult DragDrop(nsIDOMEvent* aDragEvent);
+  virtual nsresult DragGesture(nsIDOMEvent* aDragEvent);
+
+protected:
+  /** non-owning reference to containing XMLTerminal object (for callback) */
+  mozIXMLTerminal* mXMLTerminal;
+};
+
+
+// Factory for XMLTermKeyListener
+extern nsresult NS_NewXMLTermKeyListener(nsIDOMEventListener** aInstancePtrResult, mozIXMLTerminal *aXMLTerminal);
+
+// Factory for XMLTermTextListener
+extern nsresult NS_NewXMLTermTextListener(nsIDOMEventListener** aInstancePtrResult, mozIXMLTerminal *aXMLTerminal);
+
+// Factory for XMLTermMouseListener
+extern nsresult NS_NewXMLTermMouseListener(nsIDOMEventListener** aInstancePtrResult, mozIXMLTerminal *aXMLTerminal);
+
+// Factory for XMLTermDragListener
+extern nsresult NS_NewXMLTermDragListener(nsIDOMEventListener** aInstancePtrResult, mozIXMLTerminal *aXMLTerminal);
+
+#endif //mozXMLTermListeners_h__

mozilla/extensions/xmlterm/base/mozXMLTermSession.h

@@ -0,0 +1,537 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermSession.h: class to manage session input/output display
+// NOTE: This class is getting too unwieldy. It should be modularized,
+//       using a separate class for entries, for example, once the dust
+//       settles.
+
+#include "nscore.h"
+#include "prlog.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsIPresShell.h"
+#include "nsIDOMNode.h"
+#include "nsIDOMDocument.h"
+
+#include "nsIContent.h"
+
+#include "mozXMLT.h"
+#include "mozILineTermAux.h"
+#include "mozIXMLTerminal.h"
+
+
+class mozXMLTermSession
+{
+  public:
+
+  mozXMLTermSession();
+  virtual ~mozXMLTermSession();
+
+  /** Initializes XMLterm session
+   * @param aXMLTerminal containing XMLTerminal object
+   * @param aPresShell presentation shell associated with XMLterm
+   * @param aDOMDocument DOM document associated with XMLterm
+   */
+  NS_IMETHOD Init(mozIXMLTerminal* aXMLTerminal,
+                  nsIPresShell* aPresShell,
+                  nsIDOMDocument* aDOMDocument);
+
+  /** Finalizes (closes) session
+   */
+  NS_IMETHOD Finalize(void);
+
+  /** Preprocesses user input before it is transmitted to LineTerm
+   * @param aString (inout) input data to be preprocessed
+   * @param consumed (output) true if input data has been consumed
+   */
+  NS_IMETHOD Preprocess(const nsString& aString, PRBool& consumed);
+
+  /** Reads all available data from LineTerm and displays it;
+   * returns when no more data is available.
+   * @param lineTermAux LineTermAux object to read data from
+   */
+  NS_IMETHOD ReadAll(mozILineTermAux* lineTermAux);
+
+  /** Gets current entry (command) number
+   * @param aNumber (output) current entry number
+   */
+  NS_IMETHOD GetCurrentEntryNumber(PRInt32 *aNumber);
+
+  /** Gets command history buffer count
+   * @param aHistory (output) history buffer count
+   */
+  NS_IMETHOD GetHistory(PRInt32 *aHistory);
+
+  /** Sets command history buffer count
+   * @param aHistory history buffer count
+   */
+  NS_IMETHOD SetHistory(PRInt32 aHistory);
+
+  /** Gets prompt string
+   * @param aPrompt (output) prompt string
+   */
+  NS_IMETHOD GetPrompt(PRUnichar **aPrompt);
+
+  /** Sets prompt string
+   * @param aPrompt prompt string
+   */
+  NS_IMETHOD SetPrompt(const PRUnichar* aPrompt);
+
+protected:
+
+  /** ShellML element type (see ShellML documentation),
+   * implemented as CLASS attribute of HTML elements
+   */
+  enum SessionElementType {
+    SESSION_ELEMENT = 0,
+    ENTRY_ELEMENT,
+    INPUT_ELEMENT,
+    OUTPUT_ELEMENT,
+    PROMPT_ELEMENT,
+    COMMAND_ELEMENT,
+    STDIN_ELEMENT,
+    STDOUT_ELEMENT,
+    STDERR_ELEMENT,
+    SESSION_ELEMENT_TYPES
+  };
+
+  /** user-generated input event type */
+  enum SessionEventType {
+    CLICK_EVENT = 0,
+    DBLCLICK_EVENT,
+    SESSION_EVENT_TYPES
+  };
+
+  /** display style of output */
+  enum OutputDisplayType {
+    NO_NODE          = 0,
+    PRE_STDOUT_NODE,
+    PRE_STDERR_NODE,
+    SPAN_STDOUT_NODE,
+    SPAN_STDERR_NODE,
+    SPAN_MIXED_NODE,
+    OUTPUT_DISPLAY_TYPES
+  };
+
+  /** markup style of output */
+  enum OutputMarkupType {
+    PLAIN_TEXT = 0,
+    HTML_FRAGMENT,
+    HTML_DOCUMENT,
+    XML_DOCUMENT
+  };
+
+  /** settings for automatic markup detection */
+  enum AutoDetectOption {
+    NO_MARKUP = 0,
+    FIRST_LINE,
+    ANY_LINE
+  };
+
+  /** type of output flush action */
+  enum FlushActionType {
+    DISPLAY_INCOMPLETE_FLUSH = 0,
+    SPLIT_INCOMPLETE_FLUSH,
+    CLEAR_INCOMPLETE_FLUSH,
+    CLOSE_INCOMPLETE_FLUSH
+  };
+
+  /** type of currently active meta command */
+  enum MetaCommandType {
+    NO_META_COMMAND    = 0,
+    STREAM_META_COMMAND,
+    HTTP_META_COMMAND,
+    LS_META_COMMAND,
+    TREE_META_COMMAND,
+    META_COMMAND_TYPES
+  };
+
+  /** file type for directory display (TEMPORARY) */
+  enum FileType {
+    PLAIN_FILE      = 0,
+    DIRECTORY_FILE,
+    EXECUTABLE_FILE,
+    FILE_TYPES
+  };
+
+  /** action code for navigating XMLterm DOM document */
+  enum TreeActionCode {
+    TREE_MOVE_UP      = 1,
+    TREE_MOVE_DOWN    = 2,
+    TREE_MOVE_LEFT    = 3,
+    TREE_MOVE_RIGHT   = 4,
+    TREE_PRINT_ATTS   = 5,
+    TREE_PRINT_HTML   = 6,
+    TREE_ACTION_CODES = 7
+  };
+
+  /** Displays ("echoes") input text string with style and positions cursor
+   * @param aString string to be displayed
+   * @param aStyle style values for string (see lineterm.h)
+   * @param cursorCol cursor column
+   */
+  NS_IMETHOD DisplayInput(const nsString& aString,
+                          const nsString& aStyle,
+                          PRInt32 cursorCol);
+
+  /** Autodetects markup in current output line
+   * @param aString string to be displayed
+   * @param aStyle style values for string (see lineterm.h)
+   * @param firstOutputLine true if this is the first output line
+   */
+  NS_IMETHOD AutoDetectMarkup(const nsString& aString,
+                              const nsString& aStyle,
+                              PRBool firstOutputLine);
+
+  /** Initializes display of stream output with specified markup type
+   * @param streamURL effective URL of stream output
+   * @param streamMarkupType stream markup stype
+   */
+  NS_IMETHOD InitStream(const nsString& streamURL,
+                        OutputMarkupType streamMarkupType);
+
+  /** Breaks output display by flushing and deleting incomplete lines */
+  NS_IMETHOD BreakOutput(void);
+
+  /** Processes output string with specified style
+   * @param aString string to be processed
+   * @param aStyle style values for string (see lineterm.h)
+   *               (if it is a null string, STDOUT style is assumed)
+   * @param newline true if this is a complete line of output
+   * @param streamOutput true if string represents stream output
+   */
+  NS_IMETHOD ProcessOutput(const nsString& aString,
+                           const nsString& aStyle,
+                           PRBool newline,
+                           PRBool streamOutput);
+
+  /** Appends text string to output buffer
+   *  (appended text may need to be flushed for it to be actually displayed)
+   * @param aString string to be processed
+   * @param aStyle style values for string (see lineterm.h)
+   *               (if it is a null string, STDOUT style is assumed)
+   * @param newline true if this is a complete line of output
+   */
+  NS_IMETHOD AppendOutput(const nsString& aString,
+                          const nsString& aStyle,
+                          PRBool newline);
+
+  /** Adds markup to LS output (TEMPORARY)
+   * @param aString string to be processed
+   * @param aStyle style values for string (see lineterm.h)
+   *               (if it is a null string, STDOUT style is assumed)
+   */
+  NS_IMETHOD AppendLineLS(const nsString& aString,
+                          const nsString& aStyle);
+
+  /** Inserts HTML fragment string as child of parentNode, before specified
+   * child node, or after the last child node
+   * @param aString HTML fragment string to be inserted
+   * @param parentNode parent node for HTML fragment
+   * @param entryNumber entry number (default value = -1)
+   *                   (if entryNumber >= 0, all '#' characters in aString
+   *                    are substituted by entryNumber)
+   * @param beforeNode child node before which to insert fragment;
+   *                   if null, insert after last child node
+   *                   (default value is null)
+   * @param replace if true, replace beforeNode with inserted fragment
+   *                (default value is false)
+   */
+  NS_IMETHOD InsertFragment(const nsString& aString,
+                            nsCOMPtr<nsIDOMNode>& parentNode,
+                            PRInt32 entryNumber = -1,
+                            nsIDOMNode* beforeNode = nsnull,
+                            PRBool replace = false);
+
+  /** Deep refresh of selected attributes for DOM elements
+   * (WORKAROUND for inserting HTML fragments properly)
+   * @param domNode DOM node of branch to be refreshed
+   * @param entryNumber entry number (default value = -1)
+   *                   (if entryNumber >= 0, all '#' characters in event
+   *                    handler scripts are substituted by entryNumber)
+   */
+  NS_IMETHOD DeepRefreshAttributes(nsCOMPtr<nsIDOMNode>& domNode,
+                                   PRInt32 entryNumber = -1);
+
+  /** Forces display of data in output buffer
+   * @param flushAction type of flush action: display, split-off, clear, or
+   *                                          close incomplete lines
+   */
+  NS_IMETHOD FlushOutput(FlushActionType flushAction);
+
+  /** Scrolls document to align bottom and left margin with screen */
+  NS_IMETHOD ScrollBottomLeft(void);
+
+  /** Create a DIV element with attributes NAME="preface", CLASS="preface",
+   * and ID="preface0", containing an empty text node, and append it as a
+   * child of the main BODY element. Also make it the current display element.
+   */
+  NS_IMETHOD NewPreface(void);
+
+  /** Create and append a new DIV element with attributes NAME="entry",
+   * CLASS="entry", and ID="entry#" as the last child of the main BODY element,
+   * where "#" denotes the new entry number obtained by incrementing the
+   * current entry number.
+   * Inside the entry element, create a DIV element with attributes
+   * NAME="input", CLASS="input", and ID="input#" containing two elements,
+   * named "prompt" and "command", each containing a text node.
+   * Insert the supplied prompt string into the prompt element's text node.
+   * @param aPrompt prompt string to be inserted into prompt element
+   */
+  NS_IMETHOD NewEntry(const nsString& aPrompt);
+
+  /** Append a BR element as the next child of specified parent.
+   * @param parentNode parent node for BR element
+   */
+  NS_IMETHOD NewBreak(nsIDOMNode* parentNode);
+
+  /** Creates an empty block element with tag name tagName with attributes
+   * NAME="name", CLASS="name", and ID="name#", and appends it as a child of
+   * the specified parent. ("#" denotes the specified number)
+   * Also create an empty text node inside the new block element.
+   * @param tagName tag name of element
+   * @param name name and class of element
+   *             (If zero-length string, then no attributes are set)
+   * @param number numeric suffix for element ID
+   *             (If < 0, no ID attribute is defined)
+   * @param parentNode parent node for element
+   * @param blockNode (output) block-level DOM node for created element
+   * @param textNode (output) child text DOM node of element
+   */
+  NS_IMETHOD NewElementWithText(const nsString& tagName,
+                                const nsString& name, PRInt32 number,
+                                nsIDOMNode* parentNode,
+                                nsCOMPtr<nsIDOMNode>& blockNode,
+                                nsCOMPtr<nsIDOMNode>& textNode);
+
+  /** Creates an empty anchor (A) element with tag name tagName with attributes
+   * CLASS="classAttribute", and ID="classAttribute#", and appends it as a
+   * child of the specified parent. ("#" denotes the specified number)
+   * @param classAttribute class attribute of anchor element
+   *             (If zero-length string, then no attributes are set)
+   * @param number numeric suffix for element ID
+   *             (If < 0, no ID attribute is defined)
+   * @param parentNode parent node for element
+   * @param anchorNode (output) DOM node for created anchor element
+   */
+  NS_IMETHOD NewAnchor(const nsString& classAttribute,
+                       PRInt32 number,
+                       nsIDOMNode* parentNode,
+                       nsCOMPtr<nsIDOMNode>& anchorNode);
+
+  /** Creates an empty block element with tag name tagName with attributes
+   * NAME="name", CLASS="name", and ID="name#", and appends it as a child of
+   * the specified parent. ("#" denotes the specified number)
+   * @param tagName tag name of element
+   * @param name name and class of element
+   *             (If zero-length string, then no attributes are set)
+   * @param number numeric suffix for element ID
+   *             (If < 0, no ID attribute is defined)
+   * @param parentNode parent node for element
+   * @param blockNode (output) block-level DOM node for created element
+   */
+  NS_IMETHOD NewElement(const nsString& tagName,
+                        const nsString& name, PRInt32 number,
+                        nsIDOMNode* parentNode,
+                        nsCOMPtr<nsIDOMNode>& blockNode);
+
+  /** Creates a new DOM text node, and appends it as a child of the
+   * specified parent.
+   * @param parentNode parent node for element
+   * @param textNode (output) created text DOM node
+   */
+  NS_IMETHOD NewTextNode( nsIDOMNode* parentNode,
+                          nsCOMPtr<nsIDOMNode>& textNode);
+
+  /** Add event attributes (onclick, ondblclick, ...) to DOM node
+   * @param name name of DOM node (supplied as argument to the event handler)
+   * @param number entry number (supplied as argument to the event handler)
+   * @param domNode DOM node to be modified 
+   */
+  NS_IMETHOD SetEventAttributes(const nsString& name,
+                                PRInt32 number,
+                                nsCOMPtr<nsIDOMNode>& domNode);
+
+  /** Sets text content of a DOM node to supplied string
+   * @param textNode DOM text node to be modified
+   * @param aString string to be inserted
+   */
+  NS_IMETHOD SetDOMText(nsCOMPtr<nsIDOMNode>& textNode,
+                        const nsString& aString);
+
+  /** Checks if node is a text node
+   * @param aNode DOM node to be checked
+   * @return true if node is a text node
+   */
+  PRBool IsTextNode(nsIDOMNode *aNode);
+
+  /** Checks if node is a text, span, or anchor node
+   * (i.e., allowed inside a PRE element)
+   * @param aNode DOM node to be checked
+   * @return true if node is a text, span or anchor node
+   */
+  PRBool IsPREInlineNode(nsIDOMNode* aNode);
+
+  /** Serializes DOM node and its content as an HTML fragment string
+   * @param aNode DOM node to be serialized
+   * @param indentString indentation prefix string
+   * @param htmlString (output) serialized HTML fragment
+   * @param deepContent if true, serialize children of node as well
+   *                    (defaults to false)
+   * @param insidePREnode set to true if aNode is embedded inside a PRE node
+   *                      control formatting
+   *                      (defaults to false)
+   */
+  NS_IMETHOD ToHTMLString(nsIDOMNode* aNode,
+                          nsString& indentString,
+                          nsString& htmlString,
+                          PRBool deepContent = false,
+                          PRBool insidePRENode = false);
+
+  /** Implements the "tree:" meta command to traverse DOM tree
+   * @param fileStream file stream for displaying tree traversal output
+   * @param rootNode root node of DOM tree
+   * @param currentNode current node for traversal
+   * @param treeActionCode traversal action type
+   */
+  void TraverseDOMTree(FILE* fileStream,
+                       nsIDOMNode* rootNode,
+                       nsCOMPtr<nsIDOMNode>& currentNode,
+                       TreeActionCode treeActionCode);
+
+  /** names of session elements */
+  static const char* const sessionElementNames[SESSION_ELEMENT_TYPES];
+
+  /** names of session events */
+  static const char* const sessionEventNames[SESSION_EVENT_TYPES];
+
+  /** names of meta commands */
+  static const char* const metaCommandNames[META_COMMAND_TYPES];
+
+  /** names of file types (TEMPORARY) */
+  static const char* const fileTypeNames[FILE_TYPES];
+
+  /** names of tree traversal action types */
+  static const char* const treeActionNames[TREE_ACTION_CODES];
+
+  /** object initialization flag */
+  PRBool mInitialized;
+
+
+  /** non-owning reference to containing XMLTerminal object */
+  mozIXMLTerminal*   mXMLTerminal;               // non-owning reference
+
+  /** non-owning reference to presentation shell associated with XMLterm */
+  nsIPresShell*      mPresShell;                 // non-owning reference (??)
+
+  /** non-owning reference to DOM document containing XMLterm */
+  nsIDOMDocument*    mDOMDocument;               // non-owning reference (??)
+
+
+  /** BODY node of document containing XMLterm */
+  nsCOMPtr<nsIDOMNode> mBodyNode;
+
+  /** XMLterm session node */
+  nsCOMPtr<nsIDOMNode> mSessionNode;
+
+  /** current debug node (TEMPORARY; used for tree traversal) */
+  nsCOMPtr<nsIDOMNode> mCurrentDebugNode;
+
+
+  /** starting entry node in the history list */
+  nsCOMPtr<nsIDOMNode> mStartEntryNode;
+
+  /** current (and last) entry node in the history list */
+  nsCOMPtr<nsIDOMNode> mCurrentEntryNode;
+
+  /** maximum number of commands allowed to be saved in history list */
+  PRInt32              mMaxHistory;
+
+  /** entry number of first entry in history list */
+  PRInt32              mStartEntryNumber;
+
+  /** entry number of current entry */
+  PRInt32              mCurrentEntryNumber;
+
+  /** flag indicating whether current entry has output data */
+  PRBool               mEntryHasOutput;
+
+  /** span node for current command prompt (is this necessary?) */
+  nsCOMPtr<nsIDOMNode> mPromptSpanNode;
+
+  /** span node for current command input (is this necessary?) */
+  nsCOMPtr<nsIDOMNode> mCommandSpanNode;
+
+  /** text node for current command input (is this necessary?) */
+  nsCOMPtr<nsIDOMNode> mInputTextNode;
+
+
+  /** block-level node for current command output */
+  nsCOMPtr<nsIDOMNode> mOutputBlockNode;
+
+  /** current display element node for command output */
+  nsCOMPtr<nsIDOMNode> mOutputDisplayNode;
+
+  /** current text node for command output */
+  nsCOMPtr<nsIDOMNode> mOutputTextNode;
+
+
+  /** currently active meta command (if any) */
+  MetaCommandType      mMetaCommandType;
+
+
+  /** currently active display style of output */
+  OutputDisplayType    mOutputDisplayType;
+
+
+  /** currently active markup style of output */
+  OutputMarkupType     mOutputMarkupType;
+
+  /** currently active setting for automatic markup detection */
+  AutoDetectOption     mAutoDetect;
+
+
+  /** flag indicating whether a line break needs to be output */
+  PRBool               mLineBreakNeeded;
+
+  /** flag marking the first line of output */
+  PRBool               mFirstOutputLine;
+
+
+  /** buffer for incomplete line of PRE text */
+  nsString             mPreTextIncomplete;
+
+  /** buffer for complete lines of PRE text */
+  nsString             mPreTextBuffered;
+
+  /** copy of PRE text already displayed */
+  nsString             mPreTextDisplayed;
+
+
+  /** prompt string (HTML) */
+  nsString             mPromptHTML;
+
+  /** buffer for HTML/XML fragment streams */
+  nsString             mFragmentBuffer;
+
+};

mozilla/extensions/xmlterm/base/mozXMLTermShell.cpp

@@ -0,0 +1,326 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermShell.cpp: implementation of mozIXMLTermShell
+// providing an XPCONNECT wrapper to the XMLTerminal interface,
+// thus allowing easy (and controlled) access from scripts
+
+#include <stdio.h>
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsIDocumentViewer.h"
+#include "nsIDocument.h"
+
+#include "nsIWebShell.h"
+#include "nsIWebShellWindow.h"
+#include "nsIPresShell.h"
+#include "nsIPresContext.h"
+#include "nsIScriptGlobalObject.h"
+
+#include "nsIServiceManager.h"
+
+#include "nsIAppShellService.h"
+#include "nsAppShellCIDs.h"
+#include "nsAppCoresCIDs.h"
+
+#include "nsIDOMToolkitCore.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMSelection.h"
+#include "nsIDOMWindow.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermShell.h"
+
+// Define Class IDs
+static NS_DEFINE_IID(kAppShellServiceCID,    NS_APPSHELL_SERVICE_CID);
+static NS_DEFINE_CID(kToolkitCoreCID,        NS_TOOLKITCORE_CID);
+
+// Define Interface IDs
+static NS_DEFINE_IID(kISupportsIID,          NS_ISUPPORTS_IID);
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermShell factory
+/////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewXMLTermShell(mozIXMLTermShell** aXMLTermShell)
+{
+    NS_PRECONDITION(aXMLTermShell != nsnull, "null ptr");
+    if (! aXMLTermShell)
+        return NS_ERROR_NULL_POINTER;
+
+    *aXMLTermShell = new mozXMLTermShell();
+    if (! *aXMLTermShell)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aXMLTermShell);
+    return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermShell implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozXMLTermShell::mozXMLTermShell() :
+  mInitialized(PR_FALSE),
+  mContentWindow(nsnull),
+  mContentAreaWebShell(nsnull),
+  mXMLTerminal(nsnull)
+{
+  NS_INIT_REFCNT();
+}
+
+mozXMLTermShell::~mozXMLTermShell()
+{
+  if (mInitialized) {
+    Finalize();
+  }
+}
+
+
+// Implement AddRef and Release
+NS_IMPL_ADDREF(mozXMLTermShell)
+NS_IMPL_RELEASE(mozXMLTermShell)
+
+
+NS_IMETHODIMP 
+mozXMLTermShell::QueryInterface(REFNSIID aIID,void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if ( aIID.Equals(kISupportsIID)) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(mozIXMLTermShell*,this));
+
+  } else if ( aIID.Equals(mozIXMLTermShell::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(mozIXMLTermShell*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozXMLTermShell::GetCurrentEntryNumber(PRInt32 *aNumber)
+{
+  if (mXMLTerminal) {
+    return mXMLTerminal->GetCurrentEntryNumber(aNumber);
+  } else {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTermShell::GetHistory(PRInt32 *aHistory)
+{
+  if (mXMLTerminal) {
+    return mXMLTerminal->GetHistory(aHistory);
+  } else {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTermShell::SetHistory(PRInt32 aHistory)
+{
+  if (mXMLTerminal) {
+    return mXMLTerminal->SetHistory(aHistory);
+  } else {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTermShell::GetPrompt(PRUnichar **aPrompt)
+{
+  if (mXMLTerminal) {
+    return mXMLTerminal->GetPrompt(aPrompt);
+  } else {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTermShell::SetPrompt(const PRUnichar* aPrompt)
+{
+  if (mXMLTerminal) {
+    return mXMLTerminal->SetPrompt(aPrompt);
+  } else {
+    return NS_ERROR_NOT_INITIALIZED;
+  }
+}
+
+
+// Initialize XMLTermShell
+NS_IMETHODIMP    
+mozXMLTermShell::Init(nsIDOMWindow* aContentWin,
+                      const PRUnichar* URL,
+                      const PRUnichar* args)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermShell::Init,10,("\n"));
+
+  if (mInitialized)
+    return NS_ERROR_ALREADY_INITIALIZED;
+
+  if (!aContentWin)
+      return NS_ERROR_NULL_POINTER;
+
+  mContentWindow = aContentWin;  // no addref
+
+  nsCOMPtr<nsIScriptGlobalObject> globalObj = do_QueryInterface(mContentWindow,
+                                                                &result);
+  if (NS_FAILED(result) || !globalObj)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIWebShell> webShell;
+  globalObj->GetWebShell(getter_AddRefs(webShell));
+  if (!webShell)
+    return NS_ERROR_FAILURE;
+    
+  mContentAreaWebShell = webShell;  // SVN: does this assignment addref?
+
+  // Create XMLTerminal
+  nsCOMPtr<mozIXMLTerminal> newXMLTerminal;
+  result = NS_NewXMLTerminal(getter_AddRefs(newXMLTerminal));
+
+  if(!newXMLTerminal)
+    result = NS_ERROR_OUT_OF_MEMORY;
+
+  if (NS_SUCCEEDED(result)) {
+    // Initialize XMLTerminal with non-owning reference to us
+    result = newXMLTerminal->Init(mContentAreaWebShell, this, URL, args);
+
+    if (NS_SUCCEEDED(result)) {
+      mXMLTerminal = newXMLTerminal;
+    }
+  }
+
+  return result;
+}
+
+
+// De-initialize XMLTermShell and free resources
+NS_IMETHODIMP
+mozXMLTermShell::Finalize(void)
+{
+  XMLT_LOG(mozXMLTermShell::Finalize,10,("\n"));
+
+  if (mXMLTerminal) {
+    // Finalize and release reference to XMLTerm object owned by us
+    mXMLTerminal->Finalize();
+    mXMLTerminal = nsnull;
+  }
+
+  mContentAreaWebShell = nsnull;
+  mContentWindow =       nsnull;
+
+  mInitialized = PR_FALSE;
+
+  return NS_OK;
+}
+
+
+// Poll for readable data from XMLTerminal
+NS_IMETHODIMP mozXMLTermShell::Poll(void)
+{
+  if (!mXMLTerminal)
+    return NS_ERROR_NOT_INITIALIZED;
+
+  return mXMLTerminal->Poll();
+}
+
+
+// Send string to LineTerm as if the user had typed it
+NS_IMETHODIMP mozXMLTermShell::SendText(const PRUnichar* buf,
+                                        const PRUnichar* cookie)
+{
+  if (!mXMLTerminal)
+    return NS_ERROR_FAILURE;
+
+  nsAutoString sendStr (buf);
+
+  XMLT_LOG(mozXMLTermShell::SendText,10,("length=%d\n", sendStr.Length()));
+
+  return mXMLTerminal->SendText(sendStr, cookie);
+}
+
+
+// Create new XMLTerm window with specified argument string
+NS_IMETHODIMP
+mozXMLTermShell::NewXMLTermWindow(const PRUnichar* args)
+{
+  nsresult result = NS_OK;
+
+  XMLT_LOG(mozXMLTermShell::NewXMLTermWindow,10,("\n"));
+
+  // Create the toolkit core instance...
+  nsIDOMToolkitCore* toolkit = nsnull;
+  result = nsServiceManager::GetService(kToolkitCoreCID,
+                                        nsIDOMToolkitCore::GetIID(),
+                                        (nsISupports**)&toolkit);
+  if (NS_FAILED(result))
+    return result;
+
+  nsAutoString argStr (args);
+  toolkit->ShowWindowWithArgs( "chrome://xmlterm/content/XMLTermFrame.xul",
+                               nsnull, argStr );
+  
+  /* Release the toolkit... */
+  if (nsnull != toolkit) {
+    nsServiceManager::ReleaseService(kToolkitCoreCID, toolkit);
+  }
+
+  return result;
+}
+
+
+// Exit XMLTerm window
+NS_IMETHODIMP    
+mozXMLTermShell::Exit()
+{  
+  nsIAppShellService* appShell = nsnull;
+
+  XMLT_LOG(mozXMLTermShell::Exit,10,("\n"));
+
+  // Create the Application Shell instance...
+  nsresult result = nsServiceManager::GetService(kAppShellServiceCID,
+                                                 nsIAppShellService::GetIID(),
+                                                 (nsISupports**)&appShell);
+  if (NS_SUCCEEDED(result)) {
+    appShell->Shutdown();
+    nsServiceManager::ReleaseService(kAppShellServiceCID, appShell);
+  } 
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTermShell.h

@@ -0,0 +1,81 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermShell.h: declaration of mozXMLTermShell
+// which implements mozIXMLTermShell, providing an XPCONNECT wrapper
+// to the XMLTerminal interface, thus allowing easy (and controlled)
+// access from scripts
+
+#include <stdio.h>
+
+#include "nscore.h"
+#include "nspr.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "mozXMLT.h"
+#include "mozIXMLTerminal.h"
+#include "mozIXMLTermShell.h"
+
+
+class mozXMLTermShell : public mozIXMLTermShell {
+ public: 
+
+  mozXMLTermShell();
+  virtual ~mozXMLTermShell();
+
+  NS_DECL_ISUPPORTS
+
+  // mozIXMLTermShell interface
+    
+  NS_IMETHOD GetCurrentEntryNumber(PRInt32 *aNumber);
+
+  NS_IMETHOD GetHistory(PRInt32 *aHistory);
+  NS_IMETHOD SetHistory(PRInt32 aHistory);
+  NS_IMETHOD GetPrompt(PRUnichar **aPrompt);
+  NS_IMETHOD SetPrompt(const PRUnichar* aPrompt);
+
+  NS_IMETHOD Init(nsIDOMWindow* aContentWin,
+                  const PRUnichar* URL,
+                  const PRUnichar* args);
+
+  NS_IMETHOD Finalize(void);
+  NS_IMETHOD Poll(void);
+
+  NS_IMETHOD SendText(const PRUnichar* buf, const PRUnichar* cookie);
+
+  NS_IMETHOD NewXMLTermWindow(const PRUnichar* args);
+
+  NS_IMETHOD Exit(void);
+
+protected:
+
+  /** object initialization flag */
+  PRBool mInitialized;
+
+  /** non-owning reference to content window for XMLterm */		
+  nsIDOMWindow* mContentWindow;
+
+  /** non-owning reference (??) to web shell for content window */
+  nsIWebShell* mContentAreaWebShell;
+
+  /** owning reference to XMLTerminal object created by us */
+  nsCOMPtr<mozIXMLTerminal> mXMLTerminal;
+};

mozilla/extensions/xmlterm/base/mozXMLTermStream.cpp

@@ -0,0 +1,568 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermStream.cpp: implementation of mozIXMLTermStream
+// to display HTML/XML streams as documents
+
+#include "nscore.h"
+#include "prlog.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsIAllocator.h"
+
+#include "nsIServiceManager.h"
+#include "nsIIOService.h"
+#include "nsIDocumentLoader.h"
+#include "nsIContentViewer.h"
+#include "nsIDocumentViewer.h"
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+
+#include "nsIViewManager.h"
+#include "nsIScrollableView.h"
+#include "nsIDeviceContext.h"
+#include "nsIFrame.h"
+
+#include "nsIScriptContextOwner.h"
+#include "nsIScriptGlobalObject.h"
+
+#include "nsIDOMWindow.h"
+#include "nsIDOMWindowCollection.h"
+#include "nsIDOMElement.h"
+#include "nsIDOMNode.h"
+#include "nsIDOMNodeList.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDocument.h"
+
+#include "nsIURL.h"
+#include "nsNeckoUtil.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermUtils.h"
+#include "mozXMLTermStream.h"
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermStream factory
+/////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewXMLTermStream(mozIXMLTermStream** aXMLTermStream)
+{
+    NS_PRECONDITION(aXMLTermStream != nsnull, "null ptr");
+    if (!aXMLTermStream)
+        return NS_ERROR_NULL_POINTER;
+
+    *aXMLTermStream = new mozXMLTermStream();
+    if (! *aXMLTermStream)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aXMLTermStream);
+    return NS_OK;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTermStream implementation
+/////////////////////////////////////////////////////////////////////////
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+
+mozXMLTermStream::mozXMLTermStream() :
+  mUTF8Buffer(""),
+  mUTF8Offset(0),
+  mMaxResizeHeight(0),
+  mDOMWindow( nsnull ),
+  mDOMIFrameElement( nsnull ),
+  mContext( nsnull ),
+  mLoadGroup( nsnull ),
+  mChannel( nsnull ),
+  mStreamListener( nsnull )
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTermStream::~mozXMLTermStream()
+{
+}
+
+
+// Implement AddRef and Release
+NS_IMPL_ADDREF(mozXMLTermStream)
+NS_IMPL_RELEASE(mozXMLTermStream)
+
+NS_IMETHODIMP 
+mozXMLTermStream::QueryInterface(REFNSIID aIID,void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if ( aIID.Equals(NS_GET_IID(nsISupports))) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(mozIXMLTermStream*,this));
+
+  } else if(aIID.Equals(NS_GET_IID(nsIBaseStream))) {
+    *aInstancePtr = NS_STATIC_CAST(nsIBaseStream*,this);
+
+  } else if(aIID.Equals(NS_GET_IID(nsIInputStream))) {
+    *aInstancePtr = NS_STATIC_CAST(nsIInputStream*,this);
+
+  } else if(aIID.Equals(NS_GET_IID(mozIXMLTermStream))) {
+    *aInstancePtr = NS_STATIC_CAST(mozIXMLTermStream*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  XMLT_LOG(mozXMLTermStream::QueryInterface,20,("mRefCnt = %d\n", mRefCnt));
+
+  return NS_OK;
+}
+
+
+// mozIXMLTermStream interface
+
+/** Open stream in specified frame, or in current frame if frameName is null
+ * @param aDOMWindow parent window
+ * @param frameName name of child frame in which to display stream, or null
+ *                  to display in parent window
+ * @param contentURL URL of stream content
+ * @param contentType MIME type of stream content
+ * @param maxResizeHeight maximum resize height (0=> do not resize)
+ * @return NS_OK on success
+ */
+NS_IMETHODIMP mozXMLTermStream::Open(nsIDOMWindow* aDOMWindow,
+                                     const char* frameName,
+                                     const char* contentURL,
+                                     const char* contentType,
+                                     PRInt32 maxResizeHeight)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermStream::Open,20,("contentURL=%s, contentType=%s\n",
+                                      contentURL, contentType));
+
+  mMaxResizeHeight = maxResizeHeight;
+
+  if (frameName && (strlen(frameName) > 0)) {
+    // Open stream in named subframe of current frame
+    XMLT_LOG(mozXMLTermStream::Open,22,("frameName=%s\n", frameName));
+
+    nsAutoString innerFrameName = frameName;
+
+    // Get DOM IFRAME element
+    nsCOMPtr<nsIDOMDocument> domDoc;
+    result = aDOMWindow->GetDocument(getter_AddRefs(domDoc));
+    if (NS_FAILED(result) || !domDoc)
+      return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIDOMHTMLDocument> domHTMLDoc = do_QueryInterface(domDoc);
+    if (!domHTMLDoc)
+      return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIDOMNodeList> nodeList;
+    result = domHTMLDoc->GetElementsByName(innerFrameName,
+                                           getter_AddRefs(nodeList));
+    if (NS_FAILED(result) || !nodeList)
+      return NS_ERROR_FAILURE;
+
+    PRUint32 count;
+    nodeList->GetLength(&count);
+    PR_ASSERT(count==1);
+
+    nsCOMPtr<nsIDOMNode> domNode;
+    result = nodeList->Item(0, getter_AddRefs(domNode));
+    if (NS_FAILED(result) || !domNode)
+      return NS_ERROR_FAILURE;
+
+    mDOMIFrameElement = do_QueryInterface(domNode);
+    if (!mDOMIFrameElement)
+      return NS_ERROR_FAILURE;
+
+    // Ensure that it is indeed an IFRAME element
+    nsAutoString tagName;
+    result = mDOMIFrameElement->GetTagName(tagName);
+    if (NS_FAILED(result))
+      return NS_ERROR_FAILURE;
+
+    if (!tagName.EqualsIgnoreCase("iframe"))
+      return NS_ERROR_FAILURE;
+
+    if (mMaxResizeHeight > 0) {
+      // Set initial IFRAME size to be as wide as the window, but very short
+      nsAutoString attWidth = "width";
+      nsAutoString valWidth = "100%";
+      mDOMIFrameElement->SetAttribute(attWidth,valWidth);
+
+      nsAutoString attHeight = "height";
+      nsAutoString valHeight = "10";
+      mDOMIFrameElement->SetAttribute(attHeight,valHeight);
+    }
+
+    // Get inner DOM window by looking up the frames list
+    nsCOMPtr<nsIDOMWindow> innerDOMWindow;
+    result = mozXMLTermUtils::GetInnerDOMWindow(aDOMWindow, innerFrameName,
+                                getter_AddRefs(innerDOMWindow));
+    if (NS_FAILED(result) || !innerDOMWindow)
+      return NS_ERROR_FAILURE;
+
+    mDOMWindow = innerDOMWindow;
+
+  } else {
+    // Open stream in current frame
+    mDOMIFrameElement = nsnull;
+    mDOMWindow = aDOMWindow;
+  }
+
+  // Get webshell for DOM window
+  nsCOMPtr<nsIWebShell> webShell;
+  result = mozXMLTermUtils::ConvertDOMWindowToWebShell(mDOMWindow,
+                                                    getter_AddRefs(webShell));
+  if (NS_FAILED(result) || !webShell)
+    return NS_ERROR_FAILURE;
+
+  NS_WITH_SERVICE(nsIIOService, ioService, kIOServiceCID, &result);
+  if (NS_FAILED(result))
+    return result;
+
+  nsCOMPtr<nsIInputStream> inputStream = this;
+
+  nsCOMPtr<nsIURI> uri;
+  result = NS_NewURI(getter_AddRefs(uri), contentURL, nsnull);
+  if (NS_FAILED(result))
+    return result;
+
+  result = NS_NewLoadGroup(nsnull, nsnull, nsnull, getter_AddRefs(mLoadGroup));
+  if (NS_FAILED(result))
+    return result;
+
+  PRInt32 contentLength = 1024; // ??? What's this length
+  result = ioService->NewInputStreamChannel(uri, contentType, contentLength,
+                                            inputStream, mLoadGroup, nsnull,
+                                            getter_AddRefs(mChannel));
+  if (NS_FAILED(result))
+    return result;
+
+  // Determine Class ID for viewing specified mimetype
+  nsCID classID;
+  static const char command[] = "view";
+  nsCAutoString progID = NS_DOCUMENT_LOADER_FACTORY_PROGID_PREFIX;
+  progID += command;
+  progID += "/";
+  progID += contentType;
+
+  result = nsComponentManager::ProgIDToCLSID(progID.GetBuffer(),
+                                             &classID);
+  if (NS_FAILED(result))
+    return result;
+
+  nsCOMPtr<nsIDocumentLoaderFactory> docLoaderFactory;
+  result = nsComponentManager::CreateInstance(classID, nsnull,
+                                         NS_GET_IID(nsIDocumentLoaderFactory),
+                                         getter_AddRefs(docLoaderFactory));
+  if (NS_FAILED(result))
+    return result;
+
+  nsCOMPtr<nsIContentViewer> contentViewer;
+  result = docLoaderFactory->CreateInstance(command,
+                                            mChannel,
+                                            mLoadGroup,
+                                            contentType,
+                                            webShell,
+                                            nsnull,
+                                            getter_AddRefs(mStreamListener),
+                                            getter_AddRefs(contentViewer) );
+  if (NS_FAILED(result))
+    return result;
+
+  nsCOMPtr<nsIContentViewerContainer> contViewContainer =
+                                             do_QueryInterface(webShell);
+  result = contentViewer->SetContainer(contViewContainer);
+  if (NS_FAILED(result))
+    return result;
+
+  result = webShell->Embed(contentViewer, command, (nsISupports*) nsnull);
+  if (NS_FAILED(result))
+    return result;
+
+  result = mStreamListener->OnStartRequest(mChannel, mContext);
+  if (NS_FAILED(result))
+    return result;
+
+  XMLT_LOG(mozXMLTermStream::Open,21,("returning\n"));
+
+  return NS_OK;
+}
+
+
+// nsIBaseStream interface
+NS_IMETHODIMP mozXMLTermStream::Close(void)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermStream::Close,20,("\n"));
+
+  mUTF8Buffer = "";
+  mUTF8Offset = 0;
+
+  PRUint32 sourceOffset = 0;
+  PRUint32 count = 0;
+  result = mStreamListener->OnDataAvailable(mChannel, mContext,
+                                            this, sourceOffset, count);
+  if (NS_FAILED(result))
+    return result;
+
+  nsresult status = NS_OK;
+  nsAutoString errorMsg = "";
+  result = mStreamListener->OnStopRequest(mChannel, mContext,
+                                          status, errorMsg.GetUnicode());
+  if (NS_FAILED(result))
+    return result;
+
+  if (mMaxResizeHeight && mDOMIFrameElement) {
+    // Size frame to content
+    result = SizeToContentHeight(mMaxResizeHeight);
+  }
+  mMaxResizeHeight = 0;
+
+  // Release interfaces etc
+  mDOMWindow = nsnull;
+  mDOMIFrameElement = nsnull;
+  mContext = nsnull;
+  mLoadGroup = nsnull;
+  mChannel = nsnull;
+  mStreamListener = nsnull;
+
+  return NS_OK;
+}
+
+
+/** Adjusts height of frame displaying stream to fit content
+ * @param maxHeight maximum height of resized frame (pixels)
+ *                  (zero value implies no maximum)
+ */
+NS_IMETHODIMP mozXMLTermStream::SizeToContentHeight(PRInt32 maxHeight)
+{
+  nsresult result;
+
+  // Get webshell
+  nsCOMPtr<nsIWebShell> webShell;
+  result = mozXMLTermUtils::ConvertDOMWindowToWebShell(mDOMWindow,
+                                                   getter_AddRefs(webShell));
+  if (NS_FAILED(result) || !webShell)
+    return NS_ERROR_FAILURE;
+
+  // Get pres context
+  nsCOMPtr<nsIPresContext> presContext;
+  result = mozXMLTermUtils::GetWebShellPresContext(webShell,
+                                                getter_AddRefs(presContext));
+  if (NS_FAILED(result) || !presContext)
+    return NS_ERROR_FAILURE;
+
+  // Get scrollable view
+  nsCOMPtr<nsIScrollableView> scrollableView;
+  result = mozXMLTermUtils::GetPresContextScrollableView(presContext,
+                                              getter_AddRefs(scrollableView));
+  if (NS_FAILED(result) || !scrollableView)
+    return NS_ERROR_FAILURE;
+
+  // Get device context
+  nsCOMPtr<nsIDeviceContext> deviceContext;
+  result = mozXMLTermUtils::GetPresContextDeviceContext(presContext,
+                                              getter_AddRefs(deviceContext));
+  if (NS_FAILED(result) || !deviceContext)
+    return NS_ERROR_FAILURE;
+
+  // Determine twips to pixels conversion factor
+  float pixelScale;
+  presContext->GetTwipsToPixels(&pixelScale);
+
+  // Get scrollbar dimensions in pixels
+  float sbWidth, sbHeight;
+  deviceContext->GetScrollBarDimensions(sbWidth, sbHeight);
+  PRInt32 scrollBarWidth = PRInt32(sbWidth*pixelScale);
+  PRInt32 scrollBarHeight = PRInt32(sbHeight*pixelScale);
+
+  // Determine webshell size in pixels
+  PRInt32 shellX, shellY, shellWidth, shellHeight;
+  result = webShell->GetBounds(shellX, shellY, shellWidth, shellHeight);
+
+  // Determine page size in pixels
+  nscoord contX, contY;
+  scrollableView->GetContainerSize(&contX, &contY);
+
+  PRInt32 pageWidth, pageHeight;
+  pageWidth = PRInt32((float)contX*pixelScale);
+  pageHeight = PRInt32((float)contY*pixelScale);
+
+  printf("mozXMLTermStream::SizeToContentHeight: scrollbar %d, %d\n",
+         scrollBarWidth, scrollBarHeight);
+
+  printf("mozXMLTermStream::SizeToContentHeight: shell %d, %d\n",
+         shellWidth, shellHeight);
+
+  printf("mozXMLTermStream::SizeToContentHeight: page %d, %d, %e\n",
+         pageWidth, pageHeight, pixelScale);
+
+  if ((pageHeight > shellHeight) || (pageWidth > shellWidth)) {
+    // Page larger than webshell
+    nsAutoString attHeight = "height";
+    nsAutoString attWidth = "width";
+    nsAutoString attValue = "";
+
+    PRInt32 newPageHeight = pageHeight;
+    PRInt32 excessWidth = (pageWidth+scrollBarWidth - shellWidth);
+
+    printf("mozXMLTermStream::SizeToContentHeight: excessWidth %d\n",
+           excessWidth);
+
+    if (excessWidth > 0) {
+      // Widen IFRAME beyond page width by scrollbar width
+      attValue = "";
+      attValue.Append(shellWidth+scrollBarWidth);
+      mDOMIFrameElement->SetAttribute(attWidth,attValue);
+
+      // Recompute page dimensions
+      scrollableView->GetContainerSize(&contX, &contY);
+      pageWidth = PRInt32((float)contX*pixelScale);
+      pageHeight = PRInt32((float)contY*pixelScale);
+
+      newPageHeight = pageHeight;
+      if (excessWidth > scrollBarWidth)
+        newPageHeight += scrollBarHeight;
+
+      printf("mozXMLTermStream::SizeToContentHeight: page2 %d, %d, %d\n",
+             pageWidth, pageHeight, newPageHeight);
+
+      // Reset IFRAME width
+      attValue = "";
+      attValue.Append(shellWidth);
+      mDOMIFrameElement->SetAttribute(attWidth,attValue);
+    }
+
+    // Resize IFRAME height to match page height (subject to a maximum)
+    if (newPageHeight > maxHeight) newPageHeight = maxHeight;
+    attValue = "";
+    attValue.Append(newPageHeight);
+    mDOMIFrameElement->SetAttribute(attHeight,attValue);
+  }
+
+  return NS_OK;
+}
+
+
+// nsIInputStream interface
+NS_IMETHODIMP mozXMLTermStream::Available(PRUint32 *_retval)
+{
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER;
+
+  *_retval = mUTF8Buffer.Length() - mUTF8Offset;
+
+  XMLT_LOG(mozXMLTermStream::Available,60,("retval=%d\n", *_retval));
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozXMLTermStream::Read(char* buf, PRUint32 count,
+                                     PRUint32* _retval)
+{
+  XMLT_LOG(mozXMLTermStream::Read,60,("count=%d\n", count));
+
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER;
+
+  PR_ASSERT(mUTF8Buffer.Length() >= mUTF8Offset);
+
+  PRUint32 remCount = mUTF8Buffer.Length() - mUTF8Offset;
+
+  if (remCount == 0) {
+    // Empty buffer
+    *_retval = 0;
+    return NS_OK;
+  }
+
+  if (count >= remCount) {
+    // Return entire remaining buffer
+    *_retval = remCount;
+
+  } else {
+    // Return only portion of buffer
+    *_retval = count;
+  }
+
+  // Copy portion of string
+  mUTF8Buffer.ToCString(buf, *_retval, mUTF8Offset);
+
+  mUTF8Offset += *_retval;
+
+  XMLT_LOG(mozXMLTermStream::Read,61,("*retval=%d\n", *_retval));
+
+  return NS_OK;
+}
+
+
+/** Write Unicode string to stream (blocks until write is completed)
+ * @param buf string to write
+ * @return NS_OK on success
+ */
+NS_IMETHODIMP mozXMLTermStream::Write(const PRUnichar* buf)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermStream::Write,50,("\n"));
+
+  if (!buf)
+    return NS_ERROR_FAILURE;
+
+  nsAutoString strBuf ( buf );
+
+  // Convert Unicode string to UTF8 and store in buffer
+  char* utf8Str = strBuf.ToNewUTF8String();
+  mUTF8Buffer = utf8Str;
+  nsAllocator::Free(utf8Str);
+
+  mUTF8Offset = 0;
+
+  PRUint32 sourceOffset = 0;
+
+  while (mUTF8Offset < mUTF8Buffer.Length()) {
+    PRUint32 remCount = mUTF8Buffer.Length() - mUTF8Offset;
+    result = mStreamListener->OnDataAvailable(mChannel, mContext,
+                                              this, sourceOffset, remCount);
+    if (NS_FAILED(result))
+      return result;
+  }
+
+  XMLT_LOG(mozXMLTermStream::Write,51,("returning mUTF8Offset=%d\n",
+                                       mUTF8Offset));
+
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTermStream.h

@@ -0,0 +1,96 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermStream.h: declaration of mozXMLTermStream
+// which implements the mozIXMLTermStream interface
+// to display HTML/XML streams as documents
+
+#include "nscore.h"
+#include "nspr.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "mozXMLT.h"
+#include "mozIXMLTermStream.h"
+
+class mozXMLTermStream : public mozIXMLTermStream
+{
+  public:
+
+  mozXMLTermStream();
+  virtual ~mozXMLTermStream();
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+
+  // nsIInputStream interface
+  NS_IMETHOD Close(void);
+
+  NS_IMETHOD Available(PRUint32 *_retval);
+  NS_IMETHOD Read(char * buf, PRUint32 count, PRUint32 *_retval);
+
+  // mozIXMLTermStream interface
+
+  // Open stream in specified frame, or in current frame if frameName is null
+  NS_IMETHOD Open(nsIDOMWindow* aDOMWindow,
+                  const char* frameName,
+                  const char* contentURL,
+                  const char* contentType,
+                  PRInt32 maxResizeHeight);
+
+  // Write Unicode string to stream
+  NS_IMETHOD Write(const PRUnichar* buf);
+
+ protected:
+
+  /** Adjusts height of frame displaying stream to fit content
+   * @param maxHeight maximum height of resized frame (pixels)
+   *                  (zero value implies no maximum)
+   */
+  NS_IMETHOD SizeToContentHeight(PRInt32 maxHeight);
+
+  /** UTF8 data buffer to hold to be read by rendering engine */
+  nsCString mUTF8Buffer;
+
+  /** offset at which to start reading the UTF8 data buffer */
+  PRInt32 mUTF8Offset;
+
+  /** maximum frame height for resizing */
+  PRInt32 mMaxResizeHeight;
+
+  /** DOM window in which to display stream */
+  nsCOMPtr<nsIDOMWindow> mDOMWindow;
+
+  /** Frame element in which to display stream */
+  nsCOMPtr<nsIDOMElement> mDOMIFrameElement;
+
+  /** Context for stream display (what's this??) */
+  nsCOMPtr<nsISupports> mContext;
+
+  /** Load group for stream display (what's this??) */
+  nsCOMPtr<nsILoadGroup> mLoadGroup;
+
+  /** Channel for stream display (what's this??) */
+  nsCOMPtr<nsIChannel> mChannel;
+
+  /** Stream listener object */
+  nsCOMPtr<nsIStreamListener> mStreamListener;
+};
+

mozilla/extensions/xmlterm/base/mozXMLTermUtils.cpp

@@ -0,0 +1,454 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermUtils.cpp: XMLTerm utilities implementation
+
+#include "nscore.h"
+#include "nspr.h"
+#include "prlog.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsIContentViewer.h"
+#include "nsIDocumentViewer.h"
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+#include "nsIDeviceContext.h"
+
+#include "nsIPrincipal.h"
+#include "nsIScriptContext.h"
+#include "nsIScriptContextOwner.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsIDOMWindowCollection.h"
+#include "nsIDocument.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermUtils.h"
+
+/////////////////////////////////////////////////////////////////////////
+
+/** Gets presentation context for web shell
+ * @param aWebShell web shell
+ * @param aPresContext returned presentation context
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetWebShellPresContext(nsIWebShell* aWebShell,
+                                        nsIPresContext** aPresContext)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetWebShellPresContext,30,("\n"));
+
+  if (!aPresContext)
+    return NS_ERROR_FAILURE;
+
+  *aPresContext = nsnull;
+
+  nsCOMPtr<nsIContentViewer> contViewer;
+  result = aWebShell->GetContentViewer(getter_AddRefs(contViewer));
+  if (NS_FAILED(result) || !contViewer)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDocumentViewer> docViewer;
+  result = contViewer->QueryInterface(NS_GET_IID(nsIDocumentViewer),
+                                      (void**)getter_AddRefs(docViewer));
+  if (NS_FAILED(result) || !docViewer)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPresContext> presContext;
+  result = docViewer->GetPresContext(*getter_AddRefs(presContext));
+  if (NS_FAILED(result) || !presContext)
+    return NS_ERROR_FAILURE;
+
+  *aPresContext = presContext.get();
+  NS_ADDREF(*aPresContext);
+
+  return NS_OK;
+}
+
+
+/** Gets DOM document for web shell
+ * @param aWebShell web shell
+ * @param aDOMDocument returned DOM document
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetWebShellDOMDocument(nsIWebShell* aWebShell,
+                                        nsIDOMDocument** aDOMDocument)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetWebShellDOMDocument,30,("\n"));
+
+  if (!aDOMDocument)
+    return NS_ERROR_FAILURE;
+
+  *aDOMDocument = nsnull;
+
+  nsCOMPtr<nsIContentViewer> contViewer;
+  result = aWebShell->GetContentViewer(getter_AddRefs(contViewer));
+  if (NS_FAILED(result) || !contViewer)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDocumentViewer> docViewer;
+  result = contViewer->QueryInterface(NS_GET_IID(nsIDocumentViewer),
+                                      (void**)getter_AddRefs(docViewer));
+  if (NS_FAILED(result) || !docViewer)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDocument> document;
+  result = docViewer->GetDocument(*getter_AddRefs(document));
+
+  if (NS_FAILED(result) || !document)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMDocument> domDocument = do_QueryInterface(document);
+  if (!domDocument)
+    return NS_ERROR_FAILURE;
+
+  *aDOMDocument = domDocument.get();
+  NS_ADDREF(*aDOMDocument);
+
+  return NS_OK;
+}
+
+
+/** Gets DOM window for web shell
+ * @param aWebShell web shell
+ * @param aDOMWindow returned DOM window (frame)
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::ConvertWebShellToDOMWindow(nsIWebShell* aWebShell,
+                                    nsIDOMWindow** aDOMWindow)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::ConvertWebShellToDOMWindow,30,("\n"));
+
+  if (!aDOMWindow)
+    return NS_ERROR_FAILURE;
+
+  *aDOMWindow = nsnull;
+
+  nsCOMPtr<nsIScriptContextOwner> scriptContextOwner =
+                                              do_QueryInterface(aWebShell);
+  if (!scriptContextOwner)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObject;
+  result = scriptContextOwner->GetScriptGlobalObject(getter_AddRefs(scriptGlobalObject));
+
+  if (NS_FAILED(result) || !scriptGlobalObject)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDOMWindow> domWindow = do_QueryInterface(scriptGlobalObject);
+  if (!domWindow)
+    return NS_ERROR_FAILURE;
+
+  *aDOMWindow = domWindow.get();
+  NS_ADDREF(*aDOMWindow);
+
+  return NS_OK;
+}
+
+
+/** Gets web shell for DOM window
+ * @param aDOMWindow DOM window (frame)
+ * @param aWebShell returned web shell
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::ConvertDOMWindowToWebShell(nsIDOMWindow* aDOMWindow,
+                                             nsIWebShell** aWebShell)
+{
+  XMLT_LOG(mozXMLTermUtils::ConvertDOMWindowToWebShell,30,("\n"));
+
+  nsCOMPtr<nsIScriptGlobalObject> globalObject = do_QueryInterface(aDOMWindow);
+  if (!globalObject)
+    return NS_ERROR_FAILURE;
+
+  globalObject->GetWebShell(aWebShell);
+
+  if (!*aWebShell)
+    return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+
+/** Locates named inner DOM window (frame) inside outer DOM window
+ * @param outerDOMWindow outer DOM window (frame)
+ * @param innerFrameName name of inner frame to be returned
+ * @param innerDOMWindow returned inner DOM window (frame)
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetInnerDOMWindow(nsIDOMWindow* outerDOMWindow,
+                                    const nsString& innerFrameName,
+                                    nsIDOMWindow** innerDOMWindow)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetInnerDOMWindow,30,("\n"));
+
+  nsCOMPtr<nsIDOMWindowCollection> innerDOMWindowList;
+  result = outerDOMWindow->GetFrames(getter_AddRefs(innerDOMWindowList));
+  if (NS_FAILED(result) || !innerDOMWindowList)
+    return NS_ERROR_FAILURE;
+
+  PRUint32 frameCount = 0;
+  result = innerDOMWindowList->GetLength(&frameCount);
+  XMLT_LOG(mozXMLTermUtils::GetInnerDOMWindow,31,("frameCount=%d\n",
+                                                   frameCount));
+
+  result = innerDOMWindowList->NamedItem(innerFrameName, innerDOMWindow);
+  if (NS_FAILED(result) || !*innerDOMWindow)
+    return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+
+/** Gets the scrollable view for presentation context
+ * @param aPresContext presentation context
+ * @param aScrollableView returned scrollable view
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetPresContextScrollableView(nsIPresContext* aPresContext,
+                                         nsIScrollableView** aScrollableView)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetPresContextScrollableView,30,("\n"));
+
+  if (!aScrollableView)
+    return NS_ERROR_FAILURE;
+
+  *aScrollableView = nsnull;
+
+  nsCOMPtr<nsIPresShell> presShell;
+  result = aPresContext->GetShell(getter_AddRefs(presShell));
+  if (NS_FAILED(result) || !presShell)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIViewManager> viewManager;
+  result = presShell->GetViewManager(getter_AddRefs(viewManager));
+  if (NS_FAILED(result) || !viewManager)
+    return NS_ERROR_FAILURE;
+
+  return viewManager->GetRootScrollableView(aScrollableView);
+}
+
+
+/** Gets the device context for presentation context
+ * @param aPresContext presentation context
+ * @param aDeviceContext returned device context
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetPresContextDeviceContext(nsIPresContext* aPresContext,
+                                         nsIDeviceContext** aDeviceContext)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetPresContextScrollableView,30,("\n"));
+
+  if (!aDeviceContext)
+    return NS_ERROR_FAILURE;
+
+  *aDeviceContext = nsnull;
+
+  nsCOMPtr<nsIPresShell> presShell;
+  result = aPresContext->GetShell(getter_AddRefs(presShell));
+  if (NS_FAILED(result) || !presShell)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIViewManager> viewManager;
+  result = presShell->GetViewManager(getter_AddRefs(viewManager));
+  if (NS_FAILED(result) || !viewManager)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIDeviceContext> deviceContext;
+  result = viewManager->GetDeviceContext(*getter_AddRefs(deviceContext));
+  if (NS_FAILED(result) || !deviceContext)
+    return NS_ERROR_FAILURE;
+
+  *aDeviceContext = deviceContext.get();
+  NS_ADDREF(*aDeviceContext);
+
+  return NS_OK;
+}
+
+
+/** Gets the script context for document
+ * @param aDOMDocument document providing context
+ * @param aScriptContext returned script context
+ * @return NS_OK on success
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::GetScriptContext(nsIDOMDocument* aDOMDocument,
+                                  nsIScriptContext** aScriptContext)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::GetScriptContext,20,("\n"));
+
+  nsCOMPtr<nsIDocument> doc ( do_QueryInterface(aDOMDocument) );
+  if (!doc)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObject;
+  result = doc->GetScriptGlobalObject(getter_AddRefs(scriptGlobalObject));
+
+  if (NS_FAILED(result) || !scriptGlobalObject)
+    return NS_ERROR_FAILURE;
+
+  return scriptGlobalObject->GetContext(aScriptContext);
+}
+
+
+/** Executes script in specified document's context.
+ * @param aDOMDocument document providing context for script execution
+ * @param aScript string to be executed
+ * @param aOutput output string produced by script execution
+ * @return NS_OK if script was valid and got executed properly
+ */
+NS_EXPORT nsresult
+mozXMLTermUtils::ExecuteScript(nsIDOMDocument* aDOMDocument,
+                               const nsString& aScript,
+                               nsString& aOutput)
+{
+  nsresult result;
+
+  XMLT_LOG(mozXMLTermUtils::ExecuteScript,20,("\n"));
+
+  // Get document principal
+  nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDOMDocument);
+  if (!doc)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPrincipal> docPrincipal=dont_AddRef(doc->GetDocumentPrincipal());
+
+  // Get document script context
+  nsCOMPtr<nsIScriptContext> scriptContext;
+  result = GetScriptContext(aDOMDocument, getter_AddRefs(scriptContext));
+  if (NS_FAILED(result) || !scriptContext)
+    return NS_ERROR_FAILURE;
+
+  // Execute script
+  PRBool isUndefined = PR_FALSE;
+  nsString outputString = "";
+  const char* URL = "";
+  const char* version = "";
+  result = scriptContext-> EvaluateString(aScript, (void *) nsnull,
+                                          docPrincipal, URL, 0, version,
+                                          aOutput, &isUndefined);
+  return result;
+}
+
+
+/** Returns a timestamp string containing the local time, if at least
+ * deltaSec seconds have elapsed since the last timestamp. Otherwise,
+ * a null string is returned.
+ * @param deltaSec minimum elapsed seconds since last timestamp (>=0)
+ * @param lastTime in/out parameter containing time of last timestamp
+ * @param aTimeStamp  returned timestamp string
+ * @return NS_OK on success
+ */
+NS_IMETHODIMP mozXMLTermUtils::TimeStamp(PRInt32 deltaSec, PRTime& lastTime,
+                                     nsString& aTimeStamp)
+{
+  static const PRInt32 DATE_LEN = 19;
+  PRTime deltaTime ;
+  char dateStr[DATE_LEN+1];
+  PRTime curTime, difTime;
+
+  curTime = PR_Now();
+  LL_SUB(difTime, curTime, lastTime);
+
+  LL_I2L(deltaTime, deltaSec*1000000);
+  if (LL_CMP(difTime, <, deltaTime)) {
+    // Not enough time has elapsed for a new time stamp
+    aTimeStamp = "";
+    return NS_OK;
+  }
+
+  lastTime = curTime;
+
+  // Current local time
+  PRExplodedTime localTime;
+  PR_ExplodeTime(curTime, PR_LocalTimeParameters, &localTime);
+
+  PRInt32 nWritten = PR_snprintf(dateStr, DATE_LEN+1,
+                     "%02d:%02d:%02d %02d/%02d/%04d",
+                   localTime.tm_hour, localTime.tm_min, localTime.tm_sec,
+                   localTime.tm_mday, localTime.tm_month+1, localTime.tm_year);
+
+  if (nWritten != DATE_LEN)
+    return NS_ERROR_FAILURE;
+
+  XMLT_LOG(mozXMLTermUtils::LocalTime,99,("localTime=%s\n", dateStr));
+
+  aTimeStamp = dateStr;
+  return NS_OK;
+}
+
+
+/** Returns a string containing a 11-digit random cookie based upon the
+ *  current local time and the elapsed execution of the program.
+ * @param aCookie  returned cookie string
+ * @return NS_OK on success
+ */
+NS_IMETHODIMP mozXMLTermUtils::RandomCookie(nsString& aCookie)
+{
+  // Current local time
+  PRExplodedTime localTime;
+  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &localTime);
+
+  PRInt32        randomNumberA = localTime.tm_sec*1000000+localTime.tm_usec;
+  PRIntervalTime randomNumberB = PR_IntervalNow();
+
+  XMLT_LOG(mozXMLTermUtils::RandomCookie,30,("ranA=0x%x, ranB=0x%x\n",
+                                        randomNumberA, randomNumberB));
+  PR_ASSERT(randomNumberA >= 0);
+  PR_ASSERT(randomNumberB >= 0);
+
+  static const char cookieDigits[17] = "0123456789abcdef";
+  char cookie[12];
+  int j;
+
+  for (j=0; j<6; j++) {
+    cookie[j] = cookieDigits[randomNumberA%16];
+    randomNumberA = randomNumberA/16;
+  }
+  for (j=6; j<11; j++) {
+    cookie[j] = cookieDigits[randomNumberB%16];
+    randomNumberB = randomNumberB/16;
+  }
+  cookie[11] = '\0';
+
+  aCookie = cookie;
+
+  return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTermUtils.h

@@ -0,0 +1,145 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTermUtils.h: XMLTerm utilities header
+
+#ifndef _MOZXMLTERMUTILS_H
+
+#define _MOZXMLTERMUTILS_H 1
+
+#include "nscore.h"
+
+#include "nsString.h"
+
+#include "nsIWebShell.h"
+#include "nsIDOMWindow.h"
+#include "nsIDOMDocument.h"
+
+class mozXMLTermUtils
+{
+ public:
+  /** Gets presentation context for web shell
+   * @param aWebShell web shell
+   * @param aPresContext returned presentation context
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetWebShellPresContext(nsIWebShell* aWebShell,
+                           nsIPresContext** aPresContext);
+
+  /** Gets DOM document for web shell
+   * @param aWebShell web shell
+   * @param aDOMDocument returned DOM document
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetWebShellDOMDocument(nsIWebShell* aWebShell,
+                           nsIDOMDocument** aDOMDocument);
+
+  /** Gets DOM window for web shell
+   * @param aWebShell web shell
+   * @param aDOMWindow returned DOM window (frame)
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    ConvertWebShellToDOMWindow(nsIWebShell* aWebShell,
+                               nsIDOMWindow** aDOMWindow);
+
+  /** Gets web shell for DOM window
+   * @param aDOMWindow DOM window (frame)
+   * @param aWebShell returned web shell
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    ConvertDOMWindowToWebShell(nsIDOMWindow* aDOMWindow,
+                               nsIWebShell** aWebShell);
+
+  /** Locates named inner DOM window (frame) inside outer DOM window
+   * @param outerDOMWindow outer DOM window (frame)
+   * @param innerFrameName name of inner frame to be returned
+   * @param innerDOMWindow returned inner DOM window (frame)
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetInnerDOMWindow(nsIDOMWindow* outerDOMWindow,
+                      const nsString& innerFrameName,
+                      nsIDOMWindow** innerDOMWindow);
+
+  /** Gets the scrollable view for presentation context
+   * @param aPresContext presentation context
+   * @param aScrollableView returned scrollable view
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetPresContextScrollableView(nsIPresContext* aPresContext,
+                                 nsIScrollableView** aScrollableView);
+
+  /** Gets the device context for presentation context
+   * @param aPresContext presentation context
+   * @param aDeviceContext returned device context
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetPresContextDeviceContext(nsIPresContext* aPresContext,
+                                nsIDeviceContext** aDeviceContext);
+
+  /** Gets the script context for document
+   * @param aDOMDocument document providing context
+   * @param aScriptContext returned script context
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    GetScriptContext(nsIDOMDocument* aDOMDocument,
+                     nsIScriptContext** aScriptContext);
+
+  /** Executes script in specified document's context.
+   * @param aDOMDocument document providing context for script execution
+   * @param aScript string to be executed
+   * @param aOutput output string produced by script execution
+   * @return NS_OK if script was valid and got executed properly
+   */
+  static NS_EXPORT nsresult
+    ExecuteScript(nsIDOMDocument* aDOMDocument,
+                  const nsString& aScript,
+                  nsString& aOutput);
+
+  /** Returns a timestamp string containing the local time, if at least
+   * deltaSec seconds have elapsed since the last timestamp. Otherwise,
+   * a null string is returned.
+   * @param deltaSec minimum elapsed seconds since last timestamp (>=0)
+   * @param lastTime in/out parameter containing time of last timestamp
+   * @param aTimeStamp  returned timestamp string
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    TimeStamp(PRInt32 deltaSec, PRTime& lastTime,
+              nsString& aTimeStamp);
+
+  /** Returns a string containing a 11-digit random cookie based upon the
+   *  current local time and the elapsed execution of the program.
+   * @param aCookie  returned cookie string
+   * @return NS_OK on success
+   */
+  static NS_EXPORT nsresult
+    RandomCookie(nsString& aCookie);
+
+};
+
+#endif  /* _MOZXMLTERMUTILS_H */

mozilla/extensions/xmlterm/base/mozXMLTerminal.cpp

@@ -0,0 +1,770 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTerminal.cpp: implementation of mozIXMLTerminal interface
+// to manage all XMLTerm operations.
+// Creates a new mozXMLTermSession object to manage session input/output.
+// Creates a mozLineTermAux object to access LineTerm operations.
+// Creates key/text/mouse/drag listener objects to handle user events.
+
+#include "nscore.h"
+#include "nspr.h"
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "nsIDocument.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDocumentViewer.h"
+#include "nsIDocumentLoaderObserver.h"
+#include "nsIObserver.h"
+
+#include "nsIPresContext.h"
+
+#include "nsIDOMEventReceiver.h"
+#include "nsIDOMEventListener.h"
+
+#include "nsIServiceManager.h"
+#include "nsISupportsPrimitives.h"
+
+#include "nsWidgetsCID.h"
+#include "nsIClipboard.h"
+#include "nsITransferable.h"
+
+#include "mozXMLT.h"
+#include "mozXMLTermUtils.h"
+#include "mozXMLTerminal.h"
+
+////////////////////////////////////////////////////////////////////////
+
+static NS_DEFINE_IID(kISupportsIID,       NS_ISUPPORTS_IID);
+
+static NS_DEFINE_IID(kIXMLTerminalIID,    MOZIXMLTERMINAL_IID);
+static NS_DEFINE_IID(kXMLTerminalCID,     MOZXMLTERMINAL_CID);
+
+static NS_DEFINE_CID(kCClipboardCID,      NS_CLIPBOARD_CID);
+static NS_DEFINE_CID(kCTransferableCID,   NS_TRANSFERABLE_CID);
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTerminal factory
+/////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewXMLTerminal(mozIXMLTerminal** aXMLTerminal)
+{
+    NS_PRECONDITION(aXMLTerminal != nsnull, "null ptr");
+    if (!aXMLTerminal)
+        return NS_ERROR_NULL_POINTER;
+
+    *aXMLTerminal = new mozXMLTerminal();
+    if (! *aXMLTerminal)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aXMLTerminal);
+    return NS_OK;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+// mozXMLTerminal implementation
+/////////////////////////////////////////////////////////////////////////
+mozXMLTerminal::mozXMLTerminal() :
+  mInitialized(PR_FALSE),
+
+  mCookie(""),
+
+  mCommand(""),
+  mPromptExpr(""),
+  mFirstInput(""),
+
+  mXMLTermShell(nsnull),
+  mWebShell(nsnull),
+  mPresShell(nsnull),
+  mDOMDocument(nsnull),
+
+  mXMLTermSession(nsnull),
+
+  mLineTermAux(nsnull),
+
+  mKeyListener(nsnull),
+  mTextListener(nsnull),
+  mMouseListener(nsnull),
+  mDragListener(nsnull)
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozXMLTerminal::~mozXMLTerminal()
+{
+  if (mInitialized) {
+    Finalize();
+  }
+}
+
+
+// Implement AddRef and Release
+NS_IMPL_ADDREF(mozXMLTerminal)
+NS_IMPL_RELEASE(mozXMLTerminal)
+
+
+NS_IMETHODIMP 
+mozXMLTerminal::QueryInterface(REFNSIID aIID,void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if ( aIID.Equals(kISupportsIID)) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(mozIXMLTerminal*,this));
+
+  } else if ( aIID.Equals(mozIXMLTerminal::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(mozIXMLTerminal*,this);
+
+  } else if (aIID.Equals(nsIDocumentLoaderObserver::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIDocumentLoaderObserver*,this);
+
+  } else if (aIID.Equals(nsIObserver::GetIID())) {
+    *aInstancePtr = NS_STATIC_CAST(nsIObserver*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  XMLT_LOG(mozXMLTerminal::QueryInterface,20,("mRefCnt = %d\n", mRefCnt));
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozXMLTerminal::GetCurrentEntryNumber(PRInt32 *aNumber)
+{
+  if (mXMLTermSession) {
+    return mXMLTermSession->GetCurrentEntryNumber(aNumber);
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTerminal::GetHistory(PRInt32 *aHistory)
+{
+  if (mXMLTermSession) {
+    return mXMLTermSession->GetHistory(aHistory);
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTerminal::SetHistory(PRInt32 aHistory)
+{
+  if (mXMLTermSession) {
+    return mXMLTermSession->SetHistory(aHistory);
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTerminal::GetPrompt(PRUnichar **aPrompt)
+{
+  if (mXMLTermSession) {
+    return mXMLTermSession->GetPrompt(aPrompt);
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+NS_IMETHODIMP mozXMLTerminal::SetPrompt(const PRUnichar* aPrompt)
+{
+  if (mXMLTermSession) {
+    return mXMLTermSession->SetPrompt(aPrompt);
+  } else {
+    return NS_ERROR_FAILURE;
+  }
+}
+
+
+// Initialize by starting load of Init page for XMLTerm
+NS_IMETHODIMP mozXMLTerminal::Init(nsIWebShell* aWebShell,
+                                   mozIXMLTermShell* aXMLTermShell,
+                                   const PRUnichar* aURL,
+                                   const PRUnichar* args)
+{
+  XMLT_LOG(mozXMLTerminal::Init,20,("\n"));
+
+  if (!aWebShell)
+      return NS_ERROR_NULL_POINTER;
+
+  if (mWebShell)
+    return NS_ERROR_ALREADY_INITIALIZED;
+
+  mWebShell = aWebShell;          // containing webshell; no addref
+
+  mXMLTermShell = aXMLTermShell;  // containing xmlterm shell; no addref
+
+  nsresult result = NS_OK;
+
+  // NOTE: Need to parse args string!!!
+  mCommand = "";
+  mPromptExpr = "";
+  mFirstInput = args;
+
+  // Initialization completed
+  mInitialized = PR_TRUE;
+
+  if ((aURL != nsnull) && (*aURL != 0)) {
+    // Load URL and activate XMLTerm after loading
+    XMLT_LOG(mozXMLTerminal::Init,22,("setting DocLoaderObs\n"));
+
+    // About to create owning reference to this
+    result = mWebShell->SetDocLoaderObserver((nsIDocumentLoaderObserver*)this);
+    if (NS_FAILED(result))
+      return NS_ERROR_FAILURE;
+
+    XMLT_LOG(mozXMLTerminal::Init,22,("done setting DocLoaderObs\n"));
+
+    // Load initial XMLterm background document
+    nsAutoString urlString(aURL);
+
+    result = mWebShell->LoadURL(urlString.GetUnicode());
+    if (NS_FAILED(result))
+      return NS_ERROR_FAILURE;
+
+  } else {
+    // Document already loaded; activate XMLTerm
+    result = Activate();
+    if (NS_FAILED(result))
+      return NS_ERROR_FAILURE;
+  }
+
+  XMLT_LOG(mozXMLTerminal::Init,21,("exiting\n"));
+  return result;
+}
+
+
+// De-initialize XMLTerminal
+NS_IMETHODIMP mozXMLTerminal::Finalize(void)
+{
+  if (mXMLTermSession) {
+    // Finalize XMLTermSession object and delete it (it is not ref. counted)
+    mXMLTermSession->Finalize();
+    delete mXMLTermSession;
+    mXMLTermSession = nsnull;
+  }
+
+  if (mDOMDocument) {
+    // Release any event listeners for the document
+    nsCOMPtr<nsIDOMEventReceiver> eventReceiver;
+    nsresult result = mDOMDocument->QueryInterface(nsIDOMEventReceiver::GetIID(), getter_AddRefs(eventReceiver));
+
+    if (NS_SUCCEEDED(result) && eventReceiver) {
+      if (mKeyListener) {
+        eventReceiver->RemoveEventListenerByIID(mKeyListener,
+                                                nsIDOMKeyListener::GetIID());
+        mKeyListener = nsnull;
+      }
+
+      if (mTextListener) {
+        eventReceiver->RemoveEventListenerByIID(mTextListener,
+                                                nsIDOMTextListener::GetIID());
+        mTextListener = nsnull;
+      }
+
+      if (mMouseListener) {
+        eventReceiver->RemoveEventListenerByIID(mMouseListener,
+                                                nsIDOMMouseListener::GetIID());
+        mMouseListener = nsnull;
+      }
+
+      if (mDragListener) {
+        eventReceiver->RemoveEventListenerByIID(mDragListener,
+                                                nsIDOMDragListener::GetIID());
+        mDragListener = nsnull;
+      }
+    }
+    mDOMDocument = nsnull;
+  }
+
+  if (mLineTermAux) {
+    // Finalize and release reference to LineTerm object owned by us
+    mLineTermAux->CloseAux();
+    mLineTermAux = nsnull;
+  }
+
+  if (mWebShell) {
+    // Stop observing document loading
+    mWebShell->SetDocLoaderObserver((nsIDocumentLoaderObserver *)nsnull);
+    mWebShell = nsnull;
+  }
+
+  mPresShell = nsnull;
+  mXMLTermShell = nsnull;
+
+  mInitialized = PR_FALSE;
+
+  return NS_OK;
+}
+
+
+/** Activates XMLterm and instantiates LineTerm;
+ * called at the the end of Init page loading.
+ */
+NS_IMETHODIMP mozXMLTerminal::Activate(void)
+{
+  nsresult result = NS_OK;
+
+#if 0
+  // TEMPORARY: Testing mozIXMLTermStream
+  nsAutoString streamData = "<HTML><HEAD><TITLE>Stream Title</TITLE>"
+                            "<SCRIPT language='JavaScript'>"
+                            "function clik(){ dump('click\\n');return(false);}"
+                            "</SCRIPT></HEAD>"
+                            "<BODY><B>Stream Body "
+                            "<SPAN STYLE='color: blue' onClick='return clik();'>Clik</SPAN></B><BR>"
+"<TABLE WIDTH=720><TR><TD WIDTH=700 BGCOLOR=maroon>&nbsp;</TABLE>"
+                            "<BR>ABCD<BR>EFGH<BR>JKLM<BR>"
+                            "</BODY></HTML>";
+
+  nsCOMPtr<mozIXMLTermStream> stream;
+  result = NS_NewXMLTermStream(getter_AddRefs(stream));
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozXMLTerminal::Activate: Failed to create stream\n");
+    return result;
+  }
+
+  nsCOMPtr<nsIDOMWindow> outerDOMWindow;
+  result = mozXMLTermUtils::ConvertWebShellToDOMWindow(mWebShell,
+                                              getter_AddRefs(outerDOMWindow));
+
+  if (NS_FAILED(result) || !outerDOMWindow)
+    return NS_ERROR_FAILURE;
+
+  result = stream->Open(outerDOMWindow, "iframe1", "chrome://dummy",
+                        "text/html", 800);
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozXMLTerminal::Activate: Failed to open stream\n");
+    return result;
+  }
+
+  result = stream->Write(streamData.GetUnicode());
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozXMLTerminal::Activate: Failed to write to stream\n");
+    return result;
+  }
+
+  result = stream->Close();
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozXMLTerminal::Activate: Failed to close stream\n");
+    return result;
+  }
+
+#endif
+
+  XMLT_LOG(mozXMLTerminal::Activate,20,("\n"));
+
+  if (!mInitialized)
+    return NS_ERROR_NOT_INITIALIZED;
+
+  PR_ASSERT(mWebShell != nsnull);
+
+  if ((mDOMDocument != nsnull) || (mPresShell != nsnull))
+    return NS_ERROR_FAILURE;
+
+  // Get reference to DOMDocument
+  nsCOMPtr<nsIDOMDocument> domDocument;
+  result = mozXMLTermUtils::GetWebShellDOMDocument(mWebShell,
+                                                 getter_AddRefs(domDocument));
+
+  if (NS_FAILED(result) || !domDocument)
+    return NS_ERROR_FAILURE;
+
+  // Get reference to presentation shell
+  if (mPresShell != nsnull)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPresContext> presContext;
+  result = mozXMLTermUtils::GetWebShellPresContext(mWebShell,
+                                                  getter_AddRefs(presContext));
+  if (NS_FAILED(result) || !presContext)
+    return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIPresShell> presShell;
+  result = presContext->GetShell(getter_AddRefs(presShell));
+
+  if (NS_FAILED(result) || !presShell)
+    return NS_ERROR_FAILURE;
+
+  // Save references to DOMDocument and presentation shell
+  // (SVN: Should these be addref'ed and released in the destructor?)
+  mDOMDocument = domDocument;  // no addref
+  mPresShell = presShell;      // no addref
+
+  // Instantiate and initialize XMLTermSession object
+  mXMLTermSession = new mozXMLTermSession();
+
+  if (!mXMLTermSession) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  result = mXMLTermSession->Init(this, mPresShell, mDOMDocument);
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to initialize XMLTermSession\n");
+    return NS_ERROR_FAILURE;
+  }
+
+
+  // Instantiate LineTerm  
+  XMLT_LOG(mozXMLTerminal::Activate,22,("instantiating lineterm\n"));
+  result = NS_NewLineTermAux(getter_AddRefs(mLineTermAux));
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to instantiate LineTermAux\n");
+    return result;
+  }
+
+  // Open LineTerm to execute command
+  // Non-owning reference to this; delete LineTerm before deleting self
+  PRInt32 options = LTERM_NOSTDERR_FLAG;
+
+  XMLT_LOG(mozXMLTerminal::Activate,22,("Opening LineTerm\n"));
+  nsCOMPtr<nsIObserver> anObserver = this;
+#ifdef NO_CALLBACK
+  anObserver = nsnull;
+#endif
+  nsAutoString cookie;
+  result = mLineTermAux->OpenAux(mCommand.GetUnicode(),
+                                 mPromptExpr.GetUnicode(),
+                                 options, LTERM_DETERMINE_PROCESS,
+                                 mDOMDocument, anObserver, cookie);
+
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to open LineTermAux\n");
+    return result;
+  }
+  XMLT_LOG(mozXMLTerminal::Activate,22,("Opened LineTerm\n"));
+
+  // Save cookie
+  mCookie = cookie;
+
+  if (mFirstInput.Length() > 0) {
+    // Send first input command line
+    result = SendTextAux(mFirstInput);
+    if (NS_FAILED(result))
+      return result;
+  }
+
+  // Get the DOM event receiver for document
+  nsCOMPtr<nsIDOMEventReceiver> eventReceiver;
+  result = mDOMDocument->QueryInterface(nsIDOMEventReceiver::GetIID(),
+                                        getter_AddRefs(eventReceiver));
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to get DOM receiver\n");
+    return result;
+  }
+
+  // Create a key listener
+  result = NS_NewXMLTermKeyListener(getter_AddRefs(mKeyListener), this);
+  if (NS_OK != result) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to get key listener\n");
+    return result;
+  }
+
+  // Register the key listener with the DOM event receiver
+  result = eventReceiver->AddEventListenerByIID(mKeyListener,
+                                                nsIDOMKeyListener::GetIID());
+
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to register key listener\n");
+    return result;
+  }
+
+  // Create a text listener
+  result = NS_NewXMLTermTextListener(getter_AddRefs(mTextListener), this);
+  if (NS_OK != result) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to get text listener\n");
+    return result;
+  }
+
+  // Register the text listener with the DOM event receiver
+  result = eventReceiver->AddEventListenerByIID(mTextListener,
+                                                nsIDOMTextListener::GetIID());
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to register text listener\n");
+    return result;
+  }
+
+  // Create a mouse listener
+  result = NS_NewXMLTermMouseListener(getter_AddRefs(mMouseListener), this);
+  if (NS_OK != result) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to get mouse listener\n");
+    return result;
+  }
+
+  // Register the mouse listener with the DOM event receiver
+  result = eventReceiver->AddEventListenerByIID(mMouseListener,
+                                                nsIDOMMouseListener::GetIID());
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to register mouse listener\n");
+    return result;
+  }
+
+  // Create a drag listener
+  result = NS_NewXMLTermDragListener(getter_AddRefs(mDragListener), this);
+  if (NS_OK != result) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to get drag listener\n");
+    return result;
+  }
+
+  // Register the drag listener with the DOM event receiver
+  result = eventReceiver->AddEventListenerByIID(mDragListener,
+                                                nsIDOMDragListener::GetIID());
+  if (NS_FAILED(result)) {
+    XMLT_WARNING("mozXMLTerminal::Activate: Warning - Failed to register drag listener\n");
+    return result;
+  }
+
+  return NS_OK;
+}
+
+
+// Transmit string to LineTerm (use saved cookie)
+NS_IMETHODIMP mozXMLTerminal::SendTextAux(const nsString& aString)
+{
+  return SendText(aString, mCookie.GetUnicode());
+}
+
+
+// Transmit string to LineTerm
+NS_IMETHODIMP mozXMLTerminal::SendText(const nsString& aString,
+                                       const PRUnichar* aCookie)
+{
+  nsresult result;
+
+  if (!mLineTermAux)
+    return NS_ERROR_FAILURE;
+
+  // Preprocess string and check if it is to be consumed
+  PRBool consumed = false;
+  result = mXMLTermSession->Preprocess(aString, consumed);
+
+  if (!consumed) {
+    result = mLineTermAux->Write(aString.GetUnicode(), aCookie);
+    if (NS_FAILED(result)) {
+      // Close LineTerm
+      mLineTermAux->Close(aCookie);
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  return NS_OK;
+}
+
+
+// Paste data from clipboard to terminal
+NS_IMETHODIMP mozXMLTerminal::Paste()
+{
+  nsresult result;
+  nsAutoString pasteString;
+
+  XMLT_LOG(mozXMLTerminal::Paste,20,("\n"));
+
+  // Get Clipboard service
+  NS_WITH_SERVICE (nsIClipboard, clipboard, kCClipboardCID, &result);
+  if ( NS_FAILED(result) )
+    return result;
+    
+  // Generic transferable for getting clipboard data
+  nsCOMPtr<nsITransferable> trans;
+  result = nsComponentManager::CreateInstance(kCTransferableCID, nsnull, 
+                                              nsITransferable::GetIID(), 
+                                              (void**) getter_AddRefs(trans));
+
+  if (NS_FAILED(result) || !trans)
+    return NS_ERROR_FAILURE;
+
+  // DataFlavors to get out of transferable
+  trans->AddDataFlavor(kHTMLMime);
+  trans->AddDataFlavor(kTextMime);
+
+  // Get data from clipboard
+  result = clipboard->GetData(trans);
+  if (NS_FAILED(result))
+    return result;
+
+  char* bestFlavor = nsnull;
+  nsCOMPtr<nsISupports> genericDataObj;
+  PRUint32 objLen = 0;
+  result = trans->GetAnyTransferData(&bestFlavor,
+                                     getter_AddRefs(genericDataObj), &objLen);
+  if (NS_FAILED(result))
+    return result;
+
+  nsAutoString flavor ( bestFlavor );
+
+  char* temCStr = flavor.ToNewCString();
+  XMLT_LOG(mozXMLTerminal::Paste,20,("flavour=%s\n", temCStr));
+  nsAllocator::Free(temCStr);
+
+  if (flavor.Equals(kHTMLMime)) {
+    nsCOMPtr<nsISupportsWString> textDataObj ( do_QueryInterface(genericDataObj) );
+    if (textDataObj && objLen > 0) {
+      PRUnichar* text = nsnull;
+      textDataObj->ToString ( &text );
+      pasteString.SetString ( text, objLen / 2 );
+      result = SendTextAux(pasteString);
+    }
+
+  } else if (flavor.Equals(kTextMime)) {
+    nsCOMPtr<nsISupportsString> textDataObj ( do_QueryInterface(genericDataObj) );
+    if (textDataObj && objLen > 0) {
+      char* text = nsnull;
+      textDataObj->ToString ( &text );
+      pasteString.SetString ( text, objLen );
+      result = SendTextAux(pasteString);
+    }
+  }
+
+  nsAllocator::Free(bestFlavor);
+
+  return NS_OK;
+}
+
+
+// Poll for readable data from LineTerm
+NS_IMETHODIMP mozXMLTerminal::Poll(void)
+{
+  if (!mLineTermAux)
+    return NS_ERROR_NOT_INITIALIZED;
+
+  XMLT_LOG(mozXMLTerminal::Poll,20,("\n"));
+
+  return mXMLTermSession->ReadAll(mLineTermAux);
+}
+
+
+// Handle callback from LineTerm when new input/output needs to be displayed
+NS_IMETHODIMP mozXMLTerminal::Observe(nsISupports *aSubject,
+                                  const PRUnichar *aTopic,
+                                  const PRUnichar *someData)
+{
+  nsCOMPtr<mozILineTermAux> lineTermAux = do_QueryInterface(aSubject);
+  PR_ASSERT(lineTermAux != nsnull);
+
+  return mXMLTermSession->ReadAll(lineTermAux);
+}
+
+
+// Returns document associated with XMLTerminal
+NS_IMETHODIMP mozXMLTerminal::GetDocument(nsIDOMDocument** aDoc)
+{
+  if (!aDoc)
+    return NS_ERROR_NULL_POINTER;
+  *aDoc = nsnull;
+
+  NS_PRECONDITION(mDOMDocument, "bad state, null mDOMDocument");
+  if (!mDOMDocument)
+    return NS_ERROR_NOT_INITIALIZED;
+  return mDOMDocument->QueryInterface(nsIDOMDocument::GetIID(),
+                                      (void **)aDoc);
+}
+
+
+// Returns presentation shell associated with XMLTerm
+NS_IMETHODIMP mozXMLTerminal::GetPresShell(nsIPresShell** aPresShell)
+{
+  if (!aPresShell)
+    return NS_ERROR_NULL_POINTER;
+  *aPresShell = nsnull;
+
+  NS_PRECONDITION(mPresShell, "bad state, null mPresShell");
+  if (!mPresShell)
+    return NS_ERROR_NOT_INITIALIZED;
+  return mPresShell->QueryInterface(nsIPresShell::GetIID(),
+                                    (void **)aPresShell);
+}
+
+// nsIDocumentLoaderObserver methods
+NS_IMETHODIMP
+mozXMLTerminal::OnStartDocumentLoad(nsIDocumentLoader* loader, nsIURI* aURL,
+                                const char* aCommand)
+{
+   return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel* channel,
+                              nsresult aStatus,
+                              nsIDocumentLoaderObserver * aObserver)
+{
+
+   return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::OnStartURLLoad(nsIDocumentLoader* loader,
+                                 nsIChannel* channel,
+                                 nsIContentViewer* aViewer)
+{
+
+   return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::OnProgressURLLoad(nsIDocumentLoader* loader,
+                                    nsIChannel* channel, PRUint32 aProgress, 
+                                    PRUint32 aProgressMax)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::OnStatusURLLoad(nsIDocumentLoader* loader,
+                                  nsIChannel* channel, nsString& aMsg)
+{
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::OnEndURLLoad(nsIDocumentLoader* loader,
+                               nsIChannel* channel, nsresult aStatus)
+{
+  XMLT_LOG(mozXMLTerminal::OnEndURLLoad,20,("\n"));
+
+  // Activate XMLTerm
+  Activate();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+mozXMLTerminal::HandleUnknownContentType(nsIDocumentLoader* loader, 
+                                           nsIChannel* channel,
+                                           const char *aContentType,
+                                           const char *aCommand )
+{
+   return NS_OK;
+}

mozilla/extensions/xmlterm/base/mozXMLTerminal.h

@@ -0,0 +1,153 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozXMLTerminal.h: declaration of mozXMLTerminal
+// which implements the mozIXMLTerminal interface
+// to manage all XMLterm operations.
+
+#include "nscore.h"
+#include "nspr.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+#include "mozXMLT.h"
+
+#include "mozILineTermAux.h"
+#include "mozIXMLTerminal.h"
+#include "mozXMLTermSession.h"
+#include "mozXMLTermListeners.h"
+#include "mozIXMLTermStream.h"
+
+
+class mozXMLTerminal : public mozIXMLTerminal,
+                       public nsIDocumentLoaderObserver,
+                       public nsIObserver
+{
+  public:
+
+  mozXMLTerminal();
+  virtual ~mozXMLTerminal();
+
+  // nsISupports interface
+  NS_DECL_ISUPPORTS
+
+  // mozIXMLTerminal interface
+
+  NS_IMETHOD Init(nsIWebShell* aWebShell,
+                  mozIXMLTermShell* aXMLTermShell,
+                  const PRUnichar* aURL,
+                  const PRUnichar* args);
+
+  NS_IMETHOD Finalize(void);
+  NS_IMETHOD Poll(void);
+
+  NS_IMETHOD GetCurrentEntryNumber(PRInt32 *aNumber);
+
+  NS_IMETHOD GetHistory(PRInt32 *aHistory);
+  NS_IMETHOD SetHistory(PRInt32 aHistory);
+  NS_IMETHOD GetPrompt(PRUnichar **aPrompt);
+  NS_IMETHOD SetPrompt(const PRUnichar* aPrompt);
+
+  NS_IMETHOD SendTextAux(const nsString& aString);
+  NS_IMETHOD SendText(const nsString& aString, const PRUnichar* aCookie);
+
+  NS_IMETHOD Paste();
+
+  NS_IMETHOD GetDocument(nsIDOMDocument** aDoc);
+
+  NS_IMETHOD GetPresShell(nsIPresShell** aPresShell);
+
+  // nsIDocumentLoaderObserver interface
+  NS_IMETHOD OnStartDocumentLoad(nsIDocumentLoader* loader, nsIURI* aURL,
+                                 const char* aCommand);
+
+  NS_IMETHOD OnEndDocumentLoad(nsIDocumentLoader* loader, nsIChannel* channel,
+                               nsresult aStatus,
+                               nsIDocumentLoaderObserver * aObserver);
+
+  NS_IMETHOD OnStartURLLoad(nsIDocumentLoader* loader, nsIChannel* channel,
+                            nsIContentViewer* aViewer);
+
+  NS_IMETHOD OnProgressURLLoad(nsIDocumentLoader* loader, nsIChannel* channel, PRUint32 aProgress,
+                               PRUint32 aProgressMax);
+
+  NS_IMETHOD OnStatusURLLoad(nsIDocumentLoader* loader, nsIChannel* channel,
+                             nsString& aMsg);
+
+  NS_IMETHOD OnEndURLLoad(nsIDocumentLoader* loader, nsIChannel* channel,
+                          nsresult aStatus);
+
+  NS_IMETHOD HandleUnknownContentType(nsIDocumentLoader* loader,
+                                      nsIChannel* channel,
+                                      const char *aContentType,
+                                      const char *aCommand );
+
+  // nsIObserver interface
+  NS_IMETHOD Observe(nsISupports *aSubject, const PRUnichar *aTopic,
+                     const PRUnichar *someData);
+
+  // Others
+  NS_IMETHOD Activate(void);
+
+  protected:
+
+  /** object initialization flag */
+  PRBool             mInitialized;
+
+  /** cookie string used for authentication (stored in document.cookie) */
+  nsString           mCookie;
+
+  nsString           mCommand;
+  nsString           mPromptExpr;
+
+  /** initial input string to be sent to LineTerm */
+  nsString           mFirstInput;
+
+  /** non-owning reference to containing XMLTermShell object */
+  mozIXMLTermShell*  mXMLTermShell;
+
+  /** non-owning reference to containing web shell */
+  nsIWebShell*       mWebShell;
+
+  /** non-owning (??) reference to presentation shell for XMLterm */
+  nsIPresShell*      mPresShell;
+
+  /** non-owning (??) reference to DOM document containing XMLterm */
+  nsIDOMDocument*    mDOMDocument;
+
+  /** XMLTermSession object created by us (not reference counted) */
+  mozXMLTermSession* mXMLTermSession;
+
+  /** owning reference to LineTermAux object created by us */
+  nsCOMPtr<mozILineTermAux> mLineTermAux;
+
+  /** owning referencing to key listener object created by us */
+  nsCOMPtr<nsIDOMEventListener> mKeyListener;
+
+  /** owning referencing to text listener object created by us */
+  nsCOMPtr<nsIDOMEventListener> mTextListener;
+
+  /** owning referencing to mouse listener object created by us */
+  nsCOMPtr<nsIDOMEventListener> mMouseListener;
+
+  /** owning referencing to drag listener object created by us */
+  nsCOMPtr<nsIDOMEventListener> mDragListener;
+
+};

mozilla/extensions/xmlterm/base/ptystream.c

@@ -0,0 +1,512 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ptystream.c: pseudo-TTY stream implementation
+ * CPP options:
+ *   LINUX:    for Linux2.0/glibc
+ *   SOLARIS:  for Solaris2.6
+ *   NOERRMSG: for suppressing all error messages
+ *   DEBUG:    for printing some debugging output to STDERR
+ */
+
+/* system header files */
+
+
+#include <termios.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/fcntl.h>
+
+#ifdef LINUX
+#define __USE_BSD  1
+#include <sys/ioctl.h>
+#endif
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+
+/* public declarations */
+#include "ptystream.h"
+
+/* private declarations */
+static int openPTY(struct ptys *ptyp, int noblock);
+static int attachToTTY(struct ptys *ptyp, int errfd, int noecho);
+static int setTTYAttr(int ttyFD, int noecho);
+static void pty_error(const char *errmsg, const char *errmsg2);
+
+/* parameters */
+#define C_CTL_C	  '\003'     /* ^C */
+#define C_CTL_D   '\004'     /* ^D */
+#define C_CTL_H	  '\010'     /* ^H */
+#define C_CTL_O	  '\017'     /* ^O */
+#define C_CTL_Q	  '\021'     /* ^Q */
+#define C_CTL_R	  '\022'     /* ^R */
+#define C_CTL_S	  '\023'     /* ^S */
+#define C_CTL_U	  '\025'     /* ^U */
+#define C_CTL_V	  '\026'     /* ^V */
+#define C_CTL_W   '\027'     /* ^W */
+#define C_CTL_Y	  '\031'     /* ^Y */
+#define C_CTL_Z	  '\032'     /* ^Z */
+#define C_CTL_BSL '\034'     /* ^\ */
+
+/* Disable special character functions */
+#ifdef _POSIX_VDISABLE
+#define VDISABLE	_POSIX_VDISABLE
+#else
+#define VDISABLE	255
+#endif
+
+#define	PTYCHAR1    "pqrstuvwxyzPQRSTUVWXYZ"
+#define	PTYCHAR2    "0123456789abcdef"
+
+
+/* creates a new pseudo-TTY */
+int pty_create(struct ptys *ptyp, char *const argv[],
+               int errfd, int noblock, int noecho, int noexport, int debug)
+{
+  pid_t child_pid;
+  int errfd2;
+
+  if (!ptyp) {
+    pty_error("pty_create: NULL value for PTY structure", NULL);
+    return -1;
+  }
+
+  /* Set debug flag */
+  ptyp->debug = debug;
+
+#ifdef DEBUG
+  if (ptyp->debug)
+    fprintf(stderr, "00-pty_create: errfd=%d, noblock=%d, noecho=%d, noexport=%d\n",
+                     errfd, noblock, noecho, noexport);
+#endif
+
+  /* Open PTY */
+  if (openPTY(ptyp, noblock) == -1) return -1;
+
+  /* Set default TTY size */
+  if (pty_resize(ptyp, 24, 80, 0, 0) != 0)
+    return -1;
+
+  if (errfd >= -1) {
+    /* No STDERR pipe */
+    ptyp->errpipeFD = -1;
+    errfd2 = errfd;
+
+  } else {
+    /* Create pipe to handle STDERR output */
+    int pipeFD[2];
+
+    if (pipe(pipeFD) == -1) {
+      pty_error("pty_create: STDERR pipe creation failed", NULL);
+      return -1;
+    }
+
+    /* Copy pipe file descriptors */
+    ptyp->errpipeFD = pipeFD[0];
+    errfd2          = pipeFD[1];
+  }
+
+  /* Fork a child process (VFORK) */
+  child_pid = vfork();
+  if (child_pid < 0) {
+    pty_error("pty_create: vfork failed", NULL);
+    return -1;
+  }
+
+  ptyp->pid = child_pid;
+
+#ifdef DEBUG
+  if (ptyp->debug)
+    fprintf(stderr, "00-pty_create: Fork child pid = %d, initially attached to %s\n",
+                     child_pid, ttyname(0));
+#endif
+
+  if (child_pid == 0) {
+    /* Child process */
+
+    /* Attach child to slave TTY */
+    if (attachToTTY(ptyp, errfd2, noecho) == -1) return -1;
+
+    /* Set default signal handling */
+    signal(SIGINT, SIG_DFL);
+    signal(SIGQUIT, SIG_DFL);
+    signal(SIGCHLD, SIG_DFL);
+
+    /* Set ignore signal handling */
+    signal(SIGTSTP, SIG_IGN);
+    signal(SIGTTIN, SIG_IGN);
+    signal(SIGTTOU, SIG_IGN);
+
+    if (argv != NULL) {
+      /* Execute specified command with arguments */
+      if (noexport)
+        execve(argv[0], argv, NULL);
+      else
+        execvp(argv[0], argv);
+
+      pty_error("Error in executing command ", argv[0]);
+      return -1;
+
+    } else {
+      /* Execute $SHELL or /bin/sh by default */
+      char *shell = (char *) getenv("SHELL");
+
+      if ((shell == NULL) || (*shell == '\0'))
+        shell = "/bin/sh";
+
+      if (noexport)
+        execle(shell, shell, NULL, NULL);
+      else
+        execlp(shell, shell, NULL);
+
+      pty_error("pty_create: Error in executing command ", shell);
+      return -1;
+    }
+
+  }
+
+  if (errfd < -1) {
+    /* Close write end of STDERR pipe in parent process */
+    close(errfd2);
+  }
+
+  /* Return from parent */
+  return 0;
+}
+
+
+/* closes a pseudo-TTY */
+int pty_close(struct ptys *ptyp)
+{
+  if (!ptyp) {
+    pty_error("pty_close: NULL value for PTY structure", NULL);
+    return -1;
+  }
+
+  kill(ptyp->pid, SIGKILL);
+  ptyp->pid = 0;
+
+  close(ptyp->ptyFD);
+  ptyp->ptyFD = -1;
+
+  if (ptyp->errpipeFD >= 0) {
+    close(ptyp->errpipeFD);
+    ptyp->errpipeFD = -1;
+  }
+
+  return 0;
+}
+
+
+/* resizes a pseudo-TTY */
+int pty_resize(struct ptys *ptyp, int rows, int cols,
+                                  int xpix, int ypix)
+{
+  struct winsize wsize;
+
+  if (!ptyp) {
+    pty_error("pty_resize: NULL value for PTY structure", NULL);
+    return -1;
+  }
+
+  if (ioctl(ptyp->ptyFD, TIOCGWINSZ, &wsize ) == -1) {
+    pty_error("pty_resize: Failed to get TTY window size", NULL);
+    return -1;
+  }
+
+  /* Set TTY window size */
+  wsize.ws_row = (unsigned short) rows;
+  wsize.ws_col = (unsigned short) cols;
+  wsize.ws_xpixel = (unsigned short) xpix;
+  wsize.ws_ypixel = (unsigned short) ypix;
+
+  if (ioctl(ptyp->ptyFD, TIOCSWINSZ, &wsize ) == -1) {
+    pty_error("pty_resize: Failed to set TTY window size", NULL);
+    return -1;
+  }
+
+  return 0;
+}
+
+
+static int openPTY(struct ptys *ptyp, int noblock)
+{
+  char ptyName[PTYNAMELEN+1], ttyName[PTYNAMELEN+1];
+
+  int plen, tlen, ptyFD, letIndex, devIndex;
+
+  (void) strncpy(ptyName, "/dev/pty??", PTYNAMELEN+1);
+  (void) strncpy(ttyName, "/dev/tty??", PTYNAMELEN+1);
+
+  plen = strlen(ptyName);
+  tlen = strlen(ttyName);
+
+  assert(ptyp != NULL);
+  assert(plen <= PTYNAMELEN);
+  assert(tlen <= PTYNAMELEN);
+
+  ptyFD = -1;
+  letIndex = 0;
+  while (PTYCHAR1[letIndex] && (ptyFD == -1)) {
+    ttyName[tlen - 2] =
+      ptyName[plen - 2] = PTYCHAR1 [letIndex];
+
+    devIndex = 0;
+    while (PTYCHAR2[devIndex] && (ptyFD == -1)) {
+      ttyName [tlen - 1] =
+        ptyName [plen - 1] = PTYCHAR2 [devIndex];
+
+      if ((ptyFD = open(ptyName, O_RDWR)) >= 0) {
+        if (access(ttyName, R_OK | W_OK) != 0) {
+          close(ptyFD);
+          ptyFD = -1;
+        }
+      }
+      devIndex++;
+    }
+
+    letIndex++;
+  }
+
+  if (ptyFD == -1) {
+    pty_error("openPTY: Unable to open pseudo-tty", NULL);
+    return -1;
+  }
+
+  if (noblock) {
+    /* Set non-blocking mode */
+    fcntl(ptyFD, F_SETFL, O_NDELAY);
+  }
+
+  strncpy(ptyp->ptydev, ptyName, PTYNAMELEN+1);
+  strncpy(ptyp->ttydev, ttyName, PTYNAMELEN+1);
+
+  ptyp->ptyFD = ptyFD;
+
+#ifdef DEBUG
+  if (ptyp->debug)
+    fprintf(stderr, "00-openPTY: Opened pty %s on fd %d\n", ptyName, ptyFD);
+#endif
+
+  return 0;
+}
+
+
+/* attaches new process to slave TTY */
+static int attachToTTY(struct ptys *ptyp, int errfd, int noecho)
+{
+  int          ttyFD, fd, fdMax;
+  pid_t        sid;
+  gid_t        gid;
+  unsigned int ttyMode = 0622;
+
+  assert(ptyp != NULL);
+
+  /* Create new session */
+  sid = setsid();
+
+#ifdef DEBUG
+  if (ptyp->debug)
+    fprintf(stderr, "00-attachToTTY: Returned %d from setsid\n", sid);
+#endif
+
+  if (sid < 0) {
+#ifndef NOERRMSG
+    perror("attachToTTY");
+#endif
+    return -1;
+  }
+
+  if ((ttyFD = open(ptyp->ttydev, O_RDWR)) < 0) {
+    pty_error("attachToTTY: Unable to open slave tty ", ptyp->ttydev );
+    return -1;
+  }
+
+#ifdef DEBUG
+  if (ptyp->debug)
+    fprintf(stderr,"00-attachToTTY: Attaching process %d to TTY %s on fd %d\n",
+                    getpid(), ptyp->ttydev, ttyFD);
+#endif
+
+  /* Change TTY ownership and permissions*/
+  gid = getgid();
+
+  fchown(ttyFD, getuid(), gid);
+  fchmod(ttyFD, ttyMode);
+
+  /* Set TTY attributes (this actually seems to be harmful; so commented out!)
+   */
+  /* if (setTTYAttr(ttyFD, noecho) == -1) return -1; */
+
+  /* Redirect to specified descriptor or to PTY */
+  if (errfd >= 0) {
+    /* Redirect STDERR to specified file descriptor */
+    if (dup2(errfd, 2) == -1) {
+      pty_error("attachToTTY: Failed dup2 for specified stderr", NULL);
+      return -1;
+    }
+
+  } else {
+    /* Redirect STDERR to PTY */
+    if (dup2(ttyFD, 2) == -1) {
+      pty_error("attachToTTY: Failed dup2 for default stderr", NULL);
+      return -1;
+    }
+  }
+
+  /* Redirect STDIN and STDOUT to PTY */
+  if (dup2(ttyFD, 0) == -1) {
+    pty_error("attachToTTY: Failed dup2 for stdin", NULL);
+    return -1;
+  }
+
+  if (dup2(ttyFD, 1) == -1) {
+    pty_error("attachToTTY: Failed dup2 for stdout", NULL);
+    return -1;
+  }
+
+  /* Close all other file descriptors in child process */
+  fdMax = sysconf(_SC_OPEN_MAX);
+  for (fd = 3; fd < fdMax; fd++)
+    close(fd);
+
+  /* Set process group */
+  tcsetpgrp(0, sid);
+
+  /* close(open(ptyp->ttydev, O_RDWR, 0)); */
+
+  return 0;
+}
+
+
+/* sets slave TTY attributes (NOT USED) */
+static int setTTYAttr(int ttyFD, int noecho)
+{
+  struct termios tios;
+
+  /* Get TTY attributes */
+  if (tcgetattr(ttyFD, &tios ) == -1) {
+#ifndef NOERRMSG
+    perror("setTTYAttr");
+#endif
+    pty_error("setTTYattr: Failed to get TTY attributes", NULL);
+    return -1;
+  }
+
+  /* TERMIOS settings for TTY */
+  tios.c_cc[VINTR]    = C_CTL_C;
+  tios.c_cc[VQUIT]    = C_CTL_BSL;
+  tios.c_cc[VERASE]   = C_CTL_H;
+  tios.c_cc[VKILL]    = C_CTL_U;
+  tios.c_cc[VEOF]     = C_CTL_D;
+  tios.c_cc[VEOL]     = VDISABLE;
+  tios.c_cc[VEOL2]    = VDISABLE;
+#ifdef SOLARIS
+  tios.c_cc[VSWTCH]   = VDISABLE;
+#endif
+  tios.c_cc[VSTART]   = C_CTL_Q;
+  tios.c_cc[VSTOP]    = C_CTL_S;
+  tios.c_cc[VSUSP]    = C_CTL_Z;
+  tios.c_cc[VREPRINT] = C_CTL_R;
+  tios.c_cc[VDISCARD] = C_CTL_O;
+  tios.c_cc[VWERASE]  = C_CTL_W;
+  tios.c_cc[VLNEXT]   = C_CTL_V;
+
+  tios.c_cc[VMIN]     = 1;    /* Wait for at least 1 char of input */
+  tios.c_cc[VTIME]    = 0;    /* Wait indefinitely (block)  */
+
+  /* Input modes */
+  tios.c_iflag &= ~IUCLC;     /* Disable map of upper case input to lower*/
+  tios.c_iflag &= ~IGNBRK;    /* Do not ignore break */
+  tios.c_iflag &= ~BRKINT;    /* Do not signal interrupt on break either */
+
+  /* Output modes */
+  tios.c_oflag &= ~OPOST;     /* Disable output postprocessing */
+  tios.c_oflag &= ~ONLCR;     /* Disable mapping of NL to CR-NL on output */
+  tios.c_oflag &= ~OLCUC;     /* Disable map of lower case output to upper */
+                              /* No output delays */
+  tios.c_oflag &= ~(NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY);
+
+  /* control modes */
+  tios.c_cflag |= (CS8 | CREAD);
+
+  /* line discipline modes */
+  if (noecho)
+    tios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT |
+                      ECHOCTL); /* Disable echo */
+  else
+    tios.c_lflag |=  (ECHO | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT |
+                      ECHOCTL); /* Enable echo */
+
+  tios.c_lflag |= ISIG;       /* Enable signals */
+  tios.c_lflag |= ICANON;     /* Enable erase/kill and eof processing */
+
+  /* NOTE: tcsh does not echo to be turned off if TERM=xterm;
+           setting TERM=dumb allows echo to be turned off,
+           but command completion is turned off as well */
+
+  /* Set TTY attributes */
+  cfsetospeed (&tios, B38400);
+  cfsetispeed (&tios, B38400);
+
+  if (tcsetattr(ttyFD, TCSADRAIN, &tios ) == -1) {
+#ifndef NOERRMSG
+    perror("setTTYAttr");
+#endif
+    pty_error("setTTYattr: Failed to set TTY attributes", NULL);
+    return -1;
+  }
+
+  return 0;
+}
+
+
+/* displays an error message, optionally concatenated with another */
+static void pty_error(const char *errmsg, const char *errmsg2) {
+
+#ifndef NOERRMSG
+  if (errmsg != NULL) {
+    if (errmsg2 != NULL) {
+      fprintf(stderr, "%s%s\n", errmsg, errmsg2);
+    } else {
+      fprintf(stderr, "%s\n", errmsg);
+    }
+  }
+#endif
+
+}

mozilla/extensions/xmlterm/base/ptystream.h

@@ -0,0 +1,92 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ptystream.h: pseudo-TTY stream header
+ * (used by ltermPrivate.h)
+ */
+
+#ifndef _PTYSTREAM_H
+
+#define _PTYSTREAM_H   1
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#define PTYNAMELEN 10         /* Length of PTY/TTY device name: /dev/pty?? */
+
+struct ptys {                 /* PTY structure */
+
+  int ptyFD;                  /* PTY file descriptor (bi-directional) */
+  int errpipeFD;              /* stderr pipe file descriptor (-1, if none) */
+
+  long pid;                   /* PTY child PID */
+
+  int debug;                  /* Debugging flag */
+
+  char ptydev[PTYNAMELEN+1];  /* PTY (master) name */
+  char ttydev[PTYNAMELEN+1];  /* TTY (slave) name */
+};
+
+/* creates a new pseudo-TTY (PTY) and also a new process attached to
+ * it to execute the command line contained in array ARGV.
+ * The PTY details are stored in the PTY structure PTYP.
+ * ERRFD is the file descriptor to which the STDERR output of the
+ * child process is directed.
+ * If ERRFD == -1, then the STDERR output is redirected to STDOUT.
+ * If ERRFD == -2, then a new pipe is created and STDERR is redirected
+ * through it.
+ * If NOBLOCK is true, enable non-blocking I/O on PTY.
+ * If NOECHO is true, tty echoing is turned off.
+ * If NOEXPORT is true, then the current environment is not exported
+ * to the new process.
+ * If DEBUG is true, debugging messages are printed to STDERR.
+ * Returns 0 on success and -1 on error.
+ */
+int pty_create(struct ptys *ptyp, char *const argv[],
+               int errfd, int noblock, int noecho, int noexport, int debug);
+
+/* resizes the PTY, returning 0 on success and -1 on error */
+int pty_resize(struct ptys *ptyp, int rows, int cols,
+                                  int xpix, int ypix);
+
+/* closes the PTY and kills the associated child process, if still alive.
+ * Also close STDERR pipe, if open.
+ * Returns 0 on success and -1 on error.
+ */
+int pty_close(struct ptys *ptyp);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif  /* _PTYSTREAM_H */

mozilla/extensions/xmlterm/base/tracelog.c

@@ -0,0 +1,205 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* tracelog.c: Tracing/logging module implementation
+ */
+
+/* public declarations */
+#include <stdlib.h>
+#include <stdarg.h>
+
+#include "unistring.h"
+#include "tracelog.h"
+
+/* private declarations */
+
+/* TRACELOG global variable structure */
+TlogGlobal tlogGlobal;
+
+/** Initializes all TRACELOG operations and sets filestream for trace/log
+ * output. Setting filestream to NULL suppresses all output.
+ * (documented in tracelog.h)
+ */
+void tlog_init(FILE* fileStream)
+{
+  int imodule;
+
+  fprintf(stderr, "tlog_init:\n");
+
+  /* Error output stream */
+  tlogGlobal.errorStream = fileStream;
+
+  /* Debugging is disabled initially */
+  tlogGlobal.debugOn = 0;
+
+  for (imodule=0; imodule<TLOG_MAXMODULES; imodule++) {
+    tlogGlobal.messageLevel[imodule] = 0;
+    tlogGlobal.functionList[imodule] = NULL;
+  }
+}
+
+
+/** Sets TRACELOG display levels for module IMODULE
+ * (documented in tracelog.h)
+ * @return 0 on success, or -1 on error.
+ */
+int tlog_set_level(int imodule, int messageLevel, const char *functionList)
+{
+  int j;
+
+  fprintf(stderr, "tlog_set_level:%d, %d\n", imodule, messageLevel);
+
+  if ((imodule < 0) || (imodule >= TLOG_MAXMODULES))
+    return -1;
+
+  /* Message level */
+  tlogGlobal.messageLevel[imodule] = messageLevel;
+
+  if (messageLevel > 0) {
+    tlog_warning("tlog_set_level: module %d, messageLevel=%d\n",
+                                    imodule, messageLevel);
+  }
+
+  /* Free function list string */
+  free(tlogGlobal.functionList[imodule]);
+
+  if (functionList == NULL) {
+    tlogGlobal.functionList[imodule] = NULL;
+
+  } else {
+    /* Duplicate function list string */
+    int slen = strlen(functionList);
+    char *stem;
+
+    if (slen > 1000) slen = 1000;
+
+    stem = malloc((unsigned int) slen+3);
+    strncpy(&stem[1], functionList, (unsigned int) slen);
+    stem[0] = ':';
+    stem[slen+1] = ':';
+    stem[slen+2] = '\0';
+
+    tlogGlobal.functionList[imodule] = stem;
+
+    if (messageLevel > 0) {
+      tlog_warning("tlog_set_level: module %d, functionList=\"%s\"\n",
+                                    imodule, tlogGlobal.functionList[imodule]);
+    }
+  }
+
+  /* Turn on debugging only if needed */
+  tlogGlobal.debugOn = 0;
+
+  if (tlogGlobal.errorStream != NULL) {
+    for (j=0; j<TLOG_MAXMODULES; j++) {
+      if ((tlogGlobal.messageLevel[j] > 0) ||
+          (tlogGlobal.functionList != NULL))
+        tlogGlobal.debugOn = 1;
+    }
+  }
+
+  return 0;
+}
+
+
+/** Determines whether trace/log message is to be displayed for specified
+ * module at specified message level.
+ * @return 1 (true) if message should be displayed, 0 otherwise
+ */
+int tlog_test(int imodule, char *procstr, int level)
+{
+  if (tlogGlobal.errorStream == NULL)
+    return 0;
+
+  if ((imodule < 0) || (imodule >= TLOG_MAXMODULES))
+    return 0;
+
+  if ( (level%10 <= tlogGlobal.messageLevel[imodule]%10) &&
+       ( (level <= tlogGlobal.messageLevel[imodule]) ||
+         ((tlogGlobal.functionList[imodule] != NULL) &&
+          ( (strstr(tlogGlobal.functionList[imodule],procstr) != NULL) ||
+             (strstr(procstr,tlogGlobal.functionList[imodule]) != NULL)) ) )) {
+    /* Display message */
+    fprintf(tlogGlobal.errorStream, "%s%2d: ", procstr, level);
+    return 1;
+  }
+
+  return 0;
+}
+
+
+/** Displays an error message on the TRACELOG filestream */
+void tlog_message(const char *format, ...)
+{
+  va_list ap;             /* pointer to variable length argument list */
+
+  if (tlogGlobal.errorStream == NULL)
+    return;
+
+  va_start(ap, format);   /* make ap point to first unnamed arg */
+  vfprintf(tlogGlobal.errorStream, format, ap);
+  va_end(ap);             /* clean up */
+  return;
+}
+
+
+/** Displays a warning message on the TRACELOG filestream */
+void tlog_warning(const char *format, ...)
+{
+  va_list ap;             /* pointer to variable length argument list */
+
+  if ((tlogGlobal.errorStream == NULL) || !tlogGlobal.debugOn)
+    return;
+
+  va_start(ap, format);   /* make ap point to first unnamed arg */
+  vfprintf(tlogGlobal.errorStream, format, ap);
+  va_end(ap);             /* clean up */
+  return;
+}
+
+
+#ifdef _UNISTRING_H
+#define MAXCOL 1024            /* Maximum columns in line buffer */
+
+/** Displays an Unicode message on the TRACELOG filestream */
+void tlog_unichar(const UNICHAR *buf, int count)
+{
+  if (tlogGlobal.errorStream == NULL)
+    return;
+
+  fprintf(tlogGlobal.errorStream, "U(%d): ", count);
+
+  ucsprint(tlogGlobal.errorStream, buf, count);
+
+  fprintf(tlogGlobal.errorStream, "\n");
+}
+#endif

mozilla/extensions/xmlterm/base/tracelog.h

@@ -0,0 +1,154 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* tracelog.h: Tracing/logging module header
+ * CPP options:
+ *   DEBUG:          to enable debugging output
+ *   _UNISTRING_H:   for unicode messages compatible with "unistring.h"
+ */
+
+#ifndef _TRACELOG_H
+
+#define _TRACELOG_H 1
+
+#include <stdio.h>
+#include <string.h>
+
+/* Trace/log macros (to be used after call to tlog_init to initialize):
+ * TLOG_ERROR:   error message macro, e.g.,
+ *                                          TLOG_ERROR(format, val1, val2);
+ * TOG_WARNING:  warning message macro, e.g.,
+ *                                          TLOG_WARNING(format, val1, val2);
+ * TLOG_PRINT:   message logging macro, e.g., (no terminating semicolon)
+ *                                         TLOG_PRINT(10,(format, val1, val2));
+ * (if UNISTRING module is being used)
+ * TLOG_UNICHAR: Unicode string logging macro, e.g., (no terminating semicolon)
+ *                                          TLOG_UNICHAR(10,(label,str,count));
+ */
+
+/* Max. number of modules recognized by TRACELOG */
+# define TLOG_MAXMODULES 50
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/* Initializes all TRACELOG operations;
+ * needs to be called before any other trace/log calls.
+ *
+ * FILESTREAM is the file stream to be used to print messages.
+ *
+ * Normally, only error messages are sent to FILESTREAM.
+ * If FILESTREAM is null, all output, including error output, is suppressed.
+ */
+
+void tlog_init(FILE* fileStream);
+
+/** Set diagnostic message display level for module no. IMODULE.
+ * (0 <= IMODULE < TLOG_MAXMODULES)
+ *
+ * MESSAGELEVEL (>=0) specifies the diagnostic message display level:
+ *  only diagnostic messages with level values >= MESSAGELEVEL are printed
+ *  (For example, level 10, 11, ...: outermost level;
+ *                level 20, 21, ...: next inner level;
+ *                ...
+ *                level 50, 51, ...: innermost level)
+ *
+ * The message SUBLEVEL threshold is defined as MESSAGELEVEL%10
+ * (ranging from 0 to 9).
+ * Only those diagnostic messages with sublevel values >= SUBLEVEL threshold
+ * are displayed
+ * Usually, the SUBLEVEL threshold values are interpreted as
+ *  0 =>     print single message per selected procedure.
+ *  1...9 => print only messages upto selected sublevel.
+ *
+ * Setting MESSAGELEVEL to zero and FUNCTIONLIST to null for all modules
+ * disables debugging and printing of warning messages.
+ * (This is the initial configuration following the call to lterm_init.)
+ * Setting MESSAGELEVEL to 1 for atleast one module enables debugging and
+ * causes warning messages for all modules to be printed.
+ *
+ * FUNCTIONLIST is a colon-separated string of function names, e.g.,
+ * "func_a:func_b".
+ * Trace/log messages for functions in this list are always output
+ * if debugging is enabled provided the sublevel values exceed the threshold,
+ * regardless of full message level values.
+ * If FUNCTIONLIST contains a single method name without a class name, or a
+ * class name without a method name, then the missing portion is assumed
+ * to be wild-carded.
+ *
+ * Returns 0 on success, -1 otherwise (i.e., for invalid module numbers)
+ */
+
+int tlog_set_level(int imodule, int messageLevel, const char *functionList);
+
+int tlog_test(int imodule, char *procname, int level);
+void tlog_message(const char *format, ...);
+void tlog_warning(const char *format, ...);
+
+/* TRACELOG global variables */
+typedef struct { 
+  FILE *errorStream;                     /* file stream for logging */
+  int debugOn;
+  int messageLevel[TLOG_MAXMODULES];
+  char *functionList[TLOG_MAXMODULES];   /* list of functions to be debugged */
+} TlogGlobal;
+
+extern TlogGlobal tlogGlobal;
+
+#ifdef  __cplusplus
+}
+#endif
+
+#define TLOG_ERROR tlog_message
+
+#define TLOG_WARNING tlog_warning
+
+#define TLOG_PRINT(imodule,procname,level,args) \
+do {                                            \
+  if (tlogGlobal.debugOn && tlog_test(imodule,":" #procname ":",level)) {  \
+      tlog_message args;                                                  \
+  }                                             \
+} while(0)
+
+#ifdef _UNISTRING_H
+void tlog_unichar(const UNICHAR *buf, int count);
+
+#define TLOG_UNICHAR(imodule,procname,level,args) \
+do {                                              \
+if (tlogGlobal.debugOn && tlog_test(imodule,":" #procname ":",level)) {  \
+    tlog_unichar args;                            \
+  }                                               \
+} while(0)
+#endif
+
+#endif  /* _TRACELOG_H */

mozilla/extensions/xmlterm/base/unistring.c

@@ -0,0 +1,186 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* unistring.c: Unicode string operations implementation */
+
+/* public declarations */
+#include "unistring.h"
+
+/* private declarations */
+
+/** Encodes Unicode string US with NUS characters into UTF8 string S with
+ * upto NS characters, returning the number of REMAINING Unicode characters
+ * and the number of ENCODED Utf8 characters
+ */
+void ucstoutf8(const UNICHAR* us, int nus, char* s, int ns, 
+               int* remaining, int* encoded)
+{
+  int j, k;
+
+  j = 0;
+  k = 0;
+  while ((j < ns) && (k < nus)) {
+    UNICHAR uch = us[k++];
+
+    if (uch < 0x0080) {
+      s[j++] = uch;
+
+    } else if (uch < 0x0800) {
+      if (j >= ns-1) break;
+      s[j++] = ((uch & 0x07C0) >>  6) | 0xC0;
+      s[j++] =  (uch & 0x003F)        | 0x80;
+
+    } else {
+      if (j >= ns-2) break;
+      s[j++] = ((uch & 0xF000) >> 12) | 0xE0;
+      s[j++] = ((uch & 0x0FC0) >>  6) | 0x80;
+      s[j++] =  (uch & 0x003F)        | 0x80;
+    }
+  }
+
+  if (remaining)
+    *remaining = nus - k;
+
+  if (encoded)
+    *encoded = j;
+}
+
+
+/** Decodes UTF8 string S with NS characters to Unicode string US with
+ * upto NUS characters, returning the number of REMAINING Utf8 characters
+ * and the number of DECODED Unicode characters.
+ * If skipNUL is non-zero, NUL input characters are skipped.
+ * returns 0 if successful,
+ *        -1 if an error occurred during decoding
+ */
+int utf8toucs(const char* s, int ns, UNICHAR* us, int nus,
+              int skipNUL, int* remaining, int* decoded)
+{
+  int j, k;
+  int retcode = 0;
+
+  j = 0;
+  k = 0;
+  while ((j < ns) && (k < nus)) {
+    char ch = s[j];
+
+    if (0x80 & ch) {
+      if (0x40 & ch) {
+        if (0x20 & ch) {
+          /* consume 3 */
+          if (j >= ns-2) break;
+
+          if ( (s[j+1] & 0x40) || !(s[j+1] & 0x80) ||
+               (s[j+2] & 0x40) || !(s[j+2] & 0x80) ) {
+            retcode = -1;
+          }
+
+          us[k++] =   ((ch     & 0x0F) << 12)
+                    | ((s[j+1] & 0x3F) << 6)
+                    | ( s[j+2] & 0x3F);
+
+          j += 3;
+
+        } else {
+          /* consume 2 */
+          if (j >= ns-1) break;
+
+          if ( (s[j+1] & 0x40) || !(s[j+1] & 0x80) ) {
+            retcode = -1;
+          }
+
+          us[k++] =   ((ch     & 0x1F) << 6)
+                    | ( s[j+1] & 0x3F);
+          j += 2;
+        }
+
+      } else {
+        /* consume 1 (error) */
+        retcode = -1;
+        j++;
+      }
+
+    } else {
+      /* consume 1 */
+      if (ch || !skipNUL) {
+        us[k++] = ch;
+      }
+      j++;
+    }
+  }
+
+  if (remaining)
+    *remaining = ns - j;
+
+  if (decoded)
+    *decoded = k;
+
+  return retcode;
+}
+
+
+/** Prints Unicode string US with NUS characters to file stream STREAM,
+ * escaping non-printable ASCII characters and all non-ASCII characters
+ */
+void ucsprint(FILE* stream, const UNICHAR* us, int nus)
+{
+  static const char hexDigits[17] = "0123456789abcdef";
+  UNICHAR uch;
+  int k;
+
+  for (k=0; k<nus; k++) {
+    uch = us[k];
+
+    if (uch < U_SPACE) {
+      /* ASCII control character */
+      fprintf(stream, "^%c", (char) uch+U_ATSIGN);
+
+    } else if (uch == U_CARET) {
+      /* Caret */
+      fprintf(stream, "^^");
+
+    } else if (uch < U_DEL) {
+      /* Printable ASCII character */
+      fprintf(stream, "%c", (char) uch);
+
+    } else {
+      /* DEL or non-ASCII character */
+      char esc_str[8]="&#0000;";
+      int j;
+      for (j=5; j>1; j--) {
+        esc_str[j] = hexDigits[uch%16];
+        uch = uch / 16;
+      }
+      fprintf(stream, "%s", esc_str);
+    }
+  }
+}

mozilla/extensions/xmlterm/base/unistring.h

@@ -0,0 +1,277 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* unistring.h: Unicode string operations header
+ * (used by lineterm.h)
+ * CPP options:
+ *   HAVE_WCSWCS: define is function wcswcs is available
+ *   HAVE_WCSSTR: define is function wcsstr is available
+ */
+
+#ifndef _UNISTRING_H
+
+#define _UNISTRING_H   1
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#ifndef _WCHAR_H
+#include "wchar.h"
+#endif
+
+#ifndef _STDIO_H
+#include "stdio.h"
+#endif
+
+/* Unicode character type:
+ * Uses the wchar_t implementation for moment.
+ * Later we might implement a 16-bit UNICHAR type to save space
+ */
+
+typedef wchar_t UNICHAR;
+
+/* Unicode string functions:
+ * use the wchar_t implementation for moment
+ */
+
+/** Encodes Unicode string US with NUS characters into UTF8 string S with
+ * upto NS characters, returning the number of REMAINING Unicode characters
+ * and the number of ENCODED Utf8 characters
+ */
+void ucstoutf8(const UNICHAR* us, int nus, char* s, int ns, 
+               int* remaining, int* encoded);
+
+/** Decodes UTF8 string S with NS characters to Unicode string US with
+ * upto NUS characters, returning the number of REMAINING Utf8 characters
+ * and the number of DECODED Unicode characters.
+ * If skipNUL is non-zero, NUL input characters are skipped.
+ * returns 0 if successful,
+ *        -1 if an error occurred during decoding
+ */
+int utf8toucs(const char* s, int ns, UNICHAR* us, int nus,
+              int skipNUL, int* remaining, int* decoded);
+
+/** Prints Unicode string US with NUS characters to file stream STREAM,
+ * escaping non-printable ASCII characters and all non-ASCII characters
+ */
+void ucsprint(FILE* stream, const UNICHAR* us, int nus);
+
+#define ucscpy    wcscpy
+#define ucsncpy   wcsncpy
+
+#define ucscat    wcscat
+#define ucsncat   wcsncat
+
+#define ucscmp    wcscmp
+#define ucsncmp   wcsncmp
+
+#define ucschr    wcschr
+#define ucsrchr   wcsrchr
+
+#define ucsspn    wcsspn
+#define ucscspn   wcscspn
+
+#define ucspbrk   wcspbrk
+
+#ifdef HAVE_WCSWCS
+#define ucsucs    wcswcs
+#else
+#ifdef HAVE_WCSSTR
+#define ucsucs    wcsstr
+#endif
+#endif
+
+#define ucslen    wcslen
+
+#define ucstok    wcstok
+
+
+/* unsigned short constants */
+
+#define U_NUL         0x00U
+
+#define U_CTL_A       0x01U
+#define U_CTL_B       0x02U
+#define U_CTL_C       0x03U
+#define U_CTL_D       0x04U
+#define U_CTL_E       0x05U
+#define U_CTL_F       0x06U
+
+#define U_BEL         0x07U      /* ^G */
+#define U_BACKSPACE   0x08U      /* ^H */
+#define U_TAB         0x09U      /* ^I */
+#define U_LINEFEED    0x0AU      /* ^J */
+
+#define U_CTL_K       0x0BU
+#define U_CTL_L       0x0CU
+
+#define U_CRETURN     0x0DU      /* ^M */
+
+#define U_CTL_N       0x0EU
+#define U_CTL_O       0x0FU
+#define U_CTL_P       0x10U
+#define U_CTL_Q       0x11U
+#define U_CTL_R       0x12U
+#define U_CTL_S       0x13U
+#define U_CTL_T       0x14U
+#define U_CTL_U       0x15U
+#define U_CTL_V       0x16U
+#define U_CTL_W       0x17U
+#define U_CTL_X       0x18U
+#define U_CTL_Y       0x19U
+#define U_CTL_Z       0x1AU
+
+#define U_ESCAPE      0x1BU      /* escape */
+
+#define U_SPACE       0x20U      /* space */
+#define U_EXCLAMATION 0x21U      /* ! */
+#define U_DBLQUOTE    0x22U      /* " */
+#define U_NUMBER      0x23U      /* # */
+#define U_DOLLAR      0x24U      /* $ */
+#define U_PERCENT     0x25U      /* % */
+#define U_AMPERSAND   0x26U      /* & */
+#define U_SNGLQUOTE   0x27U      /* ' */
+#define U_LPAREN      0x28U      /* ( */
+#define U_RPAREN      0x29U      /* ) */
+
+#define U_STAR        0x2AU      /* * */
+#define U_PLUS        0x2BU      /* + */
+#define U_COMMA       0x2CU      /* , */
+#define U_DASH        0x2DU      /* - */
+#define U_PERIOD      0x2EU      /* . */
+#define U_SLASH       0x2FU      /* / */
+
+#define U_ZERO        0x30U      /* 0 */
+#define U_ONE         0x31U      /* 1 */
+#define U_TWO         0x32U      /* 2 */
+#define U_THREE       0x33U      /* 3 */
+#define U_FOUR        0x34U      /* 4 */
+#define U_FIVE        0x35U      /* 5 */
+#define U_SIX         0x36U      /* 6 */
+#define U_SEVEN       0x37U      /* 7 */
+#define U_EIGHT       0x38U      /* 8 */
+#define U_NINE        0x39U      /* 9 */
+
+#define U_COLON       0x3AU      /* : */
+#define U_SEMICOLON   0x3BU      /* ; */
+#define U_LESSTHAN    0x3CU      /* < */
+#define U_EQUALS      0x3DU      /* = */
+#define U_GREATERTHAN 0x3EU      /* > */
+#define U_QUERYMARK   0x3FU      /* ? */
+
+#define U_ATSIGN      0x40U      /* @ */
+
+#define U_A_CHAR      0x41U      /* A */
+#define U_B_CHAR      0x42U      /* B */
+#define U_C_CHAR      0x43U      /* C */
+#define U_D_CHAR      0x44U      /* D */
+#define U_E_CHAR      0x45U      /* E */
+#define U_F_CHAR      0x46U      /* F */
+#define U_G_CHAR      0x47U      /* G */
+#define U_H_CHAR      0x48U      /* H */
+#define U_I_CHAR      0x49U      /* I */
+#define U_J_CHAR      0x4AU      /* J */
+#define U_K_CHAR      0x4BU      /* K */
+#define U_L_CHAR      0x4CU      /* L */
+#define U_M_CHAR      0x4DU      /* M */
+#define U_N_CHAR      0x4EU      /* N */
+#define U_O_CHAR      0x4FU      /* O */
+#define U_P_CHAR      0x50U      /* P */
+#define U_Q_CHAR      0x51U      /* Q */
+#define U_R_CHAR      0x52U      /* R */
+#define U_S_CHAR      0x53U      /* S */
+#define U_T_CHAR      0x54U      /* T */
+#define U_U_CHAR      0x55U      /* U */
+#define U_V_CHAR      0x56U      /* V */
+#define U_W_CHAR      0x57U      /* W */
+#define U_X_CHAR      0x58U      /* X */
+#define U_Y_CHAR      0x59U      /* Y */
+#define U_Z_CHAR      0x5AU      /* Z */
+
+#define U_LBRACKET    0x5BU      /* [ */
+#define U_BACKSLASH   0x5CU      /* \ */
+#define U_RBRACKET    0x5DU      /* ] */
+
+#define U_CARET       0x5EU      /* ^ */
+#define U_UNDERSCORE  0x5FU      /* _ */
+#define U_BACKQUOTE   0x60U      /* ` */
+
+#define U_a_CHAR      0x61U      /* a */
+#define U_b_CHAR      0x62U      /* b */
+#define U_c_CHAR      0x63U      /* c */
+#define U_d_CHAR      0x64U      /* d */
+#define U_e_CHAR      0x65U      /* e */
+#define U_f_CHAR      0x66U      /* f */
+#define U_g_CHAR      0x67U      /* g */
+#define U_h_CHAR      0x68U      /* h */
+#define U_i_CHAR      0x69U      /* i */
+#define U_j_CHAR      0x6AU      /* j */
+#define U_k_CHAR      0x6BU      /* k */
+#define U_l_CHAR      0x6CU      /* l */
+#define U_m_CHAR      0x6DU      /* m */
+#define U_n_CHAR      0x6EU      /* n */
+#define U_o_CHAR      0x6FU      /* o */
+#define U_p_CHAR      0x70U      /* p */
+#define U_q_CHAR      0x71U      /* q */
+#define U_r_CHAR      0x72U      /* r */
+#define U_s_CHAR      0x73U      /* s */
+#define U_t_CHAR      0x74U      /* t */
+#define U_u_CHAR      0x75U      /* u */
+#define U_v_CHAR      0x76U      /* v */
+#define U_w_CHAR      0x77U      /* w */
+#define U_x_CHAR      0x78U      /* x */
+#define U_y_CHAR      0x79U      /* y */
+#define U_z_CHAR      0x7AU      /* z */
+
+#define U_LCURLY      0x7BU      /* { */
+#define U_VERTBAR     0x7CU      /* | */
+#define U_RCURLY      0x7DU      /* } */
+
+#define U_TILDE       0x7EU      /* ~ */
+#define U_DEL         0x7FU      /* delete */
+
+#define U_LATIN1LO    0xA0U      /* lowest Latin1 extension character */
+#define U_NOBRKSPACE  0xA0U      /* no-break space */
+#define U_LATIN1HI    0xFFU      /* highest Latin1 extension character */
+
+#define IS_ASCII_LETTER(x) ( (((x) >= U_A_CHAR) && ((x) <= U_Z_CHAR)) || \
+                             (((x) >= U_a_CHAR) && ((x) <= U_z_CHAR)) )
+
+#define IS_ASCII_DIGIT(x)  ( ((x) >= U_ZERO) && ((x) <= U_NINE) )
+
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* _UNISTRING_H */

mozilla/extensions/xmlterm/config/README

@@ -0,0 +1 @@
+config --- Configuration info and Make rules

mozilla/extensions/xmlterm/config/autoconf.mk

@@ -0,0 +1,47 @@
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# autoconf.mk: autoconf info for stand-alone LineTerm only
+
+# C compiler
+CC  = gcc
+
+# C++ compiler
+CXX = c++
+
+# Library archive creation command
+AR  = ar cr $@
+
+OS_INCLUDES =
+OS_CFLAGS   =
+OS_CXXFLAGS =
+OS_LDFLAGS  =

mozilla/extensions/xmlterm/config/config.mk

@@ -0,0 +1,93 @@
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# config.mk: config info for stand-alone LineTerm only
+
+# Options
+#  DEBUG:          debug option
+
+# OS details
+OS_ARCH         := $(subst /,_,$(shell uname -s))
+OS_RELEASE      := $(shell uname -r)
+
+ifneq (,$(filter Linux SunOS,$(OS_ARCH)))
+OS_VERS         := $(suffix $(OS_RELEASE))
+OS_RELEASE      := $(basename $(OS_RELEASE))
+endif
+
+OS_CONFIG       := $(OS_ARCH)$(OS_RELEASE)
+
+ifeq ($(OS_ARCH),Linux)
+LIB_SUFFIX      = a
+RANLIB          = /usr/bin/ranlib
+endif
+
+ifeq ($(OS_CONFIG),SunOS5)
+LIB_SUFFIX      = a
+RANLIB          = /bin/true
+endif
+
+# C++ compiler
+CCC          = $(CXX)
+
+# OS flags
+OS_CFLAGS   += $(PLATFORM_FLAGS)
+OS_CXXFLAGS += $(PLATFORM_FLAGS)
+OS_LDFLAGS  +=
+
+# Object directory
+OBJDIR       = lib
+
+# Library directory
+LIBS_DIR     = -L$(topsrcdir)/dist/$(OBJDIR)
+
+# Distribution includes
+LOCAL_INCLUDES += -I$(topsrcdir)/dist/include
+
+# NSPR libraries
+NSPR_LIBS = -lnspr3
+
+#
+# Debug option
+#
+ifdef DEBUG
+OPTIMIZER    = -g
+DEFINES     += -DDEBUG
+else
+OPTIMIZER    =
+endif
+
+INCLUDES     = $(LOCAL_INCLUDES) $(OS_INCLUDES)
+
+CFLAGS       = $(OPTIMIZER) $(OS_CFLAGS) $(DEFINES) $(INCLUDES)
+CXXFLAGS     = $(OPTIMIZER) $(OS_CXXFLAGS) $(DEFINES) $(INCLUDES)
+LDFLAGS      = $(OS_LDFLAGS)

mozilla/extensions/xmlterm/config/rules.mk

@@ -0,0 +1,157 @@
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# rules.mk: Make rules for stand-alone LineTerm only
+
+# CAUTION: Dependency checking is very limited.
+# For compilation, the only dependencies are on *.h files in the current
+# directory and in the distribution include directory.
+# When creating executables, there is additional dependency on
+# all *.a files in the distribution object directory.
+
+ifndef LIBRARY
+ifdef LIBRARY_NAME
+LIBRARY               := lib$(LIBRARY_NAME).$(LIB_SUFFIX)
+endif # LIBRARY_NAME
+endif # LIBRARY
+
+ifdef PROGRAM
+PROGRAM               := $(addprefix $(OBJDIR)/, $(PROGRAM))
+endif
+
+ifdef SIMPLE_PROGRAMS
+SIMPLE_PROGRAMS       := $(addprefix $(OBJDIR)/, $(SIMPLE_PROGRAMS))
+endif
+
+ifdef LIBRARY
+LIBRARY               := $(addprefix $(OBJDIR)/, $(LIBRARY))
+endif
+
+ifndef OBJS
+OBJS = $(CSRCS:.c=.o) $(CPPSRCS:.cpp=.o)
+endif
+
+OBJS                  := $(addprefix $(OBJDIR)/, $(OBJS))
+
+ifdef DIRS
+LOOP_OVER_DIRS          =                                       \
+        @for d in $(DIRS); do                                   \
+                if test -f $$d/Makefile; then                   \
+                        set -e;                                 \
+                        echo "cd $$d; $(MAKE) $@";              \
+                        oldDir=`pwd`;                           \
+                        cd $$d; $(MAKE) $@; cd $$oldDir;        \
+                        set +e;                                 \
+                else                                            \
+                        echo "Skipping non-directory $$d...";   \
+                fi;                                             \
+        done
+endif
+
+ifndef PROGOBJS
+PROGOBJS = $(OBJS)
+endif
+
+# Targets
+all: export libs progs
+
+export: $(EXPORTS)
+ifneq (,$(EXPORTS))
+	+for x in $^; do                                                 \
+            rm $(topsrcdir)/dist/include/$$x;                            \
+            echo ln -s `pwd`/$$x $(topsrcdir)/dist/include/$$x;      \
+            ln -s `pwd`/$$x $(topsrcdir)/dist/include/$$x;      \
+         done
+endif
+	+$(LOOP_OVER_DIRS)
+
+libs: $(LIBRARY)
+	+$(LOOP_OVER_DIRS)
+
+progs: $(SIMPLE_PROGRAMS)
+	+$(LOOP_OVER_DIRS)
+
+clean:
+	-rm $(OBJDIR)/*
+	+$(LOOP_OVER_DIRS)
+
+#
+# Turn on C++ linking if we have any .cpp files
+#
+ifdef CPPSRCS
+CPP_PROG_LINK = 1
+endif
+
+# Create single executable program (with limited dependency checking)
+$(PROGRAM): $(PROGOBJS) $(wildcard $(topsrcdir)/dist/$(OBJDIR)/*.a)
+ifeq ($(CPP_PROG_LINK),1)
+	$(CCC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(LIBS))
+else
+	$(CC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(LIBS)
+endif
+
+# Create multiple simple executable programs (with limited dependency checking)
+$(SIMPLE_PROGRAMS): $(OBJDIR)/%: $(OBJDIR)/%.o \
+                    $(wildcard $(topsrcdir)/dist/$(OBJDIR)/*.a)
+ifeq ($(CPP_PROG_LINK),1)
+	$(CCC) -o $@ $< $(LDFLAGS) $(LIBS_DIR) $(LIBS))
+else
+	$(CC) -o $@ $< $(LDFLAGS) $(LIBS_DIR) $(LIBS)
+endif
+
+# Create library and export it
+$(LIBRARY): $(OBJS)
+	$(AR) $(OBJS)
+	$(RANLIB) $@
+	-rm $(topsrcdir)/dist/$@
+	ln -s `pwd`/$@ $(topsrcdir)/dist/$@
+
+
+# Compilation rules (with limited dependency checking)
+$(OBJDIR)/%.o: %.c $(wildcard *.h) $(wildcard $(topsrcdir)/dist/include/*.h)
+	$(CC) -o $@ -c $(CFLAGS) $<
+
+$(OBJDIR)/%.o: %.cpp $(wildcard *.h) $(wildcard $(topsrcdir)/dist/include/*.h)
+	$(CCC) -o $@ -c $(CXXFLAGS) $<
+
+
+# Recognized suffixes
+.SUFFIXES:
+.SUFFIXES: .a .o .c .cpp .h .pl .class .java .html .mk .in
+
+# Always recognized targets
+.PHONY: all clean clobber clobber_all export install libs
+
+# OS configuration
+os_config:
+	@echo "OS_ARCH = $(OS_ARCH), OS_CONFIG=$(OS_CONFIG)"
+	@echo "OS_RELEASE=$(OS_RELEASE), OS_VERS=$(OS_VERS)"

mozilla/extensions/xmlterm/config/xmlterm_config.mk

@@ -0,0 +1,102 @@
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# xmlterm_config.mk: XMLTERM-specific configuration options
+
+# Options
+#  STAND_ALONE:    compile outside Mozilla/NSPR environment
+#  DEBUG:          debug option
+#  NO_WORKAROUND:  disables workarounds to expose bugs
+#  USE_GTK_WIDGETS use GTK widget library
+#  USE_NSPR_BASE:  use basic NSPR API (excluding I/O and process creation)
+#  USE_NSPR_IO:    use NSPR I/O and process API instead of Unix API
+#  NO_PTY:         force use of pipes rather than PTY for process communication
+#  NO_CALLBACK:    do not use GTK callbacks to handle LineTerm output
+#                  (use polling instead)
+
+ifdef NO_WORKAROUND
+DEFINES        += -DNO_WORKAROUND
+endif
+
+#
+# OS dependent options
+#
+ifneq (,$(filter-out Linux2.0 Linux2.2 SunOS5,$(OS_CONFIG)))
+# Unsupported platform for PTY; use pipes for process communication
+NO_PTY = 1
+endif
+
+ifeq ($(OS_ARCH),Linux)
+DEFINES    += -DLINUX -DHAVE_WCSSTR
+endif
+
+ifeq ($(OS_CONFIG),SunOS5)
+DEFINES    += -DSOLARIS -DHAVE_WCSWCS
+endif
+
+ifeq ($(MOZ_WIDGET_TOOLKIT),gtk)
+USE_GTK_WIDGETS = 1
+endif
+
+#
+# Netscape Portable Runtime options
+#
+ifndef STAND_ALONE
+# Use NSPR base
+USE_NSPR_BASE   = 1
+endif
+
+ifdef USE_GTK_WIDGETS
+DEFINES        += -DUSE_GTK_WIDGETS
+else
+# No callback
+NO_CALLBACK = 1
+endif
+
+ifdef USE_NSPR_IO
+DEFINES        += -DUSE_NSPR_IO
+USE_NSPR_BASE   = 1
+NO_CALLBACK = 1
+endif
+
+ifdef USE_NSPR_BASE
+DEFINES        += -DUSE_NSPR_BASE
+LIBS           += $(NSPR_LIBS)
+endif
+
+ifdef NO_PTY
+DEFINES        += -DNO_PTY
+endif
+
+ifdef NO_CALLBACK
+DEFINES        += -DNO_CALLBACK
+endif

mozilla/extensions/xmlterm/dist/README

@@ -0,0 +1 @@
+dist --- Include and library files for LineTerm only

mozilla/extensions/xmlterm/doc/BUGS

@@ -0,0 +1,9 @@
+Known bugs
+----------
+
+10 Nov 1999
+
+
+1. Command line completion output duplicates command line
+
+2. Early use of "xls -i" does not scroll properly

mozilla/extensions/xmlterm/doc/FinalizeXPCOM

@@ -0,0 +1,31 @@
+"Finalize tree" to break XPCOM cycles and have clean shutdowns
+--------------------------------------------------------------
+
+               XMLterm class embedding hierarchy
+               =================================
+
+                       mozXMLTermShell (or ../geckoterm/mozGeckoTerm)
+                              |
+                              |
+                        mozXMLTerminal
+            +-----------------+----------------+
+            |                 |                |
+     mozXMLTermSession  mozLineTermAux  mozXMLTermListeners
+            |                 |
+            |                 |
+   mozXMLTermStream...    (lineterm)
+
+We would like to have clean shutdowns of an XMLterm, since we are using
+external resources, e.g., a shell process or an rlogin process. However, the
+XPCOM reference counting can hinder shutdowns, if there cycles.  To avoid
+that, the XMLterm interfaces have a Finalize or Close method. A shutdown
+event triggers a call to the Finalize method of the root interface in the
+"Finalize tree".  When the Finalize method of any interface is called, it
+first calls the Finalize methods of any child nodes in the Finalize tree, then
+releases all the XPCOM references it owns, de-initializes itself and quietly
+waits for its reference count to go to zero. In this "closed" state of the
+interface, any attempts use it result in an error return.
+
+The destructor of an object simply checks if all its interfaces have been
+finalized, and calls the Finalize methods for any that have not been.
+--

mozilla/extensions/xmlterm/doc/INSTALL.xmlterm

@@ -0,0 +1,60 @@
+XMLterm installation instructions for Linux binaries
+----------------------------------------------------
+
+*NOTE* This work in progress. User beware!
+
+*NOTE* Check the XMLterm web site <http://xmlterm.org> for updates.
+
+19 Nov 1999
+
+1. First obtain the Mozilla Linux binary tar file
+   ftp://ftp.mozilla.org/pub/mozilla/releases/m11/mozilla-i686-pc-linux-gnu-M11.tar.gz"
+   and untar it in any convenient location. This will create a
+   directory named "package" containing the binaries.
+
+2. Untar the XMLterm binary tar file "xmlterm-i686-pc-linux-gnu-M11.tar.gz"
+   in the "package" directory created above.
+
+3. Type the following command in the "package" directory:
+
+     ./mozilla chrome://xmlterm/content/xmlterm.html
+
+   This should create an XMLTerm in the browser window. Then click on
+   that window with the mouse to shift focus and start typing UNIX
+   commands.
+
+   **NOTE**
+   The command prompt is assumed to be terminated by one of the characters
+   "#$%>?", followed by a space. If this is not the case, many features will
+   not work. This restriction will be relaxed in the future.
+
+4. To use the stand-alone XMLterm executable called "xmlterm",
+   type the following command in the "package" directory:
+
+    ./run-mozilla.sh xmlterm
+
+   (The Mozilla component registry may need to be updated by running the
+    full browser using step 3 at least once before running "xmlterm".)
+
+5. The command line can be edited using EMACS-style key bindings.
+   Command completion should also work with TCSH and BASH, as should history
+   recall.
+
+6. By default, blue coloring is used to indicate clickable display elements.
+   Note that the prompt and the input command line are clickable.
+   (Of course, the appearance of XMLterm is completely configurable
+   using the CSS stylesheet chrome://xmlterm/skin/default/xmlterm.css)
+
+   After typing one or two commands, click on the prompt string of any previous
+   command to see what happens! Then click again on the same prompt string.
+   Also click on "Hide all output" button at the top of the document.
+
+   Clicking on a previous command line (to the right of the prompt) re-executes
+   the command.
+
+7. The sample Perl script "xls", the iconic/hypertext version of the Unix
+   "ls" command, is also installed in the "package" directory. Adding
+   the "package" directory to your path should enable you to use the "xls"
+   command.
+
+--

mozilla/extensions/xmlterm/doc/Implementation

@@ -0,0 +1,28 @@
+Implementation issues
+---------------------
+
+16 Sep 1999
+
+- Slowness due to DOM reflows
+
+- Cursor positioning problems
+
+- Scrolling problems
+
+- Finding a slot in the "Tasks/Tools" menu on the browser menu bar
+  for an XMLterm menu with the following options:
+
+     shell
+     rlogin
+     telnet
+     About XMLterm
+
+  This needs to be done using XUL overlays.
+
+- Drag and drop implementation; integrating XMLterm with Gnome/KDE/CDE
+
+- Full screen implementation; determining screen size
+
+- Inline floating frames to display stream output
+
+--

mozilla/extensions/xmlterm/doc/MPL

@@ -0,0 +1,602 @@
+           MOZILLA PUBLIC LICENSE
+                Version 1.1
+                 ---------
+
+
+1. Definitions.
+
+     1.0.1. "Commercial Use" means distribution or otherwise making
+     the Covered Code available to a third party.
+
+
+     1.1. ''Contributor'' means each entity that creates or
+     contributes to the creation of Modifications.
+
+
+     1.2. ''Contributor Version'' means the combination of the
+     Original Code, prior Modifications used by a Contributor, and the
+     Modifications made by that particular Contributor.
+
+
+     1.3. ''Covered Code'' means the Original Code or Modifications or
+     the combination
+
+     of the Original Code and Modifications, in each case including
+     portions thereof.
+
+     1.4. ''Electronic Distribution Mechanism'' means a mechanism
+     generally
+
+     accepted in the software development community for the electronic
+     transfer of data.
+
+     1.5. ''Executable'' means Covered Code in any form other than
+     Source Code. 
+
+     1.6. ''Initial Developer'' means the individual or entity
+     identified as the Initial Developer in the Source Code
+     notice required by Exhibit A.
+
+     1.7. ''Larger Work'' means a work which combines Covered Code or
+     portions thereof with code not governed by the terms of this
+     License.
+
+     1.8. ''License'' means this document.
+
+     1.8.1. "Licensable" means having the right to grant, to the
+     maximum extent possible, whether at the time of the initial grant
+     or subsequently acquired, any and all of the rights conveyed
+     herein.
+
+     1.9. ''Modifications'' means any addition to or deletion from the
+     substance or structure of either the Original Code or any
+     previous Modifications. When Covered Code is released as a series
+     of files, a Modification is: A. Any addition to or deletion from
+     the contents of a file containing Original Code or previous
+     Modifications.
+
+          B. Any new file that contains any part of the Original Code
+          or previous Modifications.
+
+     1.10. ''Original Code'' means Source Code of computer software
+     code which is described in the Source Code notice required by
+     Exhibit A as Original Code, and which, at the time of its release
+     under this License is not already Covered Code governed by this
+     License.
+
+     1.10.1. "Patent Claims" means any patent claim(s), now owned or
+     hereafter acquired, including without limitation, method,
+     process, and apparatus claims, in any patent Licensable by
+     grantor.
+
+     1.11. ''Source Code'' means the preferred form of the Covered
+     Code for making modifications to it, including all modules it
+     contains, plus any associated interface definition files, scripts
+     used to control compilation and installation of an Executable, or
+     source code differential comparisons against either the Original
+     Code or another well known, available Covered Code of the
+     Contributor's choice. The Source Code can be in a compressed or
+     archival form, provided the appropriate decompression or
+     de-archiving software is widely available for no charge.
+
+     1.12. "You'' (or "Your") means an individual or a legal entity
+     exercising rights under, and complying with all of the terms of,
+     this License or a future version of this License issued under
+     Section 6.1. For legal entities, "You'' includes any entity which
+     controls, is controlled by, or is under common control with
+     You. For purposes of this definition, "control'' means (a) the
+     power, direct or indirect, to cause the direction or management
+     of such entity, whether by contract or otherwise, or (b)
+     ownership of more than fifty percent (50%) of the outstanding
+     shares or beneficial ownership of such entity.
+
+2. Source Code License.
+
+     2.1. The Initial Developer Grant.  The Initial Developer hereby
+     grants You a world-wide, royalty-free, non-exclusive license,
+     subject to third party intellectual property claims: (a) under
+     intellectual property rights (other than patent or trademark)
+     Licensable by Initial Developer to use, reproduce, modify,
+     display, perform, sublicense and distribute the Original Code (or
+     portions thereof) with or without Modifications, and/or as part
+     of a Larger Work; and
+
+          (b) under Patents Claims infringed by the making, using or
+          selling of Original Code, to make, have made, use, practice,
+          sell, and offer for sale, and/or otherwise dispose of the
+          Original Code (or portions thereof).
+
+          (c) the licenses granted in this Section 2.1(a) and (b) are
+          effective on the date Initial Developer first distributes
+          Original Code under the terms of this License.
+
+          (d) Notwithstanding Section 2.1(b) above, no patent license
+          is granted: 1) for code that You delete from the Original
+          Code; 2) separate from the Original Code; or 3) for
+          infringements caused by: i) the modification of the Original
+          Code or ii) the combination of the Original Code with other
+          software or devices.
+
+     2.2. Contributor Grant.  Subject to third party intellectual
+     property claims, each Contributor hereby grants You a world-wide,
+     royalty-free, non-exclusive license
+
+          (a) under intellectual property rights (other than patent or
+          trademark) Licensable by Contributor, to use, reproduce,
+          modify, display, perform, sublicense and distribute the
+          Modifications created by such Contributor (or portions
+          thereof) either on an unmodified basis, with other
+          Modifications, as Covered Code and/or as part of a Larger
+          Work; and
+
+          (b) under Patent Claims infringed by the making, using, or
+          selling of Modifications made by that Contributor either
+          alone and/or in combination with its Contributor Version (or
+          portions of such combination), to make, use, sell, offer for
+          sale, have made, and/or otherwise dispose of: 1)
+          Modifications made by that Contributor (or portions
+          thereof); and 2) the combination of Modifications made by
+          that Contributor with its Contributor Version (or portions
+          of such combination).
+
+          (c) the licenses granted in Sections 2.2(a) and 2.2(b) are
+          effective on the date Contributor first makes Commercial Use
+          of the Covered Code.
+
+          (d) Notwithstanding Section 2.2(b) above, no patent license
+	  is granted: 1) for any code that Contributor has deleted from the
+	  Contributor Version; 2) separate from the Contributor Version; 3) for
+	  infringements caused by: i) third party modifications of Contributor
+	  Version or ii) the combination of Modifications made by that
+	  Contributor with other software (except as part of the Contributor
+	  Version) or other devices; or 4) under Patent Claims infringed by
+	  Covered Code in the absence of Modifications made by that Contributor.
+
+3. Distribution Obligations.
+
+     3.1. Application of License.  The Modifications which You create
+     or to which You contribute are governed by the terms of this
+     License, including without limitation Section 2.2. The Source
+     Code version of Covered Code may be distributed only under the
+     terms of this License or a future version of this License
+     released under Section 6.1, and You must include a copy of this
+     License with every copy of the Source Code You distribute. You
+     may not offer or impose any terms on any Source Code version that
+     alters or restricts the applicable version of this License or the
+     recipients' rights hereunder. However, You may include an
+     additional document offering the additional rights described in
+     Section 3.5.
+
+     3.2. Availability of Source Code.  Any Modification which You
+     create or to which You contribute must be made available in
+     Source Code form under the terms of this License either on the
+     same media as an Executable version or via an accepted Electronic
+     Distribution Mechanism to anyone to whom you made an Executable
+     version available; and if made available via Electronic
+     Distribution Mechanism, must remain available for at least twelve
+     (12) months after the date it initially became available, or at
+     least six (6) months after a subsequent version of that
+     particular Modification has been made available to such
+     recipients. You are responsible for ensuring that the Source Code
+     version remains available even if the Electronic Distribution
+     Mechanism is maintained by a third party.
+
+     3.3. Description of Modifications.  You must cause all Covered
+     Code to which You contribute to contain a file documenting the
+     changes You made to create that Covered Code and the date of any
+     change. You must include a prominent statement that the
+     Modification is derived, directly or indirectly, from Original
+     Code provided by the Initial Developer and including the name of
+     the Initial Developer in (a) the Source Code, and (b) in any
+     notice in an Executable version or related documentation in which
+     You describe the origin or ownership of the Covered Code.
+
+     3.4. Intellectual Property Matters (a) Third Party Claims.  If
+          Contributor has knowledge that a license under a third
+          party's intellectual property rights is required to exercise
+          the rights granted by such Contributor under Sections 2.1 or
+          2.2, Contributor must include a text file with the Source
+          Code distribution titled "LEGAL'' which describes the claim
+          and the party making the claim in sufficient detail that a
+          recipient will know whom to contact. If Contributor obtains
+          such knowledge after the Modification is made available as
+          described in Section 3.2, Contributor shall promptly modify
+          the LEGAL file in all copies Contributor makes available
+          thereafter and shall take other steps (such as notifying
+          appropriate mailing lists or newsgroups) reasonably
+          calculated to inform those who received the Covered Code
+          that new knowledge has been obtained.
+
+          (b) Contributor APIs.  If Contributor's Modifications
+          include an application programming interface and Contributor
+          has knowledge of patent licenses which are reasonably
+          necessary to implement that API, Contributor must also
+          include this information in the LEGAL file.
+
+               (c) Representations.  Contributor represents that,
+          except as disclosed pursuant to Section 3.4(a) above,
+          Contributor believes that Contributor's Modifications are
+          Contributor's original creation(s) and/or Contributor has
+          sufficient rights to grant the rights conveyed by this
+          License.
+
+     3.5. Required Notices.  You must duplicate the notice in Exhibit
+     A in each file of the Source Code.  If it is not possible to put
+     such notice in a particular Source Code file due to its
+     structure, then You must include such notice in a location (such
+     as a relevant directory) where a user would be likely to look for
+     such a notice.  If You created one or more Modification(s) You
+     may add your name as a Contributor to the notice described in
+     Exhibit A.  You must also duplicate this License in any
+     documentation for the Source Code where You describe recipients'
+     rights or ownership rights relating to Covered Code.  You may
+     choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of
+     Covered Code.  However, You may do so only on Your own behalf,
+     and not on behalf of the Initial Developer or any
+     Contributor. You must make it absolutely clear than any such
+     warranty, support, indemnity or liability obligation is offered
+     by You alone, and You hereby agree to indemnify the Initial
+     Developer and every Contributor for any liability incurred by the
+     Initial Developer or such Contributor as a result of warranty,
+     support, indemnity or liability terms You offer.
+
+     3.6. Distribution of Executable Versions.  You may distribute
+     Covered Code in Executable form only if the requirements of
+     Section 3.1-3.5 have been met for that Covered Code, and if You
+     include a notice stating that the Source Code version of the
+     Covered Code is available under the terms of this License,
+     including a description of how and where You have fulfilled the
+     obligations of Section 3.2. The notice must be conspicuously
+     included in any notice in an Executable version, related
+     documentation or collateral in which You describe recipients'
+     rights relating to the Covered Code. You may distribute the
+     Executable version of Covered Code or ownership rights under a
+     license of Your choice, which may contain terms different from
+     this License, provided that You are in compliance with the terms
+     of this License and that the license for the Executable version
+     does not attempt to limit or alter the recipient's rights in the
+     Source Code version from the rights set forth in this License. If
+     You distribute the Executable version under a different license
+     You must make it absolutely clear that any terms which differ
+     from this License are offered by You alone, not by the Initial
+     Developer or any Contributor. You hereby agree to indemnify the
+     Initial Developer and every Contributor for any liability
+     incurred by the Initial Developer or such Contributor as a result
+     of any such terms You offer.
+
+     3.7. Larger Works.  You may create a Larger Work by combining
+     Covered Code with other code not governed by the terms of this
+     License and distribute the Larger Work as a single product. In
+     such a case, You must make sure the requirements of this License
+     are fulfilled for the Covered Code.
+
+4. Inability to Comply Due to Statute or Regulation.
+
+     If it is impossible for You to comply with any of the terms of
+     this License with respect to some or all of the Covered Code due
+     to statute, judicial order, or regulation then You must: (a)
+     comply with the terms of this License to the maximum extent
+     possible; and (b) describe the limitations and the code they
+     affect. Such description must be included in the LEGAL file
+     described in Section 3.4 and must be included with all
+     distributions of the Source Code.  Except to the extent
+     prohibited by statute or regulation, such description must be
+     sufficiently detailed for a recipient of ordinary skill to be
+     able to understand it.
+
+5. Application of this License.
+
+     This License applies to code to which the Initial Developer has
+     attached the notice in Exhibit A and to related Covered Code.
+
+6. Versions of the License.
+
+     6.1. New Versions.  Netscape Communications Corporation
+     (''Netscape'') may publish revised and/or new versions of the
+     License from time to time. Each version will be given a
+     distinguishing version number.
+
+     6.2. Effect of New Versions.  Once Covered Code has been
+     published under a particular version of the License, You may
+     always continue to use it under the terms of that version. You
+     may also choose to use such Covered Code under the terms of any
+     subsequent version of the License published by Netscape. No one
+     other than Netscape has the right to modify the terms applicable
+     to Covered Code created under this License.
+
+     6.3. Derivative Works.  If You create or use a modified version
+     of this License (which you may only do in order to apply it to
+     code which is not already Covered Code governed by this License),
+     You must (a) rename Your license so that the phrases ''Mozilla'',
+     ''MOZILLAPL'', ''MOZPL'', ''Netscape'', "MPL", ''NPL'' or any
+     confusingly similar phrase do not appear in your license (except
+     to note that your license differs from this License) and (b)
+     otherwise make it clear that Your version of the license contains
+     terms which differ from the Mozilla Public License and Netscape
+     Public License.  (Filling in the name of the Initial Developer,
+     Original Code or Contributor in the notice described in Exhibit A
+     shall not of themselves be deemed to be modifications of this
+     License.)
+
+7. DISCLAIMER OF WARRANTY.
+
+     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS'' BASIS,
+     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+     INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE
+     IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR
+     NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
+     OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE
+     DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY
+     OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING,
+     REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN
+     ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS
+     AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
+
+8. TERMINATION.
+
+     8.1.  This License and the rights granted hereunder will
+     terminate automatically if You fail to comply with terms herein
+     and fail to cure such breach within 30 days of becoming aware of
+     the breach. All sublicenses to the Covered Code which are
+     properly granted shall survive any termination of this
+     License. Provisions which, by their nature, must remain in effect
+     beyond the termination of this License shall survive.
+
+     8.2.  If You initiate litigation by asserting a patent
+     infringement claim (excluding declatory judgment actions) against
+     Initial Developer or a Contributor (the Initial Developer or
+     Contributor against whom You file such action is referred to as
+     "Participant") alleging that:
+
+     (a) such Participant's Contributor Version directly or indirectly
+     infringes any patent, then any and all rights granted by such
+     Participant to You under Sections 2.1 and/or 2.2 of this License
+     shall, upon 60 days notice from Participant terminate
+     prospectively, unless if within 60 days after receipt of notice
+     You either: (i) agree in writing to pay Participant a mutually
+     agreeable reasonable royalty for Your past and future use of
+     Modifications made by such Participant, or (ii) withdraw Your
+     litigation claim with respect to the Contributor Version against
+     such Participant.  If within 60 days of notice, a reasonable
+     royalty and payment arrangement are not mutually agreed upon in
+     writing by the parties or the litigation claim is not withdrawn,
+     the rights granted by Participant to You under Sections 2.1
+     and/or 2.2 automatically terminate at the expiration of the 60
+     day notice period specified above.
+
+     (b) any software, hardware, or device, other than such
+     Participant's Contributor Version, directly or indirectly
+     infringes any patent, then any rights granted to You by such
+     Participant under Sections 2.1(b) and 2.2(b) are revoked
+     effective as of the date You first made, used, sold, distributed,
+     or had made, Modifications made by that Participant.
+
+     8.3.  If You assert a patent infringement claim against
+     Participant alleging that such Participant's Contributor Version
+     directly or indirectly infringes any patent where such claim is
+     resolved (such as by license or settlement) prior to the
+     initiation of patent infringement litigation, then the reasonable
+     value of the licenses granted by such Participant under Sections
+     2.1 or 2.2 shall be taken into account in determining the amount
+     or value of any payment or license.
+
+     8.4.  In the event of termination under Sections 8.1 or 8.2
+     above, all end user license agreements (excluding distributors
+     and resellers) which have been validly granted by You or any
+     distributor hereunder prior to termination shall survive
+     termination.
+
+9. LIMITATION OF LIABILITY.
+
+     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
+     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE
+     INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF
+     COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE
+     TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR
+     CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT
+     LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER
+     FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES
+     OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE
+     POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL
+     NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING
+     FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
+     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
+     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+     SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
+
+10. U.S. GOVERNMENT END USERS.
+
+     The Covered Code is a ''commercial item,'' as that term is
+     defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of
+     ''commercial computer software'' and ''commercial computer
+     software documentation,'' as such terms are used in 48
+     C.F.R. 12.212 (Sept. 1995).  Consistent with 48 C.F.R. 12.212 and
+     48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all
+     U.S. Government End Users acquire Covered Code with only those
+     rights set forth herein.
+
+11. MISCELLANEOUS.
+
+     This License represents the complete agreement concerning subject
+     matter hereof. If any provision of this License is held to be
+     unenforceable, such provision shall be reformed only to the
+     extent necessary to make it enforceable.  This License shall be
+     governed by California law provisions (except to the extent
+     applicable law, if any, provides otherwise), excluding its
+     conflict-of-law provisions. With respect to disputes in which at
+     least one party is a citizen of, or an entity chartered or
+     registered to do business in the United States of America, any
+     litigation relating to this License shall be subject to the
+     jurisdiction of the Federal Courts of the Northern District of
+     California, with venue lying in Santa Clara County, California,
+     with the losing party responsible for costs, including without
+     limitation, court costs and reasonable attorneys' fees and
+     expenses. The application of the United Nations Convention on
+     Contracts for the International Sale of Goods is expressly
+     excluded. Any law or regulation which provides that the language
+     of a contract shall be construed against the drafter shall not
+     apply to this License.
+
+12. RESPONSIBILITY FOR CLAIMS.
+
+     As between Initial Developer and the Contributors, each party is
+     responsible for claims and damages arising, directly or
+     indirectly, out of its utilization of rights under this License
+     and You agree to work with Initial Developer and Contributors to
+     distribute such responsibility on an equitable basis.  Nothing
+     herein is intended or shall be deemed to constitute any admission
+     of liability.
+
+13. MULTIPLE-LICENSED CODE.
+
+     Initial Developer may designate portions of the Covered Code as
+     ?Multiple-Licensed?.  ?Multiple-Licensed? means that the Initial
+     Developer permits you to utilize portions of the Covered Code
+     under Your choice of the NPL or the alternative licenses, if any,
+     specified by the Initial Developer in the file described in
+     Exhibit A.
+
+EXHIBIT A -Mozilla Public License.
+
+     ``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 ______________________________________.
+
+     The Initial Developer of the Original Code is
+     ________________________.  Portions created by
+     ______________________ are Copyright (C) ______
+     _______________________. All Rights Reserved.
+
+     Contributor(s): ______________________________________.
+
+     Alternatively, the contents of this file may be used under the
+     terms of the _____ license (the ?[___] License?), in which case
+     the provisions of [______] License are applicable instead of
+     those above.  If you wish to allow use of your version of this
+     file only under the terms of the [____] License and not to allow
+     others to use your version of this file under the MPL, indicate
+     your decision by deleting the provisions above and replace them
+     with the notice and other provisions required by the [___]
+     License.  If you do not delete the provisions above, a recipient
+     may use your version of this file under either the MPL or the
+     [___] License."
+
+     [NOTE: The text of this Exhibit A may differ slightly from the
+     text of the notices in the Source Code files of the Original
+     Code. You should use the text of this Exhibit A rather than the
+     text found in the Original Code Source Code for Your
+     Modifications.]
+
+     ----------------------------------------
+
+     AMENDMENTS
+
+     The Netscape Public License Version 1.1 ("NPL") consists of the
+     Mozilla Public License Version 1.1 with the following Amendments,
+     including Exhibit A-Netscape Public License.  Files identified
+     with "Exhibit A-Netscape Public License" are governed by the
+     Netscape Public License Version 1.1.
+
+     Additional Terms applicable to the Netscape Public License.
+     I. Effect.  These additional terms described in this Netscape
+     Public License -- Amendments shall apply to the Mozilla
+     Communicator client code and to all Covered Code under this
+     License.
+
+          II. ''Netscape's Branded Code'' means Covered Code that
+          Netscape distributes and/or permits others to distribute
+          under one or more trademark(s) which are controlled by
+          Netscape but which are not licensed for use under this
+          License.
+
+          III. Netscape and logo.  This License does not grant any
+          rights to use the trademarks "Netscape'', the "Netscape N
+          and horizon'' logo or the "Netscape lighthouse" logo,
+          "Netcenter", "Gecko", "Java" or "JavaScript", "Smart
+          Browsing" even if such marks are included in the Original
+          Code or Modifications.
+
+          IV. Inability to Comply Due to Contractual Obligation.
+          Prior to licensing the Original Code under this License,
+          Netscape has licensed third party code for use in Netscape's
+          Branded Code. To the extent that Netscape is limited
+          contractually from making such third party code available
+          under this License, Netscape may choose to reintegrate such
+          code into Covered Code without being required to distribute
+          such code in Source Code form, even if such code would
+          otherwise be considered ''Modifications'' under this
+          License.
+
+          V. Use of Modifications and Covered Code by Initial
+          Developer.  V.1. In General.  The obligations of Section 3
+          apply to Netscape, except to the extent specified in this
+          Amendment, Section V.2 and V.3.
+
+               V.2. Other Products.  Netscape may include Covered Code
+               in products other than the Netscape's Branded Code
+               which are released by Netscape during the two (2) years
+               following the release date of the Original Code,
+               without such additional products becoming subject to
+               the terms of this License, and may license such
+               additional products on different terms from those
+               contained in this License.
+
+               V.3. Alternative Licensing.  Netscape may license the
+               Source Code of Netscape's Branded Code, including
+               Modifications incorporated therein, without such
+               Netscape Branded Code becoming subject to the terms of
+               this License, and may license such Netscape Branded
+               Code on different terms from those contained in this
+               License.
+
+          VI. Litigation.  Notwithstanding the limitations of Section
+          11 above, the provisions regarding litigation in Section
+          11(a), (b) and (c) of the License shall apply to all
+          disputes relating to this License.
+
+     EXHIBIT A-Netscape Public License.
+
+          ''The contents of this file are subject to the Netscape
+          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/NPL/
+
+          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 Netscape
+          are Copyright (C) 1998-1999 Netscape Communications
+          Corporation. All Rights Reserved.
+
+          Contributor(s): ______________________________________.
+
+          Alternatively, the contents of this file may be used under
+          the terms of the _____ license (the ?[___] License?), in
+          which case the provisions of [______] License are applicable
+          instead of those above.  If you wish to allow use of your
+          version of this file only under the terms of the [____]
+          License and not to allow others to use your version of this
+          file under the NPL, indicate your decision by deleting the
+          provisions above and replace them with the notice and other
+          provisions required by the [___] License.  If you do not
+          delete the provisions above, a recipient may use your
+          version of this file under either the NPL or the [___]
+          License."
+
+
+Copyright © 1998 The Mozilla Organization.

mozilla/extensions/xmlterm/doc/Portability

@@ -0,0 +1,36 @@
+Portability issues
+---------------------
+
+16 Sep 1999
+
+Much of the XMLterm code is cross-platform. Implementation features that 
+affect portability at the moment are:
+
+1. Main event handling:
+     By default, the present implementation of XMLterm directly uses a GTK
+     call to set up a handler for XMLterm output events. This can be disabled
+     by setting NO_CALLBACK=1 in the make command line, and calling the
+     method mozIXMLTermShell::Poll() frequently to poll for readable output
+     from LineTerm.
+     (A better event/callback mechanism needs to be implemented.)
+
+2. pseudo-TTY (PTY) operations:
+     The PTY interface for XMLterm is currently implemented only for
+     two platforms, Linux and Solaris. At some point, the PTY interface
+     should be ported to most Unix platforms. On platforms where PTY
+     operations are not implemented, the cross-platform NSPR process mechanism
+     is used to create a "slave" process. However, this process uses NSPR
+     pipes for communication, which prevents the use of terminal control
+     characters such as the most usefule Control-C. (Is there a way around
+     this restriction?)
+
+  What about Windows? It should be possible to use XMLterm even under Windows,
+  using the NSPR process/pipe functions for communication and
+  using the Cygwin utilities to simulate the Unix environment.
+
+3. The lightweight GeckoTerm uses GTK.
+
+4. The "unistring" module uses wchar functions which do not always have
+   the same names.
+
+--

mozilla/extensions/xmlterm/doc/README

@@ -0,0 +1,12 @@
+doc --- Some implementation notes and documentation
+
+This directory contains some rudimentary documentation and notes.
+See the README file in the "base" directory (../base/README) for a brief
+overview of XMLterm code architecture
+
+For a discussion of XMLterm from the user's point of view, check the XMLterm
+home page at <http://xmlterm.org>.
+
+Eventually, an XMLterm project page at mozilla.org
+<http://www.mozilla.org/projects/not-ready-yet/> will contain a description
+of XMLterm architecture from a Mozilla developer's point of view.

mozilla/extensions/xmlterm/doc/SlowDOMBug

@@ -0,0 +1,22 @@
+12 Sep 1999
+
+Appending each output line separately, separated by <BR> elements, to a
+displayed HTML document seems to be rather slow. See the file
+base/mozXMLTermSession.cpp
+
+As a workaround, multiple output lines are batched into a single <PRE>
+element. This will basically only work for plain text output, without markup.
+To disable this workaround and expose the "bug", create the XMLterm libraries
+as described in the INSTALL file. Then execute the following to make the
+"buggy" libraries:
+
+cd base
+rm mozXMLTermSession.o
+make NO_WORKAROUND=1 mozXMLTermSession.o
+make libs
+
+(If you are using the "gterm" executable, you will need to re-make it as
+well)
+
+Now execute any command which produces several lines of output in an
+XMLterm window.

mozilla/extensions/xmlterm/doc/XMLterm_LICENSE

@@ -0,0 +1,19 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */

mozilla/extensions/xmlterm/doc/lineterm_LICENSE

@@ -0,0 +1,31 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */

mozilla/extensions/xmlterm/geckoterm/Makefile.in

@@ -0,0 +1,109 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/geckoterm directory (stand alone XMLterm)
+
+ifdef STAND_ALONE
+DEPTH      = ..
+topsrcdir  = ..
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../..
+topsrcdir  = @top_srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+
+# Debug option
+DEBUG = 1
+
+# Program
+PROGRAM = xmlterm
+
+# Exported header files
+EXPORTS = mozISimpleContainer.h
+
+# Defines
+DEFINES = $(TK_CFLAGS)
+
+# C++ source files
+CPPSRCS = nsSetupRegistry.cpp  \
+	mozSimpleContainer.cpp \
+	mozGeckoTerm.cpp       \
+	nsTimer.cpp            \
+	$(NULL)
+
+# Libraries to be linked
+GTK_GLUE		= -lgtksuperwin
+
+XP_DIST_LIBS		= \
+			-lraptorgfx \
+			-lmozjs \
+			-lxpcom \
+			$(JSJ_LIB) \
+			$(NULL)
+
+XP_NS_UNDERBAR_CRAP	= \
+			$(MOZ_NECKO_UTIL_LIBS) \
+			$(MOZ_TIMER_LIBS) \
+			$(MOZ_WIDGET_SUPPORT_LIBS) \
+			$(NULL)
+
+XP_LIBS			= \
+			$(XP_NS_UNDERBAR_CRAP) \
+			$(XP_DIST_LIBS) \
+			$(NSPR_LIBS) \
+			$(NULL)
+
+ifdef DYNAMIC_LINK
+# NOTE: a soft link needs to be created for libxmlterm.so in dist/bin
+XMLTERM_LIBS = -lxmlterm
+else
+# Statically link the entire XMLTERM library
+XMLTERM_LIBS = ../base/libxmlterm.a
+endif
+
+LIBS =		        \
+        $(GTK_GLUE)     \
+	$(XP_LIBS)      \
+	$(TK_LIBS)      \
+	$(XMLTERM_LIBS) \
+	$(NULL)
+
+include $(topsrcdir)/config/config.mk
+
+include ../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlterm/geckoterm/README

@@ -0,0 +1,24 @@
+geckoterm --- Stand-alone version of XMLterm using Gecko
+
+This directory contains the files used to create the stand-alone XMLterm
+executable, which runs independent of the browser. This would be the preferred
+way to use XMLterm, so that it runs as a separate process and will not
+crash if the browser does.
+
+28 Nov 1999
+
+FILES
+=====
+
+mozGeckoTerm.cpp        Main program for stand-alone "xmlterm" executable
+                          Uses GTK to create window
+                          Uses mozIXMLTerminal to create XMLterm
+                          Uses mozISimpleContainer for web shell container
+
+mozISimpleContainer.h   Simple WebShell container interface
+mozSimpleContainer.cpp  Implementation of mozISimpleContainer
+
+nsSetupRegistry.cpp     Just a copy of viewer's nSetupRegistry
+nsTimer.cpp             Implementation of timers using Gtk timer facility
+
+--

mozilla/extensions/xmlterm/geckoterm/default_prefs.js

@@ -0,0 +1,3 @@
+# Mozilla User Preferences
+// This is a generated file!
+

mozilla/extensions/xmlterm/geckoterm/default_prefs.js.sav

@@ -0,0 +1,5 @@
+# Mozilla User Preferences
+// This is a generated file!
+pref("security.checkxpconnect", true);
+pref("security.policy.default.htmldocument.cookie", "sameOrigin");
+

mozilla/extensions/xmlterm/geckoterm/mozGeckoTerm.cpp

@@ -0,0 +1,337 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozGeckoTerm.cpp: Stand-alone implementation of XMLterm using GTK
+//                   and the Mozilla Layout engine
+
+#include "stdio.h"
+
+#include <gtk/gtk.h>
+
+#if 0 // USE_SUPERWIN
+#include "gtkmozarea.h"
+#include "gdksuperwin.h"
+#endif // USE_SUPERWIN 
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsRepository.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIEventQueueService.h"
+#include "nsIPref.h"
+
+#include "mozXMLTermUtils.h"
+#include "mozISimpleContainer.h"
+#include "mozIXMLTerminal.h"
+#include "mozIXMLTermStream.h"
+
+#define XMLTERM_DLL   "libxmlterm"MOZ_DLL_SUFFIX
+
+static NS_DEFINE_IID(kISupportsIID,          NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIEventQueueServiceIID, NS_IEVENTQUEUESERVICE_IID);
+static NS_DEFINE_IID(kEventQueueServiceCID,  NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_IID(kIPrefIID,              NS_IPREF_IID);
+static NS_DEFINE_CID(kPrefCID,               NS_PREF_CID);
+static NS_DEFINE_IID(kLineTermCID,           MOZLINETERM_CID);
+static NS_DEFINE_IID(kXMLTermShellCID,       MOZXMLTERMSHELL_CID);
+
+extern "C" void NS_SetupRegistry();
+
+nsCOMPtr<mozISimpleContainer> gSimpleContainer = nsnull;
+nsCOMPtr<mozIXMLTerminal> gXMLTerminal = nsnull;
+
+/** Processes thread events */
+static void event_processor_callback(gpointer data,
+                                     gint source,
+                                     GdkInputCondition condition)
+{
+  nsIEventQueue *eventQueue = (nsIEventQueue*)data;
+  eventQueue->ProcessPendingEvents();
+  //fprintf(stderr, "event_processor_callback:\n");
+  return;
+}
+
+
+static void event_processor_configure(GtkWidget *window,
+                                      GdkEvent  *event,
+                                      GtkWidget *termWidget)
+{
+  GtkAllocation *alloc = &GTK_WIDGET(termWidget)->allocation;
+
+  //fprintf(stderr, "event_processor_configure:\n");
+
+  // Resize web shell window
+  gSimpleContainer->Resize(alloc->width, alloc->height);
+
+  return;
+}
+
+/** Cleans up and exits */
+static gint event_processor_quit(gpointer data,
+                                 gint source,
+                                 GdkInputCondition condition)
+{
+  fprintf(stderr, "event_processor_quit:\n");
+
+  if (gXMLTerminal) {
+    // Finalize XMLTerm and release owning reference to it
+    gXMLTerminal->Finalize();
+    gXMLTerminal = nsnull;
+  }
+
+  // Delete reference to container
+  gSimpleContainer = nsnull;
+
+  gtk_main_quit();
+  return TRUE;
+}
+
+
+int main( int argc, char *argv[] )
+{
+  GtkWidget *mainWin = NULL;
+  GtkWidget *vertBox = NULL;
+  GtkWidget *horBox = NULL;
+  GtkWidget *testButton = NULL;
+#if 0 // USE_SUPERWIN
+  GdkSuperWin *termWidget = NULL;
+  GtkWidget *mozArea;
+#else // USE_SUPERWIN 
+  GtkWidget *termWidget = NULL;
+#endif // !USE_SUPERWIN 
+
+  nsIEventQueue *mEventQueue = nsnull;
+
+  nsresult result = NS_OK;
+
+  // Set up registry
+  NS_SetupRegistry();
+
+  // Register XMLTermShell and LineTerm interfaces
+  result = nsComponentManager::RegisterComponentLib(kLineTermCID,NULL,NULL,
+                                           XMLTERM_DLL, PR_FALSE, PR_FALSE);
+  printf("mozGeckoTerm: registered LineTerm, result=0x%x\n", result);
+
+  result = nsComponentManager::RegisterComponentLib(kXMLTermShellCID,NULL,NULL,
+                                           XMLTERM_DLL, PR_FALSE, PR_FALSE);
+  printf("mozGeckoTerm: registered XMLTermShell, result=0x%x\n", result);
+
+  // Get the event queue service 
+  NS_WITH_SERVICE(nsIEventQueueService, eventQService,
+                  kEventQueueServiceCID, &result);
+  if (NS_FAILED(result)) {
+    NS_ASSERTION("Could not obtain event queue service", PR_FALSE);
+    return result;
+  }
+
+  // Get the event queue for the thread.
+  result = eventQService->GetThreadEventQueue(PR_GetCurrentThread(),
+                                              &mEventQueue);
+
+  if (!mEventQueue) {
+    // Create the event queue for the thread
+    result = eventQService->CreateThreadEventQueue();
+    if (NS_FAILED(result)) {
+      NS_ASSERTION("Could not create the thread event queue", PR_FALSE);
+      return result;
+  }
+
+    // Get the event queue for the thread
+    result = eventQService->GetThreadEventQueue(PR_GetCurrentThread(), &mEventQueue);
+    if (NS_FAILED(result)) {
+      NS_ASSERTION("Could not obtain the thread event queue", PR_FALSE);
+      return result;
+    }
+  }
+
+  // Creat pref object
+  nsCOMPtr<nsIPref> mPref = nsnull;
+  result = nsComponentManager::CreateInstance(kPrefCID, NULL, 
+                                             kIPrefIID, getter_AddRefs(mPref));
+  if (NS_FAILED(result)) {
+    NS_ASSERTION("Failed to create nsIPref object", PR_FALSE);
+    return result;
+  }
+
+  mPref->StartUp();
+  mPref->ReadUserPrefs();
+
+  // Initialize GTK library
+  gtk_set_locale();
+
+  gtk_init(&argc, &argv);
+
+  gdk_rgb_init();
+
+  mainWin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_default_size( GTK_WINDOW(mainWin), 600, 400);
+  gtk_window_set_title(GTK_WINDOW(mainWin), "XMLterm");
+
+  // VBox top level
+  vertBox = gtk_vbox_new(FALSE, 0);
+  gtk_container_add(GTK_CONTAINER(mainWin), vertBox);
+  gtk_widget_show(vertBox);
+
+  // HBox for toolbar
+  horBox = gtk_hbox_new(FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(vertBox), horBox, FALSE, FALSE, 0);
+
+  testButton = gtk_button_new_with_label("Test");
+  gtk_box_pack_start (GTK_BOX (horBox), testButton, FALSE, FALSE, 0);
+  gtk_widget_show(testButton);
+
+  gtk_widget_show(horBox);
+
+#if 0 // USE_SUPERWIN
+  gtk_window_set_policy(GTK_WINDOW(mainWin), PR_TRUE, PR_TRUE, PR_FALSE);
+  mozArea = gtk_mozarea_new();
+  gtk_container_add(GTK_CONTAINER(mainWin), mozArea);
+  gtk_widget_realize(GTK_WIDGET(mozArea));
+  termWidget = GTK_MOZAREA(mozArea)->superwin;
+
+#else // USE_SUPERWIN 
+
+  // XMLterm layout widget
+  termWidget = gtk_layout_new(NULL, NULL);
+  GTK_WIDGET_SET_FLAGS(termWidget, GTK_CAN_FOCUS);
+  gtk_widget_set_app_paintable(termWidget, TRUE);
+
+  gtk_box_pack_start(GTK_BOX(vertBox), termWidget, TRUE, TRUE, 0);
+  gtk_widget_show_all(termWidget);
+
+  gtk_widget_show(mainWin);
+#endif // !USE_SUPERWIN 
+
+  // Configure event handler
+  gtk_signal_connect_after( GTK_OBJECT(mainWin), "configure_event",
+                            GTK_SIGNAL_FUNC(event_processor_configure),
+                            termWidget);
+
+  // Cleanup and exit when window is deleted
+  gtk_signal_connect( GTK_OBJECT(mainWin), "delete_event",
+                      GTK_SIGNAL_FUNC(event_processor_quit),
+                      NULL);
+  
+  // Check for input in the events queue file descriptor
+  gdk_input_add(mEventQueue->GetEventQueueSelectFD(),
+                GDK_INPUT_READ,
+                event_processor_callback,
+                mEventQueue);
+
+  // Create simple container
+  result = NS_NewSimpleContainer(getter_AddRefs(gSimpleContainer));
+
+  if (NS_FAILED(result) || !gSimpleContainer) {
+    return result; // Exit main program
+  }
+
+  // Determine window dimensions
+  GtkAllocation *alloc = &GTK_WIDGET(termWidget)->allocation;
+    
+  // Initialize container to hold a web shell
+  result = gSimpleContainer->Init((nsNativeWidget *) termWidget,
+                              alloc->width, alloc->height, mPref);
+
+  if (NS_FAILED(result)) {
+    return result; // Exit main program
+  }
+
+  // Get reference to web shell embedded in a simple container
+  nsCOMPtr<nsIWebShell> webShell;
+  result = gSimpleContainer->GetWebShell(*getter_AddRefs(webShell));
+
+  if (NS_FAILED(result) || !webShell) {
+    return result; // Exit main program
+  }
+
+#if 0
+  // TEMPORARY: Testing mozIXMLTermStream
+  nsAutoString streamData = "<HTML><HEAD><TITLE>Stream Title</TITLE>"
+                            "<SCRIPT language='JavaScript'>"
+                            "function clik(){ dump('click\\n');return(false);}"
+                            "</SCRIPT></HEAD>"
+                            "<BODY><B>Stream Body "
+                            "<SPAN STYLE='color: blue' onClick='return clik();'>Clik</SPAN></B>"
+                            "</BODY></HTML>";
+
+  nsCOMPtr<mozIXMLTermStream> stream;
+  result = NS_NewXMLTermStream(getter_AddRefs(stream));
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to create stream\n");
+    return result;
+  }
+
+  nsCOMPtr<nsIDOMWindow> outerDOMWindow;
+  result = mozXMLTermUtils::ConvertWebShellToDOMWindow(webShell,
+                                              getter_AddRefs(outerDOMWindow));
+
+  if (NS_FAILED(result) || !outerDOMWindow)
+    return NS_ERROR_FAILURE;
+
+  result = stream->Open(outerDOMWindow, nsnull, "chrome://dummy", "text/html",
+                        0);
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to open stream\n");
+    return result;
+  }
+
+  result = stream->Write(streamData.GetUnicode());
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to write to stream\n");
+    return result;
+  }
+
+  result = stream->Close();
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to close stream\n");
+    return result;
+  }
+#else
+  // Load initial XMLterm document
+  result = gSimpleContainer->LoadURL(
+                             "chrome://xmlterm/content/xmlterm.html");
+  if (NS_FAILED(result))
+    return result;
+#endif
+
+#if 0
+  // Create an XMLTERM and attach to web shell
+  result = NS_NewXMLTerminal(getter_AddRefs(gXMLTerminal));
+
+  if(!gXMLTerminal)
+    result = NS_ERROR_OUT_OF_MEMORY;
+
+  if (NS_SUCCEEDED(result)) {
+    result = gXMLTerminal->Init(webShell, nsnull, nsnull);
+  }
+#endif
+
+  // Discard reference to web shell
+  webShell = nsnull;
+
+  // GTK event loop
+  gtk_main();
+
+  NS_IF_RELEASE(mEventQueue);
+
+  return 0;
+}

mozilla/extensions/xmlterm/geckoterm/mozGeckoTerm.cpp.sav

@@ -0,0 +1,318 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozGeckoTerm.cpp: Stand-alone implementation of XMLterm using GTK
+//                   and the Mozilla Layout engine
+
+#include "stdio.h"
+
+#include <gtk/gtk.h>
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsRepository.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIEventQueueService.h"
+#include "nsIPref.h"
+
+#include "mozXMLTermUtils.h"
+#include "mozISimpleContainer.h"
+#include "mozIXMLTerminal.h"
+#include "mozIXMLTermStream.h"
+
+#define XMLTERM_DLL   "libxmlterm"MOZ_DLL_SUFFIX
+
+static NS_DEFINE_IID(kISupportsIID,          NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIEventQueueServiceIID, NS_IEVENTQUEUESERVICE_IID);
+static NS_DEFINE_IID(kEventQueueServiceCID,  NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_IID(kIPrefIID,              NS_IPREF_IID);
+static NS_DEFINE_CID(kPrefCID,               NS_PREF_CID);
+static NS_DEFINE_IID(kLineTermCID,           MOZLINETERM_CID);
+static NS_DEFINE_IID(kXMLTermShellCID,       MOZXMLTERMSHELL_CID);
+
+extern "C" void NS_SetupRegistry();
+
+nsCOMPtr<mozISimpleContainer> gSimpleContainer = nsnull;
+nsCOMPtr<mozIXMLTerminal> gXMLTerminal = nsnull;
+
+/** Processes thread events */
+static void event_processor_callback(gpointer data,
+                                     gint source,
+                                     GdkInputCondition condition)
+{
+  nsIEventQueue *eventQueue = (nsIEventQueue*)data;
+  eventQueue->ProcessPendingEvents();
+  //fprintf(stderr, "event_processor_callback:\n");
+  return;
+}
+
+
+static void event_processor_configure(GtkWidget *window,
+                                      GdkEvent  *event,
+                                      GtkWidget *termWidget)
+{
+  GtkAllocation *alloc = &GTK_WIDGET(termWidget)->allocation;
+
+  //fprintf(stderr, "event_processor_configure:\n");
+
+  // Resize web shell window
+  gSimpleContainer->Resize(alloc->width, alloc->height);
+
+  return;
+}
+
+/** Cleans up and exits */
+static gint event_processor_quit(gpointer data,
+                                 gint source,
+                                 GdkInputCondition condition)
+{
+  fprintf(stderr, "event_processor_quit:\n");
+
+  if (gXMLTerminal) {
+    // Finalize XMLTerm and release owning reference to it
+    gXMLTerminal->Finalize();
+    gXMLTerminal = nsnull;
+  }
+
+  // Delete reference to container
+  gSimpleContainer = nsnull;
+
+  gtk_main_quit();
+  return TRUE;
+}
+
+
+int main( int argc, char *argv[] )
+{
+  GtkWidget *mainWin = NULL;
+  GtkWidget *vertBox = NULL;
+  GtkWidget *horBox = NULL;
+  GtkWidget *testButton = NULL;
+  GtkWidget *termWidget = NULL;
+
+  nsIEventQueue *mEventQueue = nsnull;
+
+  nsresult result = NS_OK;
+
+  // Set up registry
+  NS_SetupRegistry();
+
+  // Register XMLTermShell and LineTerm interfaces
+  result = nsComponentManager::RegisterComponentLib(kLineTermCID,NULL,NULL,
+                                           XMLTERM_DLL, PR_FALSE, PR_FALSE);
+  printf("mozGeckoTerm: registered LineTerm, result=0x%x\n", result);
+
+  result = nsComponentManager::RegisterComponentLib(kXMLTermShellCID,NULL,NULL,
+                                           XMLTERM_DLL, PR_FALSE, PR_FALSE);
+  printf("mozGeckoTerm: registered XMLTermShell, result=0x%x\n", result);
+
+  // Get the event queue service 
+  NS_WITH_SERVICE(nsIEventQueueService, eventQService,
+                  kEventQueueServiceCID, &result);
+  if (NS_FAILED(result)) {
+    NS_ASSERTION("Could not obtain event queue service", PR_FALSE);
+    return result;
+  }
+
+  // Get the event queue for the thread.
+  result = eventQService->GetThreadEventQueue(PR_GetCurrentThread(),
+                                              &mEventQueue);
+
+  if (!mEventQueue) {
+    // Create the event queue for the thread
+    result = eventQService->CreateThreadEventQueue();
+    if (NS_FAILED(result)) {
+      NS_ASSERTION("Could not create the thread event queue", PR_FALSE);
+      return result;
+  }
+
+    // Get the event queue for the thread
+    result = eventQService->GetThreadEventQueue(PR_GetCurrentThread(), &mEventQueue);
+    if (NS_FAILED(result)) {
+      NS_ASSERTION("Could not obtain the thread event queue", PR_FALSE);
+      return result;
+    }
+  }
+
+  // Creat pref object
+  nsCOMPtr<nsIPref> mPref = nsnull;
+  result = nsComponentManager::CreateInstance(kPrefCID, NULL, 
+                                             kIPrefIID, getter_AddRefs(mPref));
+  if (NS_FAILED(result)) {
+    NS_ASSERTION("Failed to create nsIPref object", PR_FALSE);
+    return result;
+  }
+
+  mPref->StartUp();
+  mPref->ReadUserPrefs();
+
+  // Initialize GTK library
+  gtk_set_locale();
+
+  gtk_init(&argc, &argv);
+
+  gdk_rgb_init();
+
+  mainWin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_default_size( GTK_WINDOW(mainWin), 600, 400);
+  gtk_window_set_title(GTK_WINDOW(mainWin), "XMLterm");
+  
+  // VBox top level
+  vertBox = gtk_vbox_new(FALSE, 0);
+  gtk_container_add(GTK_CONTAINER(mainWin), vertBox);
+  gtk_widget_show(vertBox);
+
+  // HBox for toolbar
+  horBox = gtk_hbox_new(FALSE, 0);
+  gtk_box_pack_start(GTK_BOX(vertBox), horBox, FALSE, FALSE, 0);
+
+  testButton = gtk_button_new_with_label("Test");
+  gtk_box_pack_start (GTK_BOX (horBox), testButton, FALSE, FALSE, 0);
+  gtk_widget_show(testButton);
+
+  gtk_widget_show(horBox);
+
+  // XMLterm layout widget
+  termWidget = gtk_layout_new(NULL, NULL);
+  GTK_WIDGET_SET_FLAGS(termWidget, GTK_CAN_FOCUS);
+  gtk_widget_set_app_paintable(termWidget, TRUE);
+
+  gtk_box_pack_start(GTK_BOX(vertBox), termWidget, TRUE, TRUE, 0);
+  gtk_widget_show_all(termWidget);
+
+  gtk_widget_show(mainWin);
+
+
+  // Configure event handler
+  gtk_signal_connect_after( GTK_OBJECT(mainWin), "configure_event",
+                            GTK_SIGNAL_FUNC(event_processor_configure),
+                            termWidget);
+
+  // Cleanup and exit when window is deleted
+  gtk_signal_connect( GTK_OBJECT(mainWin), "delete_event",
+                      GTK_SIGNAL_FUNC(event_processor_quit),
+                      NULL);
+  
+  // Check for input in the events queue file descriptor
+  gdk_input_add(mEventQueue->GetEventQueueSelectFD(),
+                GDK_INPUT_READ,
+                event_processor_callback,
+                mEventQueue);
+
+  // Create simple container
+  result = NS_NewSimpleContainer(getter_AddRefs(gSimpleContainer));
+
+  if (NS_FAILED(result) || !gSimpleContainer) {
+    return result; // Exit main program
+  }
+
+  // Determine window dimensions
+  GtkAllocation *alloc = &GTK_WIDGET(termWidget)->allocation;
+    
+  // Initialize container it to hold a web shell
+  result = gSimpleContainer->Init((nsNativeWidget *) termWidget,
+                              alloc->width, alloc->height, mPref);
+
+  if (NS_FAILED(result)) {
+    return result; // Exit main program
+  }
+
+  // Get reference to web shell embedded in a simple container
+  nsCOMPtr<nsIWebShell> webShell;
+  result = gSimpleContainer->GetWebShell(*getter_AddRefs(webShell));
+
+  if (NS_FAILED(result) || !webShell) {
+    return result; // Exit main program
+  }
+
+#if 0
+  // TEMPORARY: Testing mozIXMLTermStream
+  nsAutoString streamData = "<HTML><HEAD><TITLE>Stream Title</TITLE>"
+                            "<SCRIPT language='JavaScript'>"
+                            "function clik(){ dump('click\\n');return(false);}"
+                            "</SCRIPT></HEAD>"
+                            "<BODY><B>Stream Body "
+                            "<SPAN STYLE='color: blue' onClick='return clik();'>Clik</SPAN></B>"
+                            "</BODY></HTML>";
+
+  nsCOMPtr<mozIXMLTermStream> stream;
+  result = NS_NewXMLTermStream(getter_AddRefs(stream));
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to create stream\n");
+    return result;
+  }
+
+  nsCOMPtr<nsIDOMWindow> outerDOMWindow;
+  result = mozXMLTermUtils::ConvertWebShellToDOMWindow(webShell,
+                                              getter_AddRefs(outerDOMWindow));
+
+  if (NS_FAILED(result) || !outerDOMWindow)
+    return NS_ERROR_FAILURE;
+
+  result = stream->Open(outerDOMWindow, nsnull, "chrome://dummy", "text/html",
+                        0);
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to open stream\n");
+    return result;
+  }
+
+  result = stream->Write(streamData.GetUnicode());
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to write to stream\n");
+    return result;
+  }
+
+  result = stream->Close();
+  if (NS_FAILED(result)) {
+    fprintf(stderr, "mozGeckoTerm: Failed to close stream\n");
+    return result;
+  }
+#else
+  // Load initial XMLterm document
+  result = gSimpleContainer->LoadURL(
+                             "chrome://xmlterm/content/xmlterm.html");
+  if (NS_FAILED(result))
+    return result;
+#endif
+
+#if 0
+  // Create an XMLTERM and attach to web shell
+  result = NS_NewXMLTerminal(getter_AddRefs(gXMLTerminal));
+
+  if(!gXMLTerminal)
+    result = NS_ERROR_OUT_OF_MEMORY;
+
+  if (NS_SUCCEEDED(result)) {
+    result = gXMLTerminal->Init(webShell, nsnull, nsnull);
+  }
+#endif
+
+  // Discard reference to web shell
+  webShell = nsnull;
+
+  // GTK event loop
+  gtk_main();
+
+  NS_IF_RELEASE(mEventQueue);
+
+  return 0;
+}

mozilla/extensions/xmlterm/geckoterm/mozISimpleContainer.h

@@ -0,0 +1,134 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozISimpleContainer.h: a simple WebShell container interface
+//                        for use in simple programs using the layout engine
+//                        (unregistered interface)
+
+#ifndef mozISimpleContainer_h___
+#define mozISimpleContainer_h___
+
+#include "nscore.h"
+
+#include "nsISupports.h"
+#include "nsIWebShell.h"
+#include "nsIPref.h"
+#include "nsIPresShell.h"
+#include "nsIDOMDocument.h"
+
+/* starting interface: mozISimpleContainer */
+
+/* {0eb82bF0-43a2-11d3-8e76-006008948af5} */
+#define MOZISIMPLE_CONTAINER_IID_STR "0eb82bF0-43a2-11d3-8e76-006008948af5"
+#define MOZISIMPLE_CONTAINER_IID \
+  {0x0eb82bF0, 0x43a2, 0x11d3, \
+    { 0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5 }}
+
+class mozISimpleContainer : public nsIWebShellContainer {
+
+public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(MOZISIMPLE_CONTAINER_IID)
+
+  // nsIWebShellContainer interface
+  NS_IMETHOD WillLoadURL(nsIWebShell* aShell,
+                         const PRUnichar* aURL,
+                         nsLoadType aReason) = 0;
+ 
+  NS_IMETHOD BeginLoadURL(nsIWebShell* aShell,
+                          const PRUnichar* aURL) = 0;
+ 
+
+  NS_IMETHOD ProgressLoadURL(nsIWebShell* aShell,
+                             const PRUnichar* aURL,
+                             PRInt32 aProgress,
+                             PRInt32 aProgressMax) = 0;
+ 
+  NS_IMETHOD EndLoadURL(nsIWebShell* aShell,
+                        const PRUnichar* aURL,
+                        nsresult aStatus) = 0;
+ 
+  NS_IMETHOD NewWebShell(PRUint32 aChromeMask,
+                         PRBool aVisible,
+                         nsIWebShell *&aNewWebShell) = 0;
+  
+  NS_IMETHOD FindWebShellWithName(const PRUnichar* aName,
+                                  nsIWebShell*& aResult) = 0;
+  
+  NS_IMETHOD ContentShellAdded(nsIWebShell* aChildShell,
+                               nsIContent* frameNode) = 0;
+
+  NS_IMETHOD CreatePopup(nsIDOMElement* aElement,
+                         nsIDOMElement* aPopupContent, 
+                         PRInt32 aXPos, PRInt32 aYPos, 
+                         const nsString& aPopupType,
+                         const nsString& anAnchorAlignment,
+                         const nsString& aPopupAlignment,
+                         nsIDOMWindow* aWindow, nsIDOMWindow** outPopup) = 0;
+
+  NS_IMETHOD FocusAvailable(nsIWebShell* aFocusedWebShell,
+                            PRBool& aFocusTaken) = 0;
+
+  // other
+
+  /** Initializes simple container for native window widget
+   * @param aNativeWidget native window widget (e.g., GtkWidget)
+   * @param width window width (pixels)
+   * @param height window height (pixels)
+   * @param aPref preferences object
+   */
+  NS_IMETHOD Init(nsNativeWidget aNativeWidget,
+                  PRInt32 width, PRInt32 height,
+                  nsIPref* aPref) = 0;
+
+  /** Resizes container to new dimensions
+   * @param width new window width (pixels)
+   * @param height new window height (pixels)
+   */
+  NS_IMETHOD Resize(PRInt32 aWidth, PRInt32 aHeight) = 0;
+
+  /** Loads specified URL into container
+   * @param aURL URL string
+   */
+  NS_IMETHOD LoadURL(const char* aURL) = 0;
+
+  /** Gets web shell in container
+   * @param aWebShell (output) web shell object
+   */
+  NS_IMETHOD GetWebShell(nsIWebShell*& aWebShell) = 0;
+
+  /** Gets DOM document in container
+   * @param aDocument (output) DOM document
+   */
+  NS_IMETHOD GetDocument(nsIDOMDocument*& aDocument) = 0;
+
+  /** Gets presentation shell associated with container
+   * @param aPresShell (output) presentation shell
+   */
+  NS_IMETHOD GetPresShell(nsIPresShell*& aPresShell) = 0;
+};
+
+#define MOZSIMPLE_CONTAINER_CID              \
+{ /* 0eb82bF1-43a2-11d3-8e76-006008948af5 */ \
+   0x0eb82bF1, 0x43a2, 0x11d3,               \
+{0x8e, 0x76, 0x00, 0x60, 0x08, 0x94, 0x8a, 0xf5} }
+extern nsresult
+NS_NewSimpleContainer(mozISimpleContainer** aSimpleContainer);
+
+#endif /* mozISimpleContainer_h___ */

mozilla/extensions/xmlterm/geckoterm/mozSimpleContainer.cpp

@@ -0,0 +1,396 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozSimpleContainer.cpp: Implements mozISimpleContainer
+// which provides a WebShell container for use in simple programs
+// using the layout engine
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsRepository.h"
+
+#include "nsISupports.h"
+
+#include "nsIWebShell.h"
+#include "nsIDOMDocument.h"
+#include "nsIDocumentViewer.h"
+#include "nsIPresContext.h"
+#include "nsIPresShell.h"
+#include "nsIDocument.h"
+
+#include "mozSimpleContainer.h"
+
+
+// Define Class IDs
+static NS_DEFINE_IID(kWebShellCID,           NS_WEB_SHELL_CID);
+
+// Define Interface IDs
+static NS_DEFINE_IID(kISupportsIID,          NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kIWebShellIID,          NS_IWEB_SHELL_IID);
+static NS_DEFINE_IID(kIDOMDocumentIID,       NS_IDOMDOCUMENT_IID);
+static NS_DEFINE_IID(kIDocumentViewerIID,    NS_IDOCUMENT_VIEWER_IID);
+
+/////////////////////////////////////////////////////////////////////////
+// mozSimpleContainer factory
+/////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewSimpleContainer(mozISimpleContainer** aSimpleContainer)
+{
+    NS_PRECONDITION(aSimpleContainer != nsnull, "null ptr");
+    if (!aSimpleContainer)
+        return NS_ERROR_NULL_POINTER;
+
+    *aSimpleContainer = new mozSimpleContainer();
+    if (! *aSimpleContainer)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(*aSimpleContainer);
+    return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////
+// mozSimpleContainer implementation
+/////////////////////////////////////////////////////////////////////////
+
+mozSimpleContainer::mozSimpleContainer() :
+  mWebShell(nsnull)
+{
+  NS_INIT_REFCNT();
+}
+
+
+mozSimpleContainer::~mozSimpleContainer()
+{
+  mWebShell = nsnull;
+}
+
+#define NS_IMPL_ADDREF_TRACE(_class)                         \
+NS_IMETHODIMP_(nsrefcnt) _class::AddRef(void)                \
+{                                                            \
+  NS_PRECONDITION(PRInt32(mRefCnt) >= 0, "illegal refcnt");  \
+  ++mRefCnt;                                                 \
+  fprintf(stderr, "mozSimpleContainer:AddRef, mRefCnt=%d\n", mRefCnt);   \
+  return mRefCnt;                                            \
+}
+
+#define NS_IMPL_RELEASE_TRACE(_class)                  \
+NS_IMETHODIMP_(nsrefcnt) _class::Release(void)         \
+{                                                      \
+  NS_PRECONDITION(0 != mRefCnt, "dup release");        \
+  --mRefCnt;                                           \
+  fprintf(stderr, "mozSimpleContainer:Release, mRefCnt=%d\n", mRefCnt); \
+  if (mRefCnt == 0) {                                  \
+    NS_DELETEXPCOM(this);                              \
+    return 0;                                          \
+  }                                                    \
+  return mRefCnt;                                      \
+}
+
+// Implement AddRef and Release
+NS_IMPL_ADDREF(mozSimpleContainer)
+NS_IMPL_RELEASE(mozSimpleContainer)
+
+
+NS_IMETHODIMP 
+mozSimpleContainer::QueryInterface(REFNSIID aIID,void** aInstancePtr)
+{
+  if (aInstancePtr == NULL) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  // Always NULL result, in case of failure
+  *aInstancePtr = NULL;
+
+  if ( aIID.Equals(kISupportsIID)) {
+    *aInstancePtr = NS_STATIC_CAST(nsISupports*,
+                                   NS_STATIC_CAST(mozISimpleContainer*,this));
+
+  } else if ( aIID.Equals(mozISimpleContainer::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(mozISimpleContainer*,this);
+
+  } else if ( aIID.Equals(nsIWebShellContainer::GetIID()) ) {
+    *aInstancePtr = NS_STATIC_CAST(nsIWebShellContainer*,this);
+
+  } else {
+    return NS_ERROR_NO_INTERFACE;
+  }
+
+  NS_ADDREF_THIS();
+
+  fprintf(stderr, "mozSimpleContainer::QueryInterface, mRefCnt = %d\n", mRefCnt);
+
+  return NS_OK;
+}
+
+
+/** Initializes simple container for native window widget
+ * @param aNativeWidget native window widget (e.g., GtkWidget)
+ * @param width window width (pixels)
+ * @param height window height (pixels)
+ * @param aPref preferences object
+ */
+NS_IMETHODIMP mozSimpleContainer::Init(nsNativeWidget aNativeWidget,
+                                       PRInt32 width, PRInt32 height,
+                                       nsIPref* aPref)
+{
+  // Create web shell and show it
+  nsresult result = nsRepository::CreateInstance(kWebShellCID, nsnull,
+                                                 kIWebShellIID,
+                                                 getter_AddRefs(mWebShell));
+
+  if (NS_FAILED(result) || !mWebShell) {
+    fprintf(stderr, "Failed to create create web shell\n");
+    return NS_ERROR_FAILURE;
+  }
+  
+  mWebShell->Init(aNativeWidget, 0, 0, width, height);
+
+  mWebShell->SetContainer(this);
+  if (aPref) {
+    mWebShell->SetPrefs(aPref);
+  }
+  mWebShell->Show();
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::WillLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, nsLoadType aReason)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::BeginLoadURL(nsIWebShell* aShell, const PRUnichar* aURL)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::ProgressLoadURL(nsIWebShell* aShell,
+          const PRUnichar* aURL, PRInt32 aProgress, PRInt32 aProgressMax)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::EndLoadURL(nsIWebShell* aShell,
+                                             const PRUnichar* aURL,
+                                             nsresult aStatus)
+{
+  nsCOMPtr<nsIDOMSelection> selection;
+  nsresult result;
+
+  if (aShell == mWebShell.get()) {
+    nsCOMPtr<nsIDOMDocument> domDoc;
+    nsCOMPtr<nsIPresShell> presShell;
+
+    result = GetDocument(*getter_AddRefs(domDoc));
+    if (NS_FAILED(result) || !domDoc) return result;
+
+    result = GetPresShell(*getter_AddRefs(presShell));
+    if (NS_FAILED(result) || !presShell) return result;
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::NewWebShell(PRUint32 aChromeMask,
+                                              PRBool aVisible,
+                                              nsIWebShell*& aNewWebShell)
+{
+  aNewWebShell = nsnull;
+  return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP mozSimpleContainer::FindWebShellWithName(const PRUnichar* aName,
+                                                       nsIWebShell*& aResult)
+{
+  aResult = nsnull;
+  nsString aNameStr(aName);
+
+  nsIWebShell *aWebShell;
+    
+  if (NS_OK == GetWebShell(aWebShell)) {
+    const PRUnichar *name;
+    if (NS_OK == aWebShell->GetName(&name)) {
+      if (aNameStr.Equals(name)) {
+        aResult = aWebShell;
+        NS_ADDREF(aResult);
+        return NS_OK;
+      }
+    }      
+  }
+
+  if (NS_OK == aWebShell->FindChildWithName(aName, aResult)) {
+    if (nsnull != aResult) {
+      return NS_OK;
+    }
+  }
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozSimpleContainer::ContentShellAdded(nsIWebShell* aChildShell,
+                                  nsIContent* frameNode)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozSimpleContainer::CreatePopup(nsIDOMElement* aElement, 
+                            nsIDOMElement* aPopupContent, 
+                            PRInt32 aXPos, PRInt32 aYPos, 
+                            const nsString& aPopupType,
+                            const nsString& anAnchorAlignment,
+                            const nsString& aPopupAlignment,
+                            nsIDOMWindow* aWindow, nsIDOMWindow** outPopup)
+{
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+mozSimpleContainer::FocusAvailable(nsIWebShell* aFocusedWebShell,
+                                   PRBool& aFocusTaken)
+{
+  return NS_OK;
+}
+
+
+/** Resizes container to new dimensions
+ * @param width new window width (pixels)
+ * @param height new window height (pixels)
+ */
+NS_IMETHODIMP mozSimpleContainer::Resize(PRInt32 aWidth, PRInt32 aHeight)
+{
+  if (!mWebShell) return NS_ERROR_FAILURE;
+
+  mWebShell->SetBounds(0, 0, aWidth, aHeight);
+  return NS_OK;
+}
+
+
+/** Loads specified URL into container
+ * @param aURL URL string
+ */
+NS_IMETHODIMP mozSimpleContainer::LoadURL(const char* aURL)
+{
+  if (!mWebShell) return NS_ERROR_FAILURE;
+
+  nsString aStr(aURL);
+  mWebShell->LoadURL(aStr.GetUnicode());
+  return NS_OK;
+}
+
+
+/** Gets web shell in container
+ * @param aWebShell (output) web shell object
+ */
+NS_IMETHODIMP mozSimpleContainer::GetWebShell(nsIWebShell*& aWebShell)
+{
+  aWebShell = mWebShell.get();
+  NS_IF_ADDREF(aWebShell);      // Add ref'ed; needs to be released
+  return NS_OK;
+}
+
+
+/** Gets DOM document in container
+ * @param aDocument (output) DOM document
+ */
+NS_IMETHODIMP mozSimpleContainer::GetDocument(nsIDOMDocument*& aDocument)
+{
+
+  aDocument = nsnull;
+
+  if (mWebShell) {
+    nsIContentViewer* contViewer;
+    mWebShell->GetContentViewer(&contViewer);
+
+    if (nsnull != contViewer) {
+      nsIDocumentViewer* docViewer;
+      if (NS_OK == contViewer->QueryInterface(kIDocumentViewerIID,
+                                            (void**) &docViewer)) 
+      {
+        nsIDocument* vDoc;
+        docViewer->GetDocument(vDoc);
+
+        if (nsnull != vDoc) {
+          nsIDOMDocument* vDOMDoc;
+          if (NS_OK == vDoc->QueryInterface(kIDOMDocumentIID,
+                                            (void**) &vDOMDoc)) 
+            {
+              aDocument = vDOMDoc; // Add ref'ed; needs to be released
+            }
+          NS_RELEASE(vDoc);
+        }
+
+        NS_RELEASE(docViewer);
+      }
+
+      NS_RELEASE(contViewer);
+    }
+  }
+  return NS_OK;
+}
+
+
+/** Gets presentation shell associated with container
+ * @param aPresShell (output) presentation shell
+ */
+NS_IMETHODIMP mozSimpleContainer::GetPresShell(nsIPresShell*& aPresShell)
+{
+  aPresShell = nsnull;
+
+  nsIPresShell* presShell = nsnull;
+
+  if (mWebShell) {
+    nsIContentViewer* contViewer = nsnull;
+    mWebShell->GetContentViewer(&contViewer);
+
+    if (nsnull != contViewer) {
+      nsIDocumentViewer* docViewer = nsnull;
+      contViewer->QueryInterface(kIDocumentViewerIID, (void**) &docViewer);
+
+      if (nsnull != docViewer) {
+        nsIPresContext* presContext;
+        docViewer->GetPresContext(presContext);
+
+        if (nsnull != presContext) {
+          presContext->GetShell(&presShell);  // Add ref'ed
+          aPresShell = presShell;
+          NS_RELEASE(presContext);
+        }
+
+        NS_RELEASE(docViewer);
+      }
+
+      NS_RELEASE(contViewer);
+    }
+  }
+  return NS_OK;
+}

mozilla/extensions/xmlterm/geckoterm/mozSimpleContainer.h

@@ -0,0 +1,100 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is XMLterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ */
+
+// mozSimpleContainer.h: declaration of mozSimpleContainer class
+// implementing mozISimpleContainer,
+// which provides a WebShell container for use in simple programs
+// using the layout engine
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "mozISimpleContainer.h"
+
+class mozSimpleContainer : public mozISimpleContainer {
+
+public:
+
+  mozSimpleContainer();
+  virtual ~mozSimpleContainer();
+
+  // nsISupports
+  NS_DECL_ISUPPORTS
+
+  // nsIWebShellContainer interface
+  NS_IMETHOD WillLoadURL(nsIWebShell* aShell,
+                         const PRUnichar* aURL,
+                         nsLoadType aReason);
+ 
+  NS_IMETHOD BeginLoadURL(nsIWebShell* aShell,
+                          const PRUnichar* aURL);
+ 
+
+  NS_IMETHOD ProgressLoadURL(nsIWebShell* aShell,
+                             const PRUnichar* aURL,
+                             PRInt32 aProgress,
+                             PRInt32 aProgressMax);
+ 
+  NS_IMETHOD EndLoadURL(nsIWebShell* aShell,
+                        const PRUnichar* aURL,
+                        nsresult aStatus);
+ 
+  NS_IMETHOD NewWebShell(PRUint32 aChromeMask,
+                         PRBool aVisible,
+                         nsIWebShell *&aNewWebShell);
+  
+  NS_IMETHOD FindWebShellWithName(const PRUnichar* aName,
+                                  nsIWebShell*& aResult);
+  
+  NS_IMETHOD ContentShellAdded(nsIWebShell* aChildShell,
+                               nsIContent* frameNode);
+
+  NS_IMETHOD CreatePopup(nsIDOMElement* aElement,
+                         nsIDOMElement* aPopupContent, 
+                         PRInt32 aXPos, PRInt32 aYPos, 
+                         const nsString& aPopupType,
+                         const nsString& anAnchorAlignment,
+                         const nsString& aPopupAlignment,
+                         nsIDOMWindow* aWindow, nsIDOMWindow** outPopup);
+
+  NS_IMETHOD FocusAvailable(nsIWebShell* aFocusedWebShell,
+                            PRBool& aFocusTaken);
+
+  // other
+  NS_IMETHOD Init(nsNativeWidget aNativeWidget,
+                  PRInt32 width, PRInt32 height,
+                  nsIPref* aPref);
+
+  NS_IMETHOD Resize(PRInt32 aWidth, PRInt32 aHeight);
+
+  NS_IMETHOD LoadURL(const char* aURL);
+
+  NS_IMETHOD GetWebShell(nsIWebShell*& aWebShell);
+
+  NS_IMETHOD GetDocument(nsIDOMDocument*& aDocument);
+
+  NS_IMETHOD GetPresShell(nsIPresShell*& aPresShell);
+
+protected:
+
+  /** owning reference to web shell created by us */
+  nsCOMPtr<nsIWebShell> mWebShell;
+
+};

mozilla/extensions/xmlterm/geckoterm/nsSetupRegistry.cpp

@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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/NPL/
+ *
+ * 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.
+ *
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are Copyright (C) 1998
+ * Netscape Communications Corporation.  All Rights Reserved.
+ */
+
+// nsSetupRegistry.cpp: Just a copy of viewer's nSetupRegistry
+
+#include "../../../webshell/tests/viewer/nsSetupRegistry.cpp"
+

mozilla/extensions/xmlterm/geckoterm/nsTimer.cpp

@@ -0,0 +1,198 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+#include "nsITimer.h"
+#include "nsITimerCallback.h"
+#include "nsCRT.h"
+#include "prlog.h"
+#include <stdio.h>
+#include <limits.h>
+#include <gtk/gtk.h>
+
+static NS_DEFINE_IID(kITimerIID, NS_ITIMER_IID);
+
+extern "C" gint nsTimerExpired(gpointer aCallData);
+
+/*
+ * Implementation of timers using Gtk timer facility 
+ */
+class TimerImpl : public nsITimer {
+public:
+
+public:
+  TimerImpl();
+  virtual ~TimerImpl();
+
+  virtual nsresult Init(nsTimerCallbackFunc aFunc,
+                void *aClosure,
+//              PRBool aRepeat, 
+                PRUint32 aDelay);
+
+  virtual nsresult Init(nsITimerCallback *aCallback,
+//              PRBool aRepeat, 
+                PRUint32 aDelay);
+
+  NS_DECL_ISUPPORTS
+
+  virtual void Cancel();
+  virtual PRUint32 GetDelay() { return mDelay; }
+  virtual void SetDelay(PRUint32 aDelay) { mDelay=aDelay; };
+  virtual void* GetClosure() { return mClosure; }
+
+  void FireTimeout();
+
+private:
+  nsresult Init(PRUint32 aDelay);
+
+  PRUint32 mDelay;
+  nsTimerCallbackFunc mFunc;
+  void *mClosure;
+  nsITimerCallback *mCallback;
+  // PRBool mRepeat;
+  TimerImpl *mNext;
+  guint mTimerId;
+};
+
+void TimerImpl::FireTimeout()
+{
+  if (mFunc != NULL) {
+    (*mFunc)(this, mClosure);
+  }
+  else if (mCallback != NULL) {
+    mCallback->Notify(this); // Fire the timer
+  }
+
+// Always repeating here
+
+// if (mRepeat)
+//  mTimerId = gtk_timeout_add(aDelay, nsTimerExpired, this);
+}
+
+
+TimerImpl::TimerImpl()
+{
+  //  printf("TimerImple::TimerImpl called for %p\n", this);
+  NS_INIT_REFCNT();
+  mFunc = NULL;
+  mCallback = NULL;
+  mNext = NULL;
+  mTimerId = 0;
+  mDelay = 0;
+  mClosure = NULL;
+}
+
+TimerImpl::~TimerImpl()
+{
+  //printf("TimerImpl::~TimerImpl called for %p\n", this);
+  Cancel();
+  NS_IF_RELEASE(mCallback);
+}
+
+nsresult 
+TimerImpl::Init(nsTimerCallbackFunc aFunc,
+                void *aClosure,
+//              PRBool aRepeat, 
+                PRUint32 aDelay)
+{
+  //printf("TimerImpl::Init called with func + closure for %p\n", this);
+    mFunc = aFunc;
+    mClosure = aClosure;
+    // mRepeat = aRepeat;
+
+// This is ancient debug code that is making it impossible to have timeouts
+// greater than 10 seconds. -re
+
+//   if ((aDelay > 10000) || (aDelay < 0)) {
+//     printf("Timer::Init() called with bogus value \"%d\"!  Not enabling timer.\n",
+//            aDelay);
+//     return Init(aDelay);
+//   }
+
+    mTimerId = gtk_timeout_add(aDelay, nsTimerExpired, this);
+
+    return Init(aDelay);
+}
+
+nsresult 
+TimerImpl::Init(nsITimerCallback *aCallback,
+//              PRBool aRepeat, 
+                PRUint32 aDelay)
+{
+  //printf("TimerImpl::Init called with callback only for %p\n", this);
+    mCallback = aCallback;
+    NS_ADDREF(mCallback);
+    // mRepeat = aRepeat;
+
+// This is ancient debug code that is making it impossible to have timeouts
+// greater than 10 seconds. -re
+
+//   if ((aDelay > 10000) || (aDelay < 0)) {
+//     printf("Timer::Init() called with bogus value \"%d\"!  Not enabling timer.\n",
+//            aDelay);
+//     return Init(aDelay);
+//   }
+
+    mTimerId = gtk_timeout_add(aDelay, nsTimerExpired, this);
+
+    return Init(aDelay);
+}
+
+nsresult
+TimerImpl::Init(PRUint32 aDelay)
+{
+  //printf("TimerImpl::Init called with delay %d only for %p\n", aDelay, this);
+
+    mDelay = aDelay;
+    //    NS_ADDREF(this);
+
+    return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(TimerImpl, kITimerIID)
+
+
+void
+TimerImpl::Cancel()
+{
+  //printf("TimerImpl::Cancel called for %p\n", this);
+  TimerImpl *me = this;
+  if (mTimerId)
+    gtk_timeout_remove(mTimerId);
+}
+
+NS_GFXNONXP nsresult NS_NewTimer(nsITimer** aInstancePtrResult)
+{
+    NS_PRECONDITION(nsnull != aInstancePtrResult, "null ptr");
+    if (nsnull == aInstancePtrResult) {
+      return NS_ERROR_NULL_POINTER;
+    }  
+
+    TimerImpl *timer = new TimerImpl();
+    if (nsnull == timer) {
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    return timer->QueryInterface(kITimerIID, (void **) aInstancePtrResult);
+}
+
+gint nsTimerExpired(gpointer aCallData)
+{
+  //printf("nsTimerExpired for %p\n", aCallData);
+  TimerImpl* timer = (TimerImpl *)aCallData;
+  timer->FireTimeout();
+  return 0;
+}

mozilla/extensions/xmlterm/geckoterm/remake

@@ -0,0 +1,8 @@
+#!/bin/csh
+
+set echo
+
+cd ../base
+make
+cd ../geckoterm
+rm xmlterm; make xmlterm

mozilla/extensions/xmlterm/linetest/Makefile.in

@@ -0,0 +1,65 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/linetest directory
+
+ifdef STAND_ALONE
+DEPTH      = ..
+topsrcdir  = ..
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../..
+topsrcdir  = @top_srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+
+# Debug option
+DEBUG = 1
+
+# Program
+SIMPLE_PROGRAMS = lterm ptytest testunistr
+
+# Defines
+DEFINES =
+
+# Libraries to be linked
+LIBS = -lncurses -lxmlterm -lpthread
+
+include $(topsrcdir)/config/config.mk
+
+include ../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlterm/linetest/README

@@ -0,0 +1 @@
+linetest --- Test programs (for LineTerm only)

mozilla/extensions/xmlterm/linetest/lterm.c

@@ -0,0 +1,557 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* lterm.c: Test driver for LINETERM using NCURSES
+ * CPP options:
+ *   LINUX:   for Linux2.0/glibc
+ *   SOLARIS: for Solaris2.6
+ */
+
+#include <stdio.h>
+#include <signal.h>
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <termios.h>
+
+#include <assert.h>
+
+#include "curses.h"
+
+#define _REENTRANT
+#include <pthread.h>
+
+#ifdef SOLARIS
+#include <stropts.h>
+#include <poll.h>
+#endif
+
+#ifdef LINUX
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+typedef unsigned int nfds_t;
+#endif
+
+#include "lineterm.h"
+#include "tracelog.h"
+
+#define MAXPROMPT 256          /* Maximum length of prompt regexp */
+#define MAXCOL 4096            /* Maximum columns in line buffer */
+
+/* (0,0) is upper lefthand corner of window */
+
+/* Character attributes
+        A_NORMAL        Normal display (no highlight)
+        A_STANDOUT      Best highlighting mode of the terminal.
+        A_UNDERLINE     Underlining
+        A_REVERSE       Reverse video
+        A_BLINK         Blinking
+        A_DIM           Half bright
+        A_BOLD          Extra bright or bold
+        A_PROTECT       Protected mode
+        A_INVIS         Invisible or blank mode
+        A_ALTCHARSET    Alternate character set
+        A_CHARTEXT      Bit-mask to extract a character
+        COLOR_PAIR(n)   Color-pair number n
+*/
+
+/* GLOBAL VARIABLES */
+static int lineFlag = 0;
+static int ptyFlag = 1;
+static int debugFlag = 0;
+static int ltermNumber = -1;
+static SCREEN  *termScreen = NULL;
+static char *ttyDevice;
+static char *errDevice;
+
+static struct termios tios;    /* TERMIOS structure */
+
+static void finish(int sig);
+static pthread_t output_handler_thread_ID;
+
+static void *output_handler(void *arg);
+
+static void input_handler(int *plterm);
+
+int main(int argc, char *argv[]) {
+  FILE *inFile, *outFile;
+  UNICHAR uregexp[MAXPROMPT+1];
+  int argNo, options, processType, retValue;
+  int remaining, decoded;
+  int messageLevel;
+  char *promptStr;
+  char **commandArgs;
+  char *defaultCommand[] = {(char *)getenv("SHELL"), "-i", NULL};
+
+  /* Process command line arguments */
+  lineFlag = 0;
+  ptyFlag = 1;
+  debugFlag = 0;
+  processType = LTERM_DETERMINE_PROCESS;
+  ttyDevice = NULL;
+  errDevice = NULL;
+  promptStr = "#$%>?";  /* JUST A LIST OF DELIMITERS AT PRESENT */
+
+  lineFlag = 1;         /* Temporary */
+
+  argNo = 1;
+  while (argNo < argc) {
+
+    if ((strcmp(argv[argNo],"-h") == 0)||(strcmp(argv[argNo],"-help") == 0)) {
+      fprintf(stderr, "Usage: %s [-help] [-line] [-nopty] [-debug] [-tcsh / -bash] [-tty /dev/ttyname] [-err /dev/ttyname] [-prompt <prompt>] <command> ...\n", argv[0]);
+      exit(0);
+
+    } else if (strcmp(argv[argNo],"-line") == 0) {
+      lineFlag = 1;
+      argNo++;
+
+    } else if (strcmp(argv[argNo],"-nopty") == 0) {
+      ptyFlag = 0;
+      argNo++;
+
+    } else if (strcmp(argv[argNo],"-debug") == 0) {
+      debugFlag = 1;
+      argNo++;
+
+    } else if (strcmp(argv[argNo],"-bash") == 0) {
+      processType = LTERM_BASH_PROCESS;
+      argNo++;
+
+    } else if (strcmp(argv[argNo],"-tcsh") == 0) {
+      processType = LTERM_TCSH_PROCESS;
+      argNo++;
+
+    } else if (strcmp(argv[argNo],"-tty") == 0) {
+      argNo++;
+      if (argNo < argc) {
+        ttyDevice = argv[argNo];
+        argNo++;
+      }
+
+    } else if (strcmp(argv[argNo],"-err") == 0) {
+      argNo++;
+      if (argNo < argc) {
+        errDevice = argv[argNo];
+        argNo++;
+      }
+
+    } else if (strcmp(argv[argNo],"-prompt") == 0) {
+      argNo++;
+      if (argNo < argc) {
+        promptStr = argv[argNo];
+        argNo++;
+      }
+
+    } else
+      break;
+  }
+
+  if (argNo < argc) {
+    /* Execute specified command */
+    commandArgs = argv + argNo;
+  } else {
+    /* Execute default shell */
+    commandArgs = defaultCommand;
+  }
+
+  /* Convert prompt string to Unicode */
+  retValue = utf8toucs(promptStr, strlen(promptStr), uregexp, MAXPROMPT,
+                       0, &remaining, &decoded);
+  if ((retValue < 0) || (remaining > 0)) {
+    fprintf(stderr, "lterm: Error in decoding prompt string\n");
+    exit(1);
+  }
+
+  assert(decoded <= MAXPROMPT);
+  uregexp[decoded] = U_NUL;
+
+  if (debugFlag) {
+    messageLevel = 98;
+  } else {
+    messageLevel = 1;
+  }
+
+  if (errDevice != NULL) {
+    /* Redirect debug STDERR output to specified device */
+    int errfd = -1;
+    if ( (errfd = open(errDevice, O_WRONLY)) == -1)
+        perror("lterm");
+
+    if (dup2(errfd, 2) == -1) {
+      fprintf(stderr, "lterm: Failed dup2 for specified stderr\n");
+      exit(-1);
+    }
+
+    fprintf(stderr, "\n\nlterm: Echoing %s output to %s\n",
+            argv[0], errDevice);
+  }
+
+  signal(SIGINT, finish); /* Interrupt handler */
+
+  if (lineFlag) {
+    /* Line mode */
+
+    /* Get terminal attributes */
+    if (tcgetattr(0, &tios) == -1) {
+      fprintf(stderr, "lterm: Failed to get TTY attributes\n");
+      exit(-1);
+    }
+
+    /* Disable signals, canonical mode processing, and echo  */
+    tios.c_lflag &= ~(ISIG | ICANON | ECHO );
+
+    /* set MIN=1 and TIME=0 */
+    tios.c_cc[VMIN] = 1;
+    tios.c_cc[VTIME] = 0;
+
+    /* Set terminal attributes */
+    if (tcsetattr(0, TCSAFLUSH, &tios) == -1) {
+      fprintf(stderr, "lterm: Failed to set TTY attributes\n");
+      exit(-1);
+    }
+
+  } else {
+    /* Screen mode */
+    if (ttyDevice == NULL) {
+      /* Initialize screen on controlling TTY */
+      initscr();
+
+    } else {
+      /* Initialize screen on specified TTY */
+      if (errDevice != NULL)
+        fprintf(stderr, "lterm-00: Opening xterm %s\n", ttyDevice);
+      inFile = fopen( ttyDevice, "r");
+      outFile = fopen( ttyDevice, "w");
+      termScreen = newterm("xterm", outFile, inFile);
+      set_term(termScreen);
+    }
+
+    /* NCURSES screen settings */
+    cbreak();                 /* set terminal to raw (non-canonical) mode */
+    noecho();                 /* Disable terminal echo */
+    nonl();                   /* Do not translate newline */
+    intrflush(stdscr, FALSE); /* Flush input on interrupt */
+    keypad(stdscr, TRUE);     /* Enable user keypad */
+
+#ifdef NCURSES_MOUSE_VERSION
+    mousemask(BUTTON1_CLICKED, NULL); /* Capture Button1 click events */
+#endif
+
+    clear(); /* Clear screen */
+  }
+
+  /* Initialize LTERM operations */
+  lterm_init(messageLevel);
+
+  if (errDevice != NULL) {
+    tlog_message("lterm-00: Testing tlog_message\n");
+    tlog_warning("lterm-00: Testing tlog_warning\n");
+    fprintf(stderr, "lterm-00: ");
+    tlog_unichar(uregexp, ucslen(uregexp));
+  }
+
+  if (errDevice != NULL)
+    fprintf(stderr, "lintest-00: Opening LTERM to execute %s\n", commandArgs[0]);
+
+  options = 0;
+  if (!ptyFlag) options |= LTERM_NOPTY_FLAG;
+
+  // options |= LTERM_NOSTDERR_FLAG;
+
+  ltermNumber = lterm_new();
+  retValue = lterm_open(ltermNumber, commandArgs, NULL, uregexp,
+                        options, processType, NULL, NULL);
+  if (retValue < 0) {
+    fprintf(stderr, "lterm: Error %d in opening LTERM\n", retValue);
+    exit(1);
+  }
+
+  /* Create output handler thread */
+  retValue = pthread_create(&output_handler_thread_ID,  NULL,
+                            output_handler, (void *) &ltermNumber);
+  if (retValue != 0) {
+    fprintf(stderr, "lterm: Error %d in creating OUTPUT_HANDLER thread\n",
+                     retValue);
+    finish(0);
+  }
+
+  if (errDevice != NULL)
+    fprintf(stderr, "lterm-00: Created OUTPUT_HANDLER thread\n");
+
+  /* Process input */
+  input_handler(&ltermNumber);
+
+  /* Join output handler thread */
+  if (errDevice != NULL)
+    fprintf(stderr, "lterm-00: Joining OUTPUT_HANDLER thread\n");
+
+  retValue = pthread_join(output_handler_thread_ID,  NULL);
+  if (retValue != 0) {
+    fprintf(stderr, "lterm: Error %d in joining OUTPUT_HANDLER thread\n",
+                     retValue);
+    finish(0);
+  }
+
+  finish(0);
+}
+
+void finish(int sig)
+{
+  if (!lineFlag) {
+    endwin(); /* Close window */
+    if (termScreen != NULL)
+      delscreen(termScreen);
+  }
+
+  if (ltermNumber >= 0) {
+    /* Close and delete LTERM */
+    lterm_delete(ltermNumber);
+  }
+
+  if (errDevice != NULL)
+    fprintf(stderr, "finished-00: Finished\n");
+
+  exit(0);
+}
+
+/** Output an Unicode message to specified file descriptor. */
+void writeUnicode(int fd, const UNICHAR *buf, int count)
+{
+  char str[MAXCOL];
+  int j, k;
+
+  k = 0;
+  for (j=0; j<count; j++) {
+
+    if (k >= MAXCOL-4) {
+      if (MAXCOL >= 4) {
+        str[MAXCOL-4] = '.';
+        str[MAXCOL-3] = '.';
+        str[MAXCOL-2] = '.';
+      }
+      k = MAXCOL-1;
+      break;
+    }
+
+    /* TEMPORARY IMPLEMENTATION: just truncate Unicode to byte characters */
+    str[k++] = buf[j];
+  }
+
+  if (k == 0) return;
+
+  if (write(fd, str, k) != k) {
+    fprintf(stderr, "writeUnicode: Error in writing to FD %d\n", fd);
+    exit(-1);
+  }
+}
+
+
+/** Output an Unicode message to specified output stream
+ * if NOCONTROL is true, control characters are converted to printable
+ * characters before output
+ */
+void printUnicode(FILE *outStream, const UNICHAR *buf, int count, int noControl)
+{
+  char str[MAXCOL];
+  int j, k;
+
+  k = 0;
+  for (j=0; j<count; j++) {
+
+    if (k >= MAXCOL-4) {
+      if (MAXCOL >= 4) {
+        str[MAXCOL-4] = '.';
+        str[MAXCOL-3] = '.';
+        str[MAXCOL-2] = '.';
+      }
+      k = MAXCOL-1;
+      break;
+    }
+
+    if (!noControl && ((buf[j] < U_SPACE) || (buf[j] == U_DEL)) ) {
+      /* Control character */
+      str[k++] = U_CARET;
+      str[k++] = buf[j]+U_ATSIGN;
+    } else {
+      /* Printable character */
+      /* TEMPORARY IMPLEMENTATION: just truncate Unicode to byte characters */
+      str[k++] = buf[j];
+    }
+  }
+
+  /* Insert terminating null character and display string */
+  str[k++] = '\0';
+  fprintf(outStream, "%s\n", str);
+}
+
+
+void input_handler(int *plterm)
+{
+  char ch;
+  UNICHAR uch;
+  int n_written;
+
+  if (lineFlag) {
+
+    for (;;) {
+      /* Read a character from TTY (raw mode) */
+      ch = getchar();
+
+      if (ch == 0) {
+        fprintf(stderr, "input_handler-00: NUL character read; terminating\n");
+        break;
+      }
+
+      uch = (UNICHAR) ch;
+      n_written = lterm_write(*plterm, &uch, 1, LTERM_WRITE_PLAIN_INPUT);
+
+      /* Exit loop if TTY has been closed */
+      if (n_written == -2) {
+        if (errDevice != NULL)
+          fprintf(stderr, "input_handler-00: pseudo-TTY has been closed\n", *plterm);
+        break;
+      }
+
+      if (n_written < 0) {
+        fprintf(stderr, "input_handler: Error %d return from lterm_write\n",
+                         n_written);
+        return;
+      }
+    }
+  }
+
+  /* Close LTERM */
+  if (errDevice != NULL)
+    fprintf(stderr, "input_handler-00: Closing LTERM %d\n", *plterm);
+
+  /* Close and delete LTERM */
+  lterm_delete(*plterm);
+  *plterm = -1;
+}
+
+void *output_handler(void *arg)
+{
+  int *plterm = (int *) arg;
+  int timeout = -1;
+  UNICHAR buf[MAXCOL];
+  UNISTYLE style[MAXCOL];
+  int n_read, opcodes, buf_row, buf_col, cursor_row, cursor_col;
+  int xmax, ymax, x, y, c;
+  MEVENT mev;
+
+  if (errDevice != NULL)
+    fprintf(stderr, "output_handler-00: thread ID = %d, LTERM=%d\n",
+                    pthread_self(), *plterm);
+
+  if (!lineFlag) {
+    /* Get screen size */
+    getmaxyx(stdscr, ymax, xmax);
+
+    if (errDevice != NULL)
+      fprintf(stderr, "output_handler-00: screen xmax = %d, ymax = %d\n",
+              xmax,ymax);
+  }
+
+  for (;;) {
+    n_read = lterm_read(*plterm, timeout, buf, MAXCOL,
+                        style, &opcodes,
+                        &buf_row, &buf_col, &cursor_row, &cursor_col);
+
+    if (n_read == -1) {
+      fprintf(stderr, "output_handler: Error %d return from lterm_read\n",
+                      n_read);
+      return NULL;
+    }
+
+    /* Exit loop if TTY has been closed;
+     * leave it to input handler to close the LTERM.
+     */
+    if (n_read == -2) {
+      if (errDevice != NULL)
+        fprintf(stderr, "output_handler: pseudo-TTY has been closed\n");
+      break;
+    }
+
+    if (debugFlag) {
+      fprintf(stderr, "output_handler-00: n_read=%d, opcodes=%x, buf_row/col=%d/%d, cursor_row/col=%d/%d\n",
+            n_read, opcodes, buf_row, buf_col, cursor_row, cursor_col);
+      fprintf(stderr, "output_handler-00: U(%d): ", n_read);
+      printUnicode(stderr, buf, n_read, 1);
+      fprintf(stderr, "\n");
+    }
+
+    if (opcodes & LTERM_STREAMDATA_CODE) {
+      /* Stream data */
+      if (debugFlag)
+        fprintf(stderr, "output_handler-00: STREAMDATA\n");
+
+    } else if (opcodes & LTERM_SCREENDATA_CODE) {
+      /* Screen data */
+      if (debugFlag)
+        fprintf(stderr, "output_handler-00: SCREENDATA\n");
+
+    } else if (opcodes & LTERM_LINEDATA_CODE) {
+      /* Line data */
+      if (debugFlag)
+        fprintf(stderr, "output_handler-00: LINEDATA\n");
+
+      if (lineFlag) {
+        int j;
+        write(1, "\033[2K", 4);
+        write(1, "\r", 1);
+
+        if (opcodes & LTERM_META_CODE)
+          write(1, "META", 4);
+
+        writeUnicode(1, buf, n_read);
+
+        for (j=0; j< (n_read-cursor_col); j++)
+          write(1, "\033[D", 3);
+
+        if (opcodes & LTERM_BELL_CODE)
+          write(1, "\007", 1);
+
+        if (opcodes & LTERM_CLEAR_CODE)
+          write(1, "\033[H\033[2J", 7);
+
+        if (opcodes & LTERM_NEWLINE_CODE)
+          write(1, "\n", 1);
+      }
+
+    } else if (opcodes != 0) {
+      fprintf(stderr, "output_handler: invalid opcodes %x\n", opcodes);
+    }
+  }
+
+  return NULL;
+}

mozilla/extensions/xmlterm/linetest/ptytest.c

@@ -0,0 +1,366 @@
+/*
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "MPL"); you may not use this file
+ * except in compliance with the MPL. You may obtain a copy of
+ * the MPL at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the MPL is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the MPL for the specific language governing
+ * rights and limitations under the MPL.
+ * 
+ * The Original Code is lineterm.
+ * 
+ * The Initial Developer of the Original Code is Ramalingam Saravanan.
+ * Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+ * Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+ * 
+ * Contributor(s):
+ * 
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU General Public License (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 replace 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.
+ */
+
+/* ptytest.c: Test driver for ptystream.c
+ * CPP options:
+ *   LINUX:   for Linux2.0/glibc
+ *   SOLARIS: for Solaris2.6
+ */
+
+#include <stdio.h>
+#include <termios.h>
+
+#include <signal.h>
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#ifdef SOLARIS
+#include <stropts.h>
+#include <poll.h>
+#endif
+
+#ifdef LINUX
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+typedef unsigned int nfds_t;
+#endif
+
+#include "ptystream.h"
+
+static struct termios tios;    /* TERMIOS structure */
+
+void pipeTest(int argc, char *argv[]);
+void ptyTest(int argc, char *argv[]);
+
+int echofd = -1;
+
+int main(int argc, char *argv[]) {
+
+  if (argc < 4) {
+    fprintf(stderr, "Usage: %s pty|pipe <echo-tty-name>|'' <shell-path> ...\n",
+                    argv[0]);
+    exit(-1);
+  }
+
+  /* Get terminal attributes */
+  if (tcgetattr(0, &tios) == -1) {
+    fprintf(stderr, "Failed to get TTY attributes\n");
+    exit(-1);
+  }
+
+  /* Disable signals, canonical mode processing, and echo  */
+  tios.c_lflag &= ~(ISIG | ICANON | ECHO );
+
+  /* set MIN=1 and TIME=0 */
+  tios.c_cc[VMIN] = 1;
+  tios.c_cc[VTIME] = 0;
+
+  /* Set terminal attributes */
+  if (tcsetattr(0, TCSAFLUSH, &tios) == -1) {
+    fprintf(stderr, "Failed to set TTY attributes\n");
+    exit(-1);
+  }
+
+  if (strlen(argv[2]) > 0) {
+    /* Open TTY for echoing */
+    if ( (echofd = open(argv[2], O_WRONLY)) == -1)
+      perror("ptytest");
+    fprintf(stderr, "Echoing %s output to %s\n", argv[1], argv[2]);
+    write( echofd, "Echoing PTYTEST output ...\n", 27);
+  }
+
+  fprintf(stderr, "Type Control-@ (NUL) to terminate input\n");
+
+  if (strcmp(argv[1],"pipe") == 0) {
+    pipeTest(argc-3, argv+3);
+  } else {
+    ptyTest(argc-3, argv+3);
+  }
+
+  if (echofd >= 0) close(echofd);
+  exit(0);
+
+}
+
+
+/* sends raw terminal input/output to a shell through a pseudo-TTY */
+void ptyTest(int argc, char *argv[])
+{
+  struct pollfd pollFD[2];
+  nfds_t nfds = 2;
+  struct ptys ptyStruc;
+
+  unsigned char ch;
+  int ptyFD, pollCode;
+  ssize_t n_read, n_written;
+
+  char temstr[3] = "^@";
+
+  /* Create a PTY */
+  if (pty_create(&ptyStruc,argv,-1,0,0,0,1) == -1) {
+    fprintf(stderr, "PTY creation failed\n");
+    exit(-1);
+  }
+
+  ptyFD = ptyStruc.ptyFD;
+
+  /* fprintf(stderr, "Polling for input on fd=0 (%s) and fd=%d\n",
+     ttyname(0), ptyFD ); */
+
+  /* Set up polling to read from parent STDIN and child STDOUT */
+  pollFD[0].fd = 0;
+  pollFD[0].events = POLLIN;
+  pollFD[1].fd = ptyFD;
+  pollFD[1].events = POLLIN;
+
+  while ( (pollCode=poll(pollFD,nfds,-1)) >= 0) {
+    if (pollCode == 0) continue;
+    pollCode = 0;
+
+    if (pollFD[0].revents != 0) {
+      /* Read character from parent STDIN and write to child STDIN */
+      ch = getchar();
+
+      /* Exit poll loop if a null (Control-@) is read */
+      if (ch == 0) break;
+
+      if (write(ptyFD, &ch, 1) != 1) {
+        fprintf(stderr, "Error in writing to child STDIN\n");
+        exit(-1);
+      }
+
+    }
+
+    if (pollFD[1].revents != 0) {
+      /* Read character from child STDOUT and write to parent STDOUT */
+
+      if ( (n_read=read(ptyFD, &ch, 1)) < 0) {
+        fprintf(stderr, "Error in reading from child STDOUT\n");
+        if (echofd >= 0) close(echofd);
+        exit(-1);
+      }
+
+      if (n_read == 0) { /* End of file */
+        if (echofd >= 0) close(echofd);
+        exit(0);
+      }
+
+      if (echofd >= 0) {
+        /* Echo output to another TTY */
+        if (ch == 0x7F) {
+          write(echofd, "\\DEL", 4);
+        } else if (ch == 0x1B) {
+          write(echofd, "\\ESC", 4);
+        } else if (ch < 0x20) {
+          temstr[1]= ch+'@';
+          write(echofd, temstr, 2);
+        } else {
+          write(echofd, &ch, 1);
+        }
+      }
+
+      if (write(1, &ch, 1) != 1) {
+        fprintf(stderr, "Error in writing to parent STDOUT\n");
+        exit(-1);
+      }
+
+      /*
+      if (ioctl(1, I_FLUSH, FLUSHRW) == -1) {
+        fprintf(stderr, "Error return from ioctl\n");
+        exit(-1);
+      }
+      */
+
+    }
+  }
+
+  if (pollCode != 0) {
+    fprintf(stderr, "Error return from poll\n");
+    exit(-1);
+  }
+
+  /* Close PTY */
+  pty_close(&ptyStruc);
+
+}
+
+
+/* sends raw terminal input/output to a shell through a pipe */
+void pipeTest(int argc, char *argv[])
+{
+  struct pollfd pollFD[2];
+  nfds_t nfds = 2;
+  pid_t child_pid = -1;   /* child process id */
+
+  unsigned char ch;
+  int pipeFD[2], pipeIN, pipeOUT, procIN, procOUT;
+  int pollCode;
+  ssize_t n_read, n_written;
+
+  char temstr[3] = "^@";
+
+  /* Create process input pipe (assumed unidirectional) */
+  if (pipe(pipeFD) == -1) {
+    fprintf(stderr, "Input pipe creation failed\n");
+    exit(-1);
+  }
+#ifdef DEBUG
+  fprintf(stderr,"Created input pipe: %d %d\n", pipeFD[0], pipeFD[1]);
+#endif
+  procIN = pipeFD[0];
+  pipeIN = pipeFD[1];
+
+  /* Create process output pipe (assumed unidirectional) */
+  if (pipe(pipeFD) == -1) {
+    fprintf(stderr, "Output pipe creation failed\n");
+    exit(-1);
+  }
+#ifdef DEBUG
+  fprintf(stderr,"Created output pipe: %d %d\n", pipeFD[0], pipeFD[1]);
+#endif
+  pipeOUT = pipeFD[0];
+  procOUT = pipeFD[1];
+
+  /* Fork a child process */
+  child_pid = fork();
+  if (child_pid < 0) {
+    fprintf(stderr, "Fork failed\n");
+    exit(-1);
+  }
+
+#ifdef DEBUG
+  fprintf(stderr, "Fork child process %d\n", child_pid);
+#endif
+
+  if (child_pid == 0) {
+    /* Child process */
+
+    if (dup2(procIN, 0) == -1) {
+      fprintf(stderr, "Dup2 failed for stdin of child\n");
+      exit(-1);
+    }
+
+    if (dup2(procOUT, 1) == -1) {
+      fprintf(stderr, "Dup2 failed for stdout of child\n");
+      exit(-1);
+    }
+
+    execvp(argv[0], argv);
+    fprintf(stderr, "Exec failed for command %s\n", argv[0]);
+    exit(-1);
+  }
+
+  /* Set up polling to read from parent STDIN and child STDOUT */
+  pollFD[0].fd = 0;
+  pollFD[0].events = POLLIN;
+  pollFD[1].fd = pipeOUT;
+  pollFD[1].events = POLLIN;
+
+  while ( (pollCode=poll(pollFD,nfds,-1)) >= 0) {
+
+    if (pollFD[0].revents != 0) {
+      /* Read character from parent STDIN and write to child STDIN */
+      ch = getchar();
+
+      /* Exit poll loop if a null (Control-@) is read */
+      if (ch == 0) break;
+
+      if (write(pipeIN, &ch, 1) != 1) {
+        fprintf(stderr, "Error in writing to child STDIN\n");
+        exit(-1);
+      }
+
+    }
+
+    if (pollFD[1].revents != 0) {
+      /* Read character from child STDOUT and write to parent STDOUT */
+
+      if ( (n_read=read(pipeOUT, &ch, 1)) < 0) {
+        fprintf(stderr, "Error in reading from child STDOUT\n");
+        if (echofd >= 0) close(echofd);
+        exit(-1);
+      }
+
+      if (n_read == 0) { /* End of file */
+        if (echofd >= 0) close(echofd);
+        exit(0);
+      }
+
+      if (echofd >= 0) {
+        /* Echo output to another TTY */
+        if (ch == 0x7F) {
+          write(echofd, "\\DEL", 4);
+        } else if (ch == 0x1B) {
+          write(echofd, "\\ESC", 4);
+        } else if (ch < 0x20) {
+          temstr[1]= ch+'@';
+          write(echofd, temstr, 2);
+        } else {
+          write(echofd, &ch, 1);
+        }
+      }
+
+      if (write(1, &ch, 1) != 1) {
+        fprintf(stderr, "Error in writing to parent STDOUT\n");
+        exit(-1);
+      }
+
+      /*
+      if (ioctl(1, I_FLUSH, FLUSHRW) == -1) {
+        fprintf(stderr, "Error return from ioctl\n");
+        exit(-1);
+      }
+      */
+
+    }
+
+  }
+
+  if (kill(child_pid, SIGKILL) == -1) {
+    fprintf(stderr, "Error return from kill\n");
+    exit(-1);
+  }
+
+  if (pollCode != 0) {
+    fprintf(stderr, "Error return from poll\n");
+    exit(-1);
+  }
+
+  /* Close pipes (assumed unidirectional) */
+  close(pipeIN);
+  close(pipeOUT);
+  close(procIN);
+  close(procOUT);
+
+}

mozilla/extensions/xmlterm/linetest/remake

@@ -0,0 +1,7 @@
+#!/bin/csh
+set echo
+
+pushd ../base
+make STAND_ALONE=1 export libs
+popd
+make STAND_ALONE=1 $*

mozilla/extensions/xmlterm/linetest/temncurses.c

@@ -0,0 +1,32 @@
+
+  /* Move cursor and display string */
+  x = 2;
+  y = 4;
+
+  /* if (scanf("%d %d", &y, &x) == EOF) break; */
+
+  /* Display string at specified location and advance cursor */
+  mvaddnstr(y, x, "test 1", 6);
+
+  attron(A_BOLD);
+  mvaddnstr(y, x+6, "test2 ", 6);
+  attroff(A_BOLD);
+
+  refresh();
+
+  for (;;) {
+    c = getch();
+    if (c == KEY_MOUSE) {
+      if (getmouse(&mev) == OK) {
+        move(mev.y, mev.x);
+        addnstr("MEV ", 4);
+        refresh();
+
+        /* Delete top line, and move up (if +1, insert top line, move down) */
+        move(0,0);
+        insdelln(-1);
+
+      }
+    }
+  }
+

mozilla/extensions/xmlterm/linetest/testunistr.c

@@ -0,0 +1,138 @@
+/* testunistr.c: Test driver for Unicode strings module unistring.c */
+
+/* public declarations */
+#include "unistring.h"
+
+#include "assert.h"
+
+int main(int argc, char *argv[])
+{
+  int argNo, ucs16_opt, utf8_opt, j;
+  int result, remaining, encoded, decoded;
+
+  if (argc < 2) {
+    printf("Usage: %s (-ucs16 <unicode-hex-string>|-utf8 <utf8-hex-string>|<ascii-chars>)\n",
+           argv[0]);
+    exit(1);
+  }
+
+  ucs16_opt = 0;
+  utf8_opt = 0;
+  argNo = 1;
+
+  if (argc > 1) {
+    argNo = 2;
+    if (strcmp(argv[1],"-ucs16") == 0) {
+      ucs16_opt = 1;
+    } else if (strcmp(argv[1],"-utf8") == 0) {
+      utf8_opt = 1;
+    }
+  }
+
+  if (ucs16_opt) {
+    char* tems = argv[argNo];
+    int nus = strlen(argv[argNo])/4;
+    int ns = 3*nus;
+    UNICHAR* us = (UNICHAR*) malloc((nus+1)*sizeof(UNICHAR));
+    unsigned char* s = (unsigned char*) malloc(ns+1);
+    char temus[5] = {0,0,0,0,0};
+
+    for (j=0; j<nus; j++) {
+      temus[0] = tems[4*j];
+      temus[1] = tems[4*j+1];
+      temus[2] = tems[4*j+2];
+      temus[3] = tems[4*j+3];
+      sscanf(temus, "%x", &us[j]);
+    }
+    us[nus] = U_NUL;
+
+    ucsprint(stderr, us, nus);
+    fprintf(stderr, "\n");
+
+    ucstoutf8(us, nus, s, ns, &remaining, &encoded);
+    assert(encoded <= ns);
+    ns = encoded;
+    s[ns] = '\0';
+
+    printf("UTF8(%d)=0x", ns);
+    for (j=0; j<ns; j++) {
+      printf("%02x",s[j]);
+    }
+    printf(", remaining=%d\n", remaining);
+
+    result = utf8toucs(s, ns, us, nus, 0, &remaining, &decoded);
+    assert(decoded <= nus);
+    us[decoded] = U_NUL;
+
+    printf("UCS(%d)=0x", decoded);
+
+    for (j=0; j<decoded; j++) {
+      printf("%04x",us[j]);
+    }
+    printf(", remaining=%d, result=%d\n", remaining, result);
+
+    free(us);
+    free(s);
+
+  } else {
+    char* tems = argv[argNo];
+    int ns, nus;
+    char* s;
+    UNICHAR* us;
+
+    ns = (utf8_opt) ? strlen(argv[argNo])/2 : strlen(argv[argNo]);
+    s = (char*) malloc(ns+1);
+    nus = ns;
+    us = (UNICHAR*) malloc((nus+1)*sizeof(UNICHAR));
+
+    if (utf8_opt) {
+      char temstr[3] = {0,0,0};
+      int ival;
+      for (j=0; j<ns; j++) {
+        temstr[0] = tems[2*j];
+        temstr[1] = tems[2*j+1];
+        sscanf(temstr, "%x", &ival);
+        s[j] = (unsigned char) ival;
+      }
+    } else {
+      for (j=0; j<ns; j++)
+        s[j] = tems[j];
+    }
+    s[ns] = '\0';
+
+    result = utf8toucs(s, ns, us, nus, 0, &remaining, &decoded);
+    assert(decoded <= nus);
+    nus = decoded;
+    us[nus] = U_NUL;
+
+    printf("UCS(%d)=0x", nus);
+
+    for (j=0; j<nus; j++) {
+      printf("%04x",us[j]);
+    }
+
+    printf(", remaining=%d, result=%d\n", remaining, result);
+
+    ucstoutf8(us, nus, s, ns, &remaining, &encoded);
+
+    assert(encoded <= ns);
+    s[encoded] = '\0';
+
+    if (utf8_opt) {
+      printf("UTF8(%d)=0x", encoded);
+
+      for (j=0; j<encoded; j++)
+        printf("%02x", s[j]);
+
+      printf(", remaining=%d\n", remaining);
+
+    } else {
+      printf("UTF8(%d)='%s', remaining=%d\n", encoded, s, remaining);
+    }
+
+    free(us);
+    free(s);
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/makemake

@@ -0,0 +1,34 @@
+#!/bin/csh
+# makemake: Dumb script to make Makefile from Makefile.in
+#           (recursively, if -r is specified)
+# Usage: makemake [-r]
+
+if ($# == 0) then
+   set makelist = (./Makefile.in)
+else
+   set makelist = (`find . -name Makefile.in -print`)
+endif
+
+foreach makefile ($makelist)
+   set dir=${makefile:h}
+   pushd $dir
+
+   set wd=`pwd`
+   echo $wd
+
+   set top_srcdir = ""
+   while (${wd:t} != "mozilla")
+      if ("$top_srcdir" == "") then
+         set top_srcdir = ".."
+      else
+         set top_srcdir = "../$top_srcdir"
+      endif
+      set wd=${wd:h}
+   end
+
+   /bin/cp Makefile.in Makefile
+   globsub @srcdir@ @srcdir@ . Makefile
+   globsub @top_srcdir@ @top_srcdir@ $top_srcdir Makefile
+
+   popd
+end

mozilla/extensions/xmlterm/tests/DocStream.c

@@ -0,0 +1,45 @@
+/* DocStream.c: Display complete HTML document using IFRAME */
+
+#include <stdio.h>
+
+int main(void)
+{
+  char ch;
+
+  /* XMLTerm escape sequence signalling start of a HTML document */
+  printf("\033{0;1S\007");
+
+  printf(" <HTML><BODY> \
+<FORM> \
+<IMG align=center src='chrome://navigator/skin/animthrob_single.gif'> \
+   <B>Please click a button</B> <BR> \
+<INPUT ID='button-b#' TYPE=button VALUE='Bold' \
+  onClick=\"return clickXMLTerm('sendln','#','b')\"> \
+<INPUT ID='button-e#' TYPE=button VALUE='Emphasis' \
+  onClick=\"return clickXMLTerm('sendln',#,'e')\"> \
+<INPUT ID='button-q#' TYPE=button VALUE='Quit' \
+  onClick=\"return clickXMLTerm('sendln',#,'q')\"> \
+<BR></FORM> \
+</BODY></HTML>");
+
+  /* XMLTerm escape sequence signalling end of stream */
+  printf("%c", '\0');
+
+  while((ch = getchar())){ /* Poll for data generated by button click events */
+    switch (ch) {
+    case 'b':
+      printf("\033{S\007<B>Hello World!</B><BR> %c", '\0');
+      break;
+    case 'e':
+      printf("\033{S\007<EM>Hello World!</EM><BR> %c", '\0');
+      break;
+    case 'q':
+      return 0;
+      break;
+    default:
+      break;
+    }
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/tests/HelloWorld.c

@@ -0,0 +1,40 @@
+/* HelloWorld.c: Simple demo program for "pagelets" */
+
+#include <stdio.h>
+
+int main(void)
+{
+  char ch;
+  printf("\033{S\007");  /* XMLTerm escape sequence signalling start of HTML */
+
+  printf("<FORM> \
+<IMG align=center src='chrome://navigator/skin/animthrob_single.gif'> \
+   <B>Please click a button</B> <BR> \
+<INPUT ID='button-b#' TYPE=button VALUE='Bold' \
+  onClick=\"return clickXMLTerm('sendln','#','b')\"> \
+<INPUT ID='button-e#' TYPE=button VALUE='Emphasis' \
+  onClick=\"return clickXMLTerm('sendln',#,'e')\"> \
+<INPUT ID='button-q#' TYPE=button VALUE='Quit' \
+  onClick=\"return clickXMLTerm('sendln',#,'q')\"> \
+<BR></FORM>");
+
+  printf("%c", '\0');    /* XMLTerm escape sequence signalling end of HTML */
+
+  while((ch = getchar())){ /* Poll for data generated by button click events */
+    switch (ch) {
+    case 'b':
+      printf("\033{S\007<B>Hello World!</B><BR> %c", '\0');
+      break;
+    case 'e':
+      printf("\033{S\007<EM>Hello World!</EM><BR> %c", '\0');
+      break;
+    case 'q':
+      return 0;
+      break;
+    default:
+      break;
+    }
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/tests/Makefile.in

@@ -0,0 +1,67 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/tests directory
+
+ifdef STAND_ALONE
+DEPTH      = ..
+topsrcdir  = ..
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../..
+topsrcdir  = @top_srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+# Debug option
+DEBUG = 1
+
+# C Sources
+CSRCS = escape.c teststream.c HelloWorld.c DocStream.c
+
+# Program
+SIMPLE_PROGRAMS = escape teststream HelloWorld DocStream
+
+# Defines
+DEFINES =
+
+# Libraries to be linked
+LIBS =
+
+include $(topsrcdir)/config/config.mk
+
+include ../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk

mozilla/extensions/xmlterm/tests/README

@@ -0,0 +1 @@
+tests --- Test programs for XMLterm

mozilla/extensions/xmlterm/tests/escape.c

@@ -0,0 +1,56 @@
+/* escape.c: Generates XMLterm/LineTerm escape sequences */
+
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+  int nparam, j;
+  char *param1, *param2, *param3, *code, *sparam;
+
+  param1 = NULL;
+  param2 = NULL;
+  param3 = NULL;
+  code =   NULL;
+  sparam = "";
+  nparam = 0;
+
+  for (j=1; j<argc; j++) {
+    if ((*argv[j] >= '0') && (*argv[j] <= '9')) {
+      if (j == 1) {
+        param1 = argv[j];
+        nparam = 1;
+      } else if (j == 2) {
+        param2 = argv[j];
+        nparam = 2;
+      } else if (j == 3) {
+        param3 = argv[j];
+        nparam = 3;
+      }
+    } else if (code == NULL) {
+      code = argv[j];
+    } else {
+      sparam = argv[j];
+    }
+  }
+
+  if (code == NULL) {
+    fprintf(stderr, "Usage: %s [<param1> [<param2> [<param3>]]] <code-character> [<string-param>] \n", argv[0]);
+    return 1;
+  }
+
+  if (nparam == 0) {
+    fprintf(stderr, "ESC{%s%sBEL\n", code, sparam);
+    fprintf(stdout, "\033{%s%s\007", code, sparam);
+  } else if (nparam == 1) {
+    fprintf(stderr, "ESC{%s%s%sBEL\n", param1, code, sparam);
+    fprintf(stdout, "\033{%s%s%s\007", param1, code, sparam);
+  } else if (nparam == 2) {
+    fprintf(stderr, "ESC{%s;%s%s%sBEL\n", param1, param2, code, sparam);
+    fprintf(stdout, "\033{%s;%s%s%s\007", param1, param2, code, sparam);
+  } else {
+    fprintf(stderr, "ESC{%s;%s;%s%s%sBEL\n", param1, param2, param3, code, sparam);
+    fprintf(stdout, "\033{%s;%s;%s%s%s\007", param1, param2, param3, code, sparam);
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/tests/teststream.c

@@ -0,0 +1,20 @@
+/* teststream.c: Test driver to generate escaped stream data */
+
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  if (argc < 2) {
+    fprintf(stderr, "Usage: %s <data-string> [<terminator-string>]\n",argv[0]);
+    return 1;
+  }
+
+  if (argc > 2) {
+    /* fprintf(stderr, "{ESCS%sBEL%s%s", argv[2], argv[1], argv[2]); */
+    fprintf(stdout, "\033{S%s\007%s%s", argv[2], argv[1], argv[2]);
+
+  } else {
+    fprintf(stdout, "\033{S\007%s%c", argv[1], '\0');
+  }
+
+  return 0;
+}

mozilla/extensions/xmlterm/tests/xls

@@ -0,0 +1,84 @@
+#!/usr/bin/perl
+# xls: an XMLterm wrapper for the UNIX "ls" command
+# Usage: xls  [-c|--cols] [-h|help] [-i||--iconic] [-w|--window]
+
+use Cwd;
+use Getopt::Long;
+
+Getopt::Long::config('bundling');
+
+$options = "@ARGV";
+
+&GetOptions("cols|c=i", "help|h!", "iconic|i!", "window|w!");
+
+if ($opt_help) {
+    print "Usage: xls [-c|--cols] [-i|--iconic] [-w|--window]\n";
+    exit;
+}
+
+# Icon details
+#$imgdir="chrome://xmlterm/skin/default/images"
+$imgdir = "file:/usr/share/pixmaps/mc";
+
+($img{'directory'}, $img{'executable'}, $img{'plainfile'}) =
+    ('i-directory.png', 'i-executable.png', 'i-regular.png');
+
+$ncols = 5;
+$ncols = $opt_cols if ($opt_cols);
+
+print "\e{S\a";                         # HTML stream escape sequence
+print "<TABLE FRAME=none BORDER=0>";
+print "<COLGROUP COLSPAN=$ncols WIDTH=1*>";
+
+$dir = cwd();
+$rowimg = "";
+$rowtxt = "";
+$nfile = 0;
+foreach $file (glob("$dir/*")) {        # for each file in current directory
+    if (-d $file) {                     # directory
+        $filetype = "directory";
+        $sendtxt = "cd $file; xls $options";
+        $sendimg = "file:/usr/share/pixmaps/mc/i-directory.png";
+
+    } elsif (-x $file) {                # executable
+        $filetype = "executable";
+        $sendtxt = "$file";
+
+    } else {                            # plain file
+        $filetype = "plainfile";
+        $sendtxt = "";
+    }
+
+    @comps = split(m./.,$file);
+    $tail = $comps[$#comps];            # file name
+
+    if ($opt_window) {
+        $sendcmd = "createln";
+    } else {
+        $sendcmd = "sendln";
+    }
+
+    $clickcmd = qq%onclick="return clickXMLTerm('$sendcmd',-1,'$sendtxt')"%;
+
+    $rowimg .= "<TD><IMG SRC='$imgdir/$img{$filetype}' $clickcmd>";
+    $rowtxt .= "<TD><SPAN CLASS='$filetype' $clickcmd>";
+    $rowtxt .= "$tail</SPAN>";
+    $nfile++;
+
+    if (($nfile % $ncols) == 0) {       # print complete table row
+        print "<TR>$rowimg" if ($opt_iconic) ;
+        print "<TR>$rowtxt";
+        $rowimg = "";
+        $rowtxt = "";
+    }
+
+}
+
+if (length($rowtxt) != 0) {
+    print "<TR>$rowimg" if ($opt_iconic) ;
+    print "<TR>$rowtxt";
+}
+
+print "</TABLE>";
+print "\000";                           # Terminate HTML stream
+

mozilla/extensions/xmlterm/tests/xls.csh

@@ -0,0 +1,81 @@
+#!/bin/csh
+# xls.csh: a C-shell XMLterm wrapper for the UNIX "ls" command
+# Usage: xls.csh [-i] [-x]
+
+set files=(`/bin/ls -d $cwd/*`)
+set ncols=4
+
+##set echocmd="/usr/bin/echo"
+set echocmd="/bin/echo -e"
+
+set iconic=0
+set create=0
+
+set options=""
+foreach arg ($*)
+   switch ($arg)
+   case "-i":
+      set iconic=1
+      set options=($options $arg)
+      breaksw
+   case "-c":
+      set create=1
+      set options=($options $arg)
+      breaksw
+   endsw
+end
+
+$echocmd '\033{S\007\c'
+$echocmd '<TABLE FRAME=none BORDER=0>'
+$echocmd "<COLGROUP COLSPAN=$ncols WIDTH=1*>"
+
+set rowimg=""
+set rowtxt=""
+set nfile=0
+foreach file ($files)
+   if (-d $file) then       #directory
+      set filetype="directory"
+      set sendtxt="cd $file; xls $options"
+      set sendimg="file:/usr/share/pixmaps/mc/i-directory.png"
+#      set sendimg="chrome://xmlterm/skin/default/images/ficon3.gif"
+   else if (-x $file) then  #executable
+      set filetype="executable"
+      set sendtxt="$file"
+      set sendimg="file:/usr/share/pixmaps/mc/i-executable.png"
+   else                     #plain file
+      set filetype="plainfile"
+      set sendtxt=""
+      set sendimg="file:/usr/share/pixmaps/mc/i-regular.png"
+   endif
+
+   set tail=${file:t}
+
+   if ($create) then
+      set cmd="createln"
+   else
+      set cmd="sendln"
+   endif
+   set clickcmd="onclick="'"'"return clickXMLTerm('$cmd',-1,'$sendtxt')"'"'
+
+   set rowimg="${rowimg}<TD><IMG SRC='$sendimg' $clickcmd>"
+   set rowtxt="${rowtxt}<TD><SPAN CLASS='$filetype' $clickcmd>"
+   set rowtxt="${rowtxt}$tail<SPAN/>"
+@  nfile++
+
+   if (($nfile % $ncols) == 0) then
+      if ($iconic) $echocmd "<TR>$rowimg"
+      $echocmd "<TR>$rowtxt"
+      set rowimg=""
+      set rowtxt=""
+   endif
+
+end
+
+if ("$rowtxt" != "") then
+   if ($iconic) $echocmd "<TR>$rowimg"
+   $echocmd "<TR>$rowtxt"
+endif
+
+$echocmd '</TABLE>'
+$echocmd '\000\c'
+

mozilla/extensions/xmlterm/ui/Makefile.in

@@ -0,0 +1,57 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/ui directory
+
+ifdef STAND_ALONE
+DEPTH      = .
+topsrcdir  = .
+VPATH      = .
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../..
+topsrcdir  = @top_srcdir@
+VPATH      = @srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+DIRS = content skin
+
+include $(topsrcdir)/config/config.mk
+
+include ../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/extensions/xmlterm/ui/README

@@ -0,0 +1 @@
+ui --- User Interface stuff for XMLterm

mozilla/extensions/xmlterm/ui/content/Makefile.in

@@ -0,0 +1,61 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/ui/content directory
+
+ifdef STAND_ALONE
+DEPTH      = .
+topsrcdir  = .
+VPATH      = .
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../../..
+topsrcdir  = @top_srcdir@
+VPATH      = @srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+include $(topsrcdir)/config/config.mk
+
+include ../../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk
+
+EXPORT_RESOURCE_CONTENT = \
+	$(srcdir)/xmlterm.html \
+	$(NULL)
+
+install:: 
+	$(INSTALL) $(EXPORT_RESOURCE_CONTENT) $(DIST)/bin/chrome/xmlterm/content/default

mozilla/extensions/xmlterm/ui/content/README

@@ -0,0 +1,5 @@
+content --- XUL, Javascript, and HTML for user interface
+
+xmlterm.html      XMLterm startup file containing HTML and Javascript
+                    Uses mozIXMLTermShell to create XMLterm
+                    Uses ../skin/xmlterm.css for stylesheets

mozilla/extensions/xmlterm/ui/content/xmlterm.html

@@ -0,0 +1,239 @@
+<!-- xmlterm.html: XMLterm startup page -->
+<HTML>
+  <HEAD>
+    <TITLE>XMLterm Test Page</TITLE>
+
+  <LINK TITLE="DefaultStyle" REL="stylesheet" TYPE="text/css"
+   HREF="chrome://xmlterm/skin/xmlterm.css">
+
+    <SCRIPT language="JavaScript">
+
+      // Control display of all output elements
+      function DisplayAllOutput(flag) {
+        var outputElements = document.getElementsByName("output");
+        for (i=0; i<outputElements.length; i++) {
+          var outputElement = outputElements[i];
+          outputElement.style.display = (flag) ? "block" : "none";
+        }
+
+        var promptElements = document.getElementsByName("prompt");
+        for (i=0; i<promptElements.length; i++) {
+          promptElement = promptElements[i];
+          promptElement.style.setProperty("text-decoration",
+                                           (flag) ? "none" : "underline", "")
+        }
+        return (false);
+      }
+
+      // Click handler
+      function clickXMLTerm(name, number, arg) {
+        dump("clickXMLTerm("+name+","+number+","+arg+")\n");
+        //dump("clickXMLTerm:document.cookie="+document.cookie+"\n");
+
+        if (name === "prompt") {
+          var outputElement = document.getElementById("output"+number);
+          var promptElement = document.getElementById("prompt"+number);
+          //dump(promptElement.style.getPropertyValue("text-decoration"));
+
+          if (outputElement.style.display == "none") {
+            outputElement.style.display = "block";
+            promptElement.style.setProperty("text-decoration","none","");
+          } else {
+            outputElement.style.display = "none";
+            promptElement.style.setProperty("text-decoration","underline","");
+          }
+
+        } else if (name === "command") {
+          var commandElement = document.getElementById(name+number);
+          var command = commandElement.firstChild.data;
+          dump("command = "+command+"\n\n");
+          window.xmltermshell.SendText("\025"+command+"\n", document.cookie);
+
+        } else {
+
+          if ((number >= 0) &&
+            (window.xmltermshell.currentEntryNumber != number)) {
+            dump("NOT CURRENT COMMAND\n");
+            return (false);
+          }
+
+
+          if (name == "directory") {
+            var command = "ls: "+arg;
+            dump("command = "+command+"\n\n");
+            window.xmltermshell.SendText("\025"+command+"\n", document.cookie);
+  
+          } else if (name == "executable") {
+            var command = arg;
+            dump("command = "+command+"\n\n");
+            window.xmltermshell.SendText("\025"+command+"\n", document.cookie);
+  
+          } else if (name == "send") {
+            dump("send = "+arg+"\n");
+            window.xmltermshell.SendText(arg, document.cookie);
+  
+          } else if (name == "sendln") {
+            dump("sendln = "+arg+"\n\n");
+            window.xmltermshell.SendText("\025"+arg+"\n", document.cookie);
+  
+          } else if (name == "createln") {
+            dump("createln = "+arg+"\n\n");
+            xmltermshell.NewXMLTermWindow(arg+"\n");
+          }
+        }
+
+        return (false);
+      }
+
+      // Double Click handler
+      function dblclickXMLTerm(name, number, arg) {
+        dump("dblclickXMLTerm("+name+","+number+","+arg+")\n");
+        return (false);
+      }
+
+      // Set history buffer size
+      function SetHistory() {
+        var field = document.getElementById('HistoryValue');
+        dump("SetHistory "+field.value+"\n");
+        xmltermshell.history = field.value;
+        field.value = xmltermshell.history;
+        return (false);
+      }
+
+      // Set prompt
+      function SetPrompt() {
+        var field = document.getElementById('PromptValue');
+        dump("SetPrompt "+field.value+"\n");
+        xmltermshell.prompt = field.value;
+        return (false);
+      }
+
+      // Create new XMLTerm window
+      function CreateXMLTermWindow(firstcommand) {
+        xmltermshell.NewXMLTermWindow(firstcommand);
+        return (false);
+      }
+
+      // onLoad event handler
+      function LoadHandler() {
+        dump("xmlterm: LoadHandler ... "+window.xmltermshell+"\n");
+
+        if (window.xmltermshell) {
+           // XMLTerm already initialized
+           return (false);
+        }
+
+        dump("Trying to make an XMLTerm Shell through the component manager...\n");
+
+        var xmltshell = Components.classes["component://mozilla/xmlterm/xmltermshell"].createInstance();
+
+        dump("Interface xmltshell1 = " + xmltshell + "\n");
+
+        xmltshell = xmltshell.QueryInterface(Components.interfaces.mozIXMLTermShell);
+        dump("Interface xmltshell2 = " + xmltshell + "\n");
+
+        if (!xmltshell) {
+          dump("Failed to create XMLTerm shell\n");
+          window.close();
+          return;
+        }
+  
+        // Store the XMLTerm shell in the window
+        window.xmltermshell = xmltshell;
+
+        // Content window same as current window
+        var contentWindow = window;
+
+        // Initialize XMLTerm shell in content window with argvals
+        window.xmltermshell.Init(contentWindow, "", "");
+
+        //dump("LoadHandler:"+document.cookie+"\n");
+
+        dump("contentWindow="+contentWindow+"\n");
+        dump("document="+document+"\n");
+        dump("documentElement="+document.documentElement+"\n");
+
+        // Set focus to appropriate frame
+        contentWindow.focus();
+
+        //contentWindow.xmltermshell = xmltermshell;
+
+        //dump(contentWindow.xmltermshell);
+
+        return (false);
+
+        dump("[Main] "+window+"\n");
+        dump(window.screenX+", "+window.screenY+"\n");
+        dump(window.scrollX+", "+window.scrollY+"\n");
+        dump(window.pageXOffset+", "+window.pageYOffset+"\n");
+
+        dump("IFRAME checks\n");
+        var iframe = document.getElementById('iframe1');
+
+        dump("iframe="+iframe+"\n");
+
+        frames=document.frames;
+        dump("frames="+frames+"\n");
+        dump("frames.length="+frames.length+"\n");
+
+        framewin = frames[0];
+
+        dump("framewin="+framewin+"\n");
+        dump("framewin.document="+framewin.document+"\n");
+
+        dump(framewin.screenX+", "+framewin.screenY+"\n");
+        dump(framewin.scrollX+", "+framewin.scrollY+"\n");
+        dump(framewin.pageXOffset+", "+framewin.pageYOffset+"\n");
+
+        var body = framewin.document.getElementsByTagName("BODY")[0];
+        dump("body="+body+"\n");
+
+        var height= body.scrollHeight;
+        dump("height="+height+"\n");
+
+//        iframe.height = 800;
+//        iframe.width = 700;
+
+//        framewin.sizeToContent();
+
+        framewin.xmltshell = xmltshell;
+        dump(framewin.xmltshell+"\n");
+
+        dump("xmlterm: LoadHandler completed\n");
+        return (false);
+      }
+
+    </SCRIPT>
+    
+  </HEAD>
+
+  <BODY onLoad="return LoadHandler();">
+
+    <TABLE FRAME=none BORDER=0>
+      <TBODY>
+      <TR><TD ALIGN=center>
+        <FORM NAME="XMLTERM form">
+          <INPUT TYPE="button" VALUE="Show all output"
+               onClick="return DisplayAllOutput(true);">
+          <INPUT TYPE="button" VALUE="Hide all output"
+               onClick="return DisplayAllOutput(false);">
+          <INPUT TYPE="button" VALUE="New XMLterm"
+               onClick="return CreateXMLTermWindow('');">
+          <BR>
+          History Buffer Size:
+          <INPUT TYPE="text" ID="HistoryValue" VALUE="">
+          <INPUT TYPE="button" VALUE="Set"  onClick="return SetHistory();">
+        </FORM>
+    </TABLE>
+
+<!--
+    <IFRAME NAME="iframe1" SRC="file:///home/svn/xmlterm/doc/web/tem2.html"
+            FRAMEBORDER=0 WIDTH="20" HEIGHT=60>
+    </IFRAME>
+-->
+
+    <DIV CLASS="session" ID="session">
+    </DIV>
+
+  </BODY>
+</HTML>

mozilla/extensions/xmlterm/ui/skin/Makefile.in

@@ -0,0 +1,66 @@
+#!gmake
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "MPL"); you may not use this file
+# except in compliance with the MPL. You may obtain a copy of
+# the MPL at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the MPL is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the MPL for the specific language governing
+# rights and limitations under the MPL.
+# 
+# The Original Code is lineterm.
+# 
+# The Initial Developer of the Original Code is Ramalingam Saravanan.
+# Portions created by Ramalingam Saravanan <svn@xmlterm.org> are
+# Copyright (C) 1999 Ramalingam Saravanan. All Rights Reserved.
+# 
+# Contributor(s):
+# 
+# Alternatively, the contents of this file may be used under the
+# terms of the GNU General Public License (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 replace 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.
+#
+
+# makefile for xmlterm/ui/skin directory
+
+ifdef STAND_ALONE
+DEPTH      = .
+topsrcdir  = .
+VPATH      = .
+srcdir     = .
+include $(topsrcdir)/config/autoconf.mk
+else
+DEPTH      = ../../../..
+topsrcdir  = @top_srcdir@
+VPATH      = @srcdir@
+srcdir     = @srcdir@
+include $(DEPTH)/config/autoconf.mk
+endif
+
+include $(topsrcdir)/config/config.mk
+
+include ../../config/xmlterm_config.mk
+
+include $(topsrcdir)/config/rules.mk
+
+EXPORT_RESOURCE_SKIN = \
+        $(srcdir)/xmlterm.css \
+        $(NULL)
+
+EXPORT_RESOURCE_TOOLBAR = \
+        $(srcdir)/images/ficon.gif \
+        $(NULL)
+
+install:: 
+	$(INSTALL) $(EXPORT_RESOURCE_SKIN) $(DIST)/bin/chrome/xmlterm/skin/default
+	$(INSTALL) $(EXPORT_RESOURCE_TOOLBAR) $(DIST)/bin/chrome/xmlterm/skin/default/images

mozilla/extensions/xmlterm/ui/skin/README

@@ -0,0 +1,5 @@
+skin --- CSS stylesheets and images for user interface
+
+xmlterm.css       Stylesheet for XMLterm startup file ../content/xmlterm.html
+
+

mozilla/extensions/xmlterm/ui/skin/images/README

@@ -0,0 +1 @@
+images --- Icons and images for user interface

mozilla/extensions/xmlterm/ui/skin/xmlterm.css

@@ -0,0 +1,19 @@
+/* xmlterm.css: XMLterm default style sheet */
+
+BODY { font-family: monaco, courier, elite, monospace;
+       background-color: #FFFFFF;
+     }
+
+DIV, PRE, SPAN { margin: 0; padding-top: 0; padding-bottom: 0 }
+
+PRE { font-family: monaco;
+      line-height: 120% }
+
+/* Input components */
+SPAN.prompt      { color: blue }
+SPAN.command     { color: blue }
+
+/* Directory display */
+SPAN.plainfile   { font-family: monaco}
+SPAN.directory   { font-family: monaco; color: blue; cursor: hand }
+SPAN.executable  { font-family: monaco; color: blue; cursor: hand }

mozilla/htmlparser/src/nsAVLTree.cpp

@@ -1,617 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsAVLTree.h"
- 
-
-enum eLean      {eLeft,eNeutral,eRight};
-
-struct NS_COM nsAVLNode {
-public:
-
-  nsAVLNode(void* aValue) {
-    mLeft=0;
-    mRight=0;
-    mSkew=eNeutral;
-    mValue=aValue;
-  }
-
-  nsAVLNode*  mLeft;
-  nsAVLNode*  mRight;
-  eLean       mSkew;
-  void*       mValue;
-};
-
-
-/************************************************************
-  Now begin the tree class. Don't forget that the comparison
-  between nodes must occur via the comparitor function, 
-  otherwise all you're testing is pointer addresses.
- ************************************************************/
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-nsAVLTree::nsAVLTree(nsAVLNodeComparitor& aComparitor, 
-                     nsAVLNodeFunctor* aDeallocator) :
-  mComparitor(aComparitor), mDeallocator(aDeallocator) {
-  mRoot=0;
-  mCount=0;
-}
-
-
-static void 
-avlDeleteTree(nsAVLNode* aNode){
-  if (aNode) {
-    avlDeleteTree(aNode->mLeft);
-    avlDeleteTree(aNode->mRight);
-    delete aNode;
-  }
-}
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-nsAVLTree::~nsAVLTree(){
-  if (mDeallocator) {
-    ForEachDepthFirst(*mDeallocator);
-  }
-  avlDeleteTree(mRoot);
-}
-
-
-class CDoesntExist: public nsAVLNodeFunctor {
-public:
-  CDoesntExist(const nsAVLTree& anotherTree) : mOtherTree(anotherTree) {
-  }
-  virtual void* operator()(void* anItem) {
-    void* result=mOtherTree.FindItem(anItem);
-    if(result)
-      return nsnull;
-    return anItem;
-  }
-protected:
-  const nsAVLTree& mOtherTree;
-};
-
-/**
- * This method compares two trees (members by identity).
- * @update	gess12/27/98
- * @param   tree to compare against
- * @return  true if they are identical (contain same stuff).
- */
-PRBool nsAVLTree::operator==(const nsAVLTree& aCopy) const{
-  CDoesntExist functor(aCopy);
-  void* theItem=FirstThat(functor);
-  PRBool result=PRBool(!theItem);
-  return result;
-}
-
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-static void 
-avlRotateRight(nsAVLNode*& aRootNode){
-  nsAVLNode* ptr2;
-  nsAVLNode* ptr3;
-
-  ptr2=aRootNode->mRight;
-  if(ptr2->mSkew==eRight) {
-    aRootNode->mRight=ptr2->mLeft;
-    ptr2->mLeft=aRootNode;
-    aRootNode->mSkew=eNeutral;
-    aRootNode=ptr2;
-  }
-  else {
-    ptr3=ptr2->mLeft;
-    ptr2->mLeft=ptr3->mRight;
-    ptr3->mRight=ptr2;
-    aRootNode->mRight=ptr3->mLeft;
-    ptr3->mLeft=aRootNode;
-    if(ptr3->mSkew==eLeft)
-      ptr2->mSkew=eRight;
-    else ptr2->mSkew=eNeutral;
-    if(ptr3->mSkew==eRight)
-      aRootNode->mSkew=eLeft;
-    else aRootNode->mSkew=eNeutral;
-    aRootNode=ptr3;
-  }
-  aRootNode->mSkew=eNeutral;
-  return;
-}
-
-
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-static void 
-avlRotateLeft(nsAVLNode*& aRootNode){
-  nsAVLNode* ptr2;
-  nsAVLNode* ptr3;
-
-  ptr2=aRootNode->mLeft;
-  if(ptr2->mSkew==eLeft) {
-    aRootNode->mLeft=ptr2->mRight;
-    ptr2->mRight=aRootNode;
-    aRootNode->mSkew=eNeutral;
-    aRootNode=ptr2;
-  }
-  else {
-    ptr3=ptr2->mRight;
-    ptr2->mRight=ptr3->mLeft;
-    ptr3->mLeft=ptr2;
-    aRootNode->mLeft=ptr3->mRight;
-    ptr3->mRight=aRootNode;
-    if(ptr3->mSkew==eRight)
-      ptr2->mSkew=eLeft;
-    else ptr2->mSkew=eNeutral;
-    if(ptr3->mSkew==eLeft)
-      aRootNode->mSkew=eRight;
-    else aRootNode->mSkew=eNeutral;
-    aRootNode=ptr3;
-  }
-  aRootNode->mSkew=eNeutral;
-  return;
-}
-
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlInsert(nsAVLNode*& aRootNode, nsAVLNode* aNewNode, 
-          nsAVLNodeComparitor& aComparitor) {
-  eAVLStatus result=eAVL_unknown;
-  
-  if(!aRootNode) {
-    aRootNode = aNewNode;
-    return eAVL_ok;
-  }
-  
-  if(aNewNode==aRootNode->mValue) {
-    return eAVL_duplicate;
-  }
-
-  PRInt32 theCompareResult=aComparitor(aRootNode->mValue,aNewNode->mValue);
-  if(0 < theCompareResult) { //if(anItem<aRootNode->mValue)
-    result=avlInsert(aRootNode->mLeft,aNewNode,aComparitor);
-    if(eAVL_ok==result) {
-      switch(aRootNode->mSkew){
-        case eLeft:
-          avlRotateLeft(aRootNode);
-          result=eAVL_fail;
-          break;
-        case eRight:
-          aRootNode->mSkew=eNeutral;
-          result=eAVL_fail;
-          break;
-        case eNeutral:
-          aRootNode->mSkew=eLeft;
-          break;
-      } //switch
-    }//if
-  } //if
-  else { 
-    result=avlInsert(aRootNode->mRight,aNewNode,aComparitor);
-    if(eAVL_ok==result) {
-      switch(aRootNode->mSkew){
-        case eLeft:
-          aRootNode->mSkew=eNeutral;
-          result=eAVL_fail;
-          break;
-        case eRight:
-          avlRotateRight(aRootNode);
-          result=eAVL_fail;
-          break;
-        case eNeutral:
-          aRootNode->mSkew=eRight;
-          break;
-      } //switch
-    }
-  } //if
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static void 
-avlBalanceLeft(nsAVLNode*& aRootNode, PRBool& delOk){
-  nsAVLNode*  ptr2;
-  nsAVLNode*  ptr3;
-  eLean       balnc2;
-  eLean       balnc3;
-
-  switch(aRootNode->mSkew){
-    case eLeft:
-      ptr2=aRootNode->mLeft;
-      balnc2=ptr2->mSkew;
-      if(balnc2!=eRight) {
-        aRootNode->mLeft=ptr2->mRight;
-        ptr2->mRight=aRootNode;
-        if(balnc2==eNeutral){
-          aRootNode->mSkew=eLeft;
-          ptr2->mSkew=eRight;
-          delOk=PR_FALSE;
-        }
-        else{
-          aRootNode->mSkew=eNeutral;
-          ptr2->mSkew=eNeutral;
-        }
-        aRootNode=ptr2;
-      }
-      else{
-        ptr3=ptr2->mRight;
-        balnc3=ptr3->mSkew;
-        ptr2->mRight=ptr3->mLeft;
-        ptr3->mLeft=ptr2;
-        aRootNode->mLeft=ptr3->mRight;
-        ptr3->mRight=aRootNode;
-        if(balnc3==eRight) {
-          ptr2->mSkew=eLeft;
-        }
-        else {
-          ptr2->mSkew=eNeutral;
-        }
-        if(balnc3==eLeft) {
-          aRootNode->mSkew=eRight;
-        }
-        else {
-          aRootNode->mSkew=eNeutral;
-        }
-        aRootNode=ptr3;
-        ptr3->mSkew=eNeutral;
-      }
-      break;
-
-    case eRight:
-      aRootNode->mSkew=eNeutral;
-      break;
-    
-    case eNeutral:
-      aRootNode->mSkew=eLeft;
-      delOk=PR_FALSE;
-      break;
-  }//switch
-  return;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static void 
-avlBalanceRight(nsAVLNode*& aRootNode, PRBool& delOk){
-  nsAVLNode*  ptr2;
-  nsAVLNode*  ptr3;
-  eLean       balnc2;
-  eLean       balnc3;
-
-  switch(aRootNode->mSkew){
-    case eLeft:
-      aRootNode->mSkew=eNeutral;
-      break;
-
-    case eRight:
-      ptr2=aRootNode->mRight;
-      balnc2=ptr2->mSkew;
-      if(balnc2!=eLeft) {
-        aRootNode->mRight=ptr2->mLeft;
-        ptr2->mLeft=aRootNode;
-        if(balnc2==eNeutral){
-          aRootNode->mSkew=eRight;
-          ptr2->mSkew=eLeft;
-          delOk=PR_FALSE;
-        }
-        else{
-          aRootNode->mSkew=eNeutral;
-          ptr2->mSkew=eNeutral;
-        }
-        aRootNode=ptr2;
-      }
-      else{
-        ptr3=ptr2->mLeft;
-        balnc3=ptr3->mSkew;
-        ptr2->mLeft=ptr3->mRight;
-        ptr3->mRight=ptr2;
-        aRootNode->mRight=ptr3->mLeft;
-        ptr3->mLeft=aRootNode;
-        if(balnc3==eLeft) {
-          ptr2->mSkew=eRight;
-        }
-        else {
-          ptr2->mSkew=eNeutral;
-        }
-        if(balnc3==eRight) {
-          aRootNode->mSkew=eLeft;
-        }
-        else {
-          aRootNode->mSkew=eNeutral;
-        }
-        aRootNode=ptr3;
-        ptr3->mSkew=eNeutral;
-      }
-      break;
-
-    case eNeutral:
-      aRootNode->mSkew=eRight;
-      delOk=PR_FALSE;
-      break;
-  }//switch
-  return;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlRemoveChildren(nsAVLNode*& aRootNode,nsAVLNode*& anotherNode, PRBool& delOk){
-  eAVLStatus result=eAVL_ok;
-  
-  if(!anotherNode->mRight){
-    aRootNode->mValue=anotherNode->mValue; //swap
-    anotherNode=anotherNode->mLeft;
-    delOk=PR_TRUE;
-  }
-  else{
-    avlRemoveChildren(aRootNode,anotherNode->mRight,delOk);
-    if(delOk)
-      avlBalanceLeft(anotherNode,delOk);
-  }
-
-  return result;
-}
-
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlRemove(nsAVLNode*& aRootNode, void* anItem, PRBool& delOk,
-          nsAVLNodeComparitor& aComparitor){
-  eAVLStatus result=eAVL_ok;
-
-  if(!aRootNode)
-    delOk=PR_FALSE;
-  else {
-    PRInt32 cmp=aComparitor(anItem,aRootNode->mValue);
-    if(cmp<0){
-      avlRemove(aRootNode->mLeft,anItem,delOk,aComparitor);
-      if(delOk)
-        avlBalanceRight(aRootNode,delOk);
-    }
-    else if(cmp>0){
-      avlRemove(aRootNode->mRight,anItem,delOk,aComparitor);
-      if(delOk)
-        avlBalanceLeft(aRootNode,delOk);
-    }
-    else{ //they match...
-      nsAVLNode* temp=aRootNode;
-      if(!aRootNode->mRight) {
-        aRootNode=aRootNode->mLeft;
-        delOk=PR_TRUE;
-        delete temp;
-      }
-      else if(!aRootNode->mLeft) {
-        aRootNode=aRootNode->mRight;
-        delOk=PR_TRUE;
-        delete temp;
-      }
-      else {
-        avlRemoveChildren(aRootNode,aRootNode->mLeft,delOk);
-        if(delOk)
-          avlBalanceRight(aRootNode,delOk);
-      }
-    }
-  }
-
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-eAVLStatus 
-nsAVLTree::AddItem(void* anItem){
-  eAVLStatus result=eAVL_ok;
-
-  nsAVLNode* theNewNode=new nsAVLNode(anItem);
-  result=avlInsert(mRoot,theNewNode,mComparitor);
-  if(eAVL_duplicate!=result)
-    mCount++;
-  else {
-    delete theNewNode;
-  }
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-void* nsAVLTree::FindItem(void* aValue) const{
-  nsAVLNode* result=mRoot;
-  PRInt32 count=0;
-  while(result) {
-    count++;
-    PRInt32 cmp=mComparitor(aValue,result->mValue);
-    if(0==cmp) {
-      //we matched...
-      break;
-    }
-    else if(0>cmp){
-      //theNode was greater...
-      result=result->mLeft;
-    }
-    else {
-      //aValue is greater...
-      result=result->mRight;
-    }
-  }
-  if(result) {
-    return result->mValue;
-  }
-  return nsnull;
-}
-
-
-/**
- * 
- * @update	gess12/30/98
- * @param 
- * @return
- */
-eAVLStatus 
-nsAVLTree::RemoveItem(void* aValue){
-  PRBool delOk=PR_TRUE;
-  eAVLStatus result=avlRemove(mRoot,aValue,delOk,mComparitor);
-  if(eAVL_ok==result)
-    mCount--;
-  return result;
-} 
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void 
-avlForEachDepthFirst(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor){
-  if(aNode) {
-    avlForEachDepthFirst(aNode->mLeft,aFunctor);
-    avlForEachDepthFirst(aNode->mRight,aFunctor);
-    aFunctor(aNode->mValue);
-  }
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void 
-nsAVLTree::ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const{
-  ::avlForEachDepthFirst(mRoot,aFunctor);
-}
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void 
-avlForEach(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
-  if(aNode) {
-    avlForEach(aNode->mLeft,aFunctor);
-    aFunctor(aNode->mValue);
-    avlForEach(aNode->mRight,aFunctor);
-  }
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void 
-nsAVLTree::ForEach(nsAVLNodeFunctor& aFunctor) const{
-  ::avlForEach(mRoot,aFunctor);
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void* 
-avlFirstThat(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
-  void* result=nsnull;
-  if(aNode) {
-    result = avlFirstThat(aNode->mLeft,aFunctor);
-    if (result) {
-      return result;
-    }
-    result = aFunctor(aNode->mValue);
-    if (result) {
-      return result;
-    }
-    result = avlFirstThat(aNode->mRight,aFunctor);
-  }
-  return result;
-}
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void* 
-nsAVLTree::FirstThat(nsAVLNodeFunctor& aFunctor) const{
-  return ::avlFirstThat(mRoot,aFunctor);
-}
-

mozilla/htmlparser/src/nsAVLTree.h

@@ -1,74 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsAVLTree_h___
-#define nsAVLTree_h___
-
-
-#include "nscore.h"
-
-
-enum eAVLStatus {eAVL_unknown,eAVL_ok,eAVL_fail,eAVL_duplicate};
-
-
-struct nsAVLNode;
-
-/**
- * 
- * @update	gess12/26/98
- * @param anObject1 is the first object to be compared
- * @param anObject2 is the second object to be compared
- * @return -1,0,1 if object1 is less, equal, greater than object2
- */
-class NS_COM nsAVLNodeComparitor {
-public:
-  virtual PRInt32 operator()(void* anItem1,void* anItem2)=0;
-}; 
-
-class NS_COM nsAVLNodeFunctor {
-public:
-  virtual void* operator()(void* anItem)=0;
-};
-
-class NS_COM nsAVLTree {
-public:
-              nsAVLTree(nsAVLNodeComparitor& aComparitor, nsAVLNodeFunctor* aDeallocator);
-              ~nsAVLTree(void);
-
-  PRBool      operator==(const nsAVLTree& aOther) const;
-  PRInt32     GetCount(void) const {return mCount;}
-
-              //main functions...
-  eAVLStatus  AddItem(void* anItem);
-  eAVLStatus  RemoveItem(void* anItem);
-  void*       FindItem(void* anItem) const;
-  void        ForEach(nsAVLNodeFunctor& aFunctor) const;
-  void        ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const;
-  void*       FirstThat(nsAVLNodeFunctor& aFunctor) const;
-
-protected: 
-
-  nsAVLNode*  mRoot;
-  PRInt32     mCount;
-  nsAVLNodeComparitor&  mComparitor;
-  nsAVLNodeFunctor*     mDeallocator;
-};
-
-
-#endif /* nsAVLTree_h___ */
-

mozilla/parser/htmlparser/src/nsAVLTree.cpp

@@ -1,617 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#include "nsAVLTree.h"
- 
-
-enum eLean      {eLeft,eNeutral,eRight};
-
-struct NS_COM nsAVLNode {
-public:
-
-  nsAVLNode(void* aValue) {
-    mLeft=0;
-    mRight=0;
-    mSkew=eNeutral;
-    mValue=aValue;
-  }
-
-  nsAVLNode*  mLeft;
-  nsAVLNode*  mRight;
-  eLean       mSkew;
-  void*       mValue;
-};
-
-
-/************************************************************
-  Now begin the tree class. Don't forget that the comparison
-  between nodes must occur via the comparitor function, 
-  otherwise all you're testing is pointer addresses.
- ************************************************************/
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-nsAVLTree::nsAVLTree(nsAVLNodeComparitor& aComparitor, 
-                     nsAVLNodeFunctor* aDeallocator) :
-  mComparitor(aComparitor), mDeallocator(aDeallocator) {
-  mRoot=0;
-  mCount=0;
-}
-
-
-static void 
-avlDeleteTree(nsAVLNode* aNode){
-  if (aNode) {
-    avlDeleteTree(aNode->mLeft);
-    avlDeleteTree(aNode->mRight);
-    delete aNode;
-  }
-}
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-nsAVLTree::~nsAVLTree(){
-  if (mDeallocator) {
-    ForEachDepthFirst(*mDeallocator);
-  }
-  avlDeleteTree(mRoot);
-}
-
-
-class CDoesntExist: public nsAVLNodeFunctor {
-public:
-  CDoesntExist(const nsAVLTree& anotherTree) : mOtherTree(anotherTree) {
-  }
-  virtual void* operator()(void* anItem) {
-    void* result=mOtherTree.FindItem(anItem);
-    if(result)
-      return nsnull;
-    return anItem;
-  }
-protected:
-  const nsAVLTree& mOtherTree;
-};
-
-/**
- * This method compares two trees (members by identity).
- * @update	gess12/27/98
- * @param   tree to compare against
- * @return  true if they are identical (contain same stuff).
- */
-PRBool nsAVLTree::operator==(const nsAVLTree& aCopy) const{
-  CDoesntExist functor(aCopy);
-  void* theItem=FirstThat(functor);
-  PRBool result=PRBool(!theItem);
-  return result;
-}
-
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-static void 
-avlRotateRight(nsAVLNode*& aRootNode){
-  nsAVLNode* ptr2;
-  nsAVLNode* ptr3;
-
-  ptr2=aRootNode->mRight;
-  if(ptr2->mSkew==eRight) {
-    aRootNode->mRight=ptr2->mLeft;
-    ptr2->mLeft=aRootNode;
-    aRootNode->mSkew=eNeutral;
-    aRootNode=ptr2;
-  }
-  else {
-    ptr3=ptr2->mLeft;
-    ptr2->mLeft=ptr3->mRight;
-    ptr3->mRight=ptr2;
-    aRootNode->mRight=ptr3->mLeft;
-    ptr3->mLeft=aRootNode;
-    if(ptr3->mSkew==eLeft)
-      ptr2->mSkew=eRight;
-    else ptr2->mSkew=eNeutral;
-    if(ptr3->mSkew==eRight)
-      aRootNode->mSkew=eLeft;
-    else aRootNode->mSkew=eNeutral;
-    aRootNode=ptr3;
-  }
-  aRootNode->mSkew=eNeutral;
-  return;
-}
-
-
-
-/**
- * 
- * @update	gess12/27/98
- * @param 
- * @return
- */
-static void 
-avlRotateLeft(nsAVLNode*& aRootNode){
-  nsAVLNode* ptr2;
-  nsAVLNode* ptr3;
-
-  ptr2=aRootNode->mLeft;
-  if(ptr2->mSkew==eLeft) {
-    aRootNode->mLeft=ptr2->mRight;
-    ptr2->mRight=aRootNode;
-    aRootNode->mSkew=eNeutral;
-    aRootNode=ptr2;
-  }
-  else {
-    ptr3=ptr2->mRight;
-    ptr2->mRight=ptr3->mLeft;
-    ptr3->mLeft=ptr2;
-    aRootNode->mLeft=ptr3->mRight;
-    ptr3->mRight=aRootNode;
-    if(ptr3->mSkew==eRight)
-      ptr2->mSkew=eLeft;
-    else ptr2->mSkew=eNeutral;
-    if(ptr3->mSkew==eLeft)
-      aRootNode->mSkew=eRight;
-    else aRootNode->mSkew=eNeutral;
-    aRootNode=ptr3;
-  }
-  aRootNode->mSkew=eNeutral;
-  return;
-}
-
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlInsert(nsAVLNode*& aRootNode, nsAVLNode* aNewNode, 
-          nsAVLNodeComparitor& aComparitor) {
-  eAVLStatus result=eAVL_unknown;
-  
-  if(!aRootNode) {
-    aRootNode = aNewNode;
-    return eAVL_ok;
-  }
-  
-  if(aNewNode==aRootNode->mValue) {
-    return eAVL_duplicate;
-  }
-
-  PRInt32 theCompareResult=aComparitor(aRootNode->mValue,aNewNode->mValue);
-  if(0 < theCompareResult) { //if(anItem<aRootNode->mValue)
-    result=avlInsert(aRootNode->mLeft,aNewNode,aComparitor);
-    if(eAVL_ok==result) {
-      switch(aRootNode->mSkew){
-        case eLeft:
-          avlRotateLeft(aRootNode);
-          result=eAVL_fail;
-          break;
-        case eRight:
-          aRootNode->mSkew=eNeutral;
-          result=eAVL_fail;
-          break;
-        case eNeutral:
-          aRootNode->mSkew=eLeft;
-          break;
-      } //switch
-    }//if
-  } //if
-  else { 
-    result=avlInsert(aRootNode->mRight,aNewNode,aComparitor);
-    if(eAVL_ok==result) {
-      switch(aRootNode->mSkew){
-        case eLeft:
-          aRootNode->mSkew=eNeutral;
-          result=eAVL_fail;
-          break;
-        case eRight:
-          avlRotateRight(aRootNode);
-          result=eAVL_fail;
-          break;
-        case eNeutral:
-          aRootNode->mSkew=eRight;
-          break;
-      } //switch
-    }
-  } //if
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static void 
-avlBalanceLeft(nsAVLNode*& aRootNode, PRBool& delOk){
-  nsAVLNode*  ptr2;
-  nsAVLNode*  ptr3;
-  eLean       balnc2;
-  eLean       balnc3;
-
-  switch(aRootNode->mSkew){
-    case eLeft:
-      ptr2=aRootNode->mLeft;
-      balnc2=ptr2->mSkew;
-      if(balnc2!=eRight) {
-        aRootNode->mLeft=ptr2->mRight;
-        ptr2->mRight=aRootNode;
-        if(balnc2==eNeutral){
-          aRootNode->mSkew=eLeft;
-          ptr2->mSkew=eRight;
-          delOk=PR_FALSE;
-        }
-        else{
-          aRootNode->mSkew=eNeutral;
-          ptr2->mSkew=eNeutral;
-        }
-        aRootNode=ptr2;
-      }
-      else{
-        ptr3=ptr2->mRight;
-        balnc3=ptr3->mSkew;
-        ptr2->mRight=ptr3->mLeft;
-        ptr3->mLeft=ptr2;
-        aRootNode->mLeft=ptr3->mRight;
-        ptr3->mRight=aRootNode;
-        if(balnc3==eRight) {
-          ptr2->mSkew=eLeft;
-        }
-        else {
-          ptr2->mSkew=eNeutral;
-        }
-        if(balnc3==eLeft) {
-          aRootNode->mSkew=eRight;
-        }
-        else {
-          aRootNode->mSkew=eNeutral;
-        }
-        aRootNode=ptr3;
-        ptr3->mSkew=eNeutral;
-      }
-      break;
-
-    case eRight:
-      aRootNode->mSkew=eNeutral;
-      break;
-    
-    case eNeutral:
-      aRootNode->mSkew=eLeft;
-      delOk=PR_FALSE;
-      break;
-  }//switch
-  return;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static void 
-avlBalanceRight(nsAVLNode*& aRootNode, PRBool& delOk){
-  nsAVLNode*  ptr2;
-  nsAVLNode*  ptr3;
-  eLean       balnc2;
-  eLean       balnc3;
-
-  switch(aRootNode->mSkew){
-    case eLeft:
-      aRootNode->mSkew=eNeutral;
-      break;
-
-    case eRight:
-      ptr2=aRootNode->mRight;
-      balnc2=ptr2->mSkew;
-      if(balnc2!=eLeft) {
-        aRootNode->mRight=ptr2->mLeft;
-        ptr2->mLeft=aRootNode;
-        if(balnc2==eNeutral){
-          aRootNode->mSkew=eRight;
-          ptr2->mSkew=eLeft;
-          delOk=PR_FALSE;
-        }
-        else{
-          aRootNode->mSkew=eNeutral;
-          ptr2->mSkew=eNeutral;
-        }
-        aRootNode=ptr2;
-      }
-      else{
-        ptr3=ptr2->mLeft;
-        balnc3=ptr3->mSkew;
-        ptr2->mLeft=ptr3->mRight;
-        ptr3->mRight=ptr2;
-        aRootNode->mRight=ptr3->mLeft;
-        ptr3->mLeft=aRootNode;
-        if(balnc3==eLeft) {
-          ptr2->mSkew=eRight;
-        }
-        else {
-          ptr2->mSkew=eNeutral;
-        }
-        if(balnc3==eRight) {
-          aRootNode->mSkew=eLeft;
-        }
-        else {
-          aRootNode->mSkew=eNeutral;
-        }
-        aRootNode=ptr3;
-        ptr3->mSkew=eNeutral;
-      }
-      break;
-
-    case eNeutral:
-      aRootNode->mSkew=eRight;
-      delOk=PR_FALSE;
-      break;
-  }//switch
-  return;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlRemoveChildren(nsAVLNode*& aRootNode,nsAVLNode*& anotherNode, PRBool& delOk){
-  eAVLStatus result=eAVL_ok;
-  
-  if(!anotherNode->mRight){
-    aRootNode->mValue=anotherNode->mValue; //swap
-    anotherNode=anotherNode->mLeft;
-    delOk=PR_TRUE;
-  }
-  else{
-    avlRemoveChildren(aRootNode,anotherNode->mRight,delOk);
-    if(delOk)
-      avlBalanceLeft(anotherNode,delOk);
-  }
-
-  return result;
-}
-
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-static eAVLStatus 
-avlRemove(nsAVLNode*& aRootNode, void* anItem, PRBool& delOk,
-          nsAVLNodeComparitor& aComparitor){
-  eAVLStatus result=eAVL_ok;
-
-  if(!aRootNode)
-    delOk=PR_FALSE;
-  else {
-    PRInt32 cmp=aComparitor(anItem,aRootNode->mValue);
-    if(cmp<0){
-      avlRemove(aRootNode->mLeft,anItem,delOk,aComparitor);
-      if(delOk)
-        avlBalanceRight(aRootNode,delOk);
-    }
-    else if(cmp>0){
-      avlRemove(aRootNode->mRight,anItem,delOk,aComparitor);
-      if(delOk)
-        avlBalanceLeft(aRootNode,delOk);
-    }
-    else{ //they match...
-      nsAVLNode* temp=aRootNode;
-      if(!aRootNode->mRight) {
-        aRootNode=aRootNode->mLeft;
-        delOk=PR_TRUE;
-        delete temp;
-      }
-      else if(!aRootNode->mLeft) {
-        aRootNode=aRootNode->mRight;
-        delOk=PR_TRUE;
-        delete temp;
-      }
-      else {
-        avlRemoveChildren(aRootNode,aRootNode->mLeft,delOk);
-        if(delOk)
-          avlBalanceRight(aRootNode,delOk);
-      }
-    }
-  }
-
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-eAVLStatus 
-nsAVLTree::AddItem(void* anItem){
-  eAVLStatus result=eAVL_ok;
-
-  nsAVLNode* theNewNode=new nsAVLNode(anItem);
-  result=avlInsert(mRoot,theNewNode,mComparitor);
-  if(eAVL_duplicate!=result)
-    mCount++;
-  else {
-    delete theNewNode;
-  }
-  return result;
-}
-
-/** ------------------------------------------------
- * 
- * 
- * @update gess 4/22/98
- * @param  
- * @return 
- */ //----------------------------------------------
-void* nsAVLTree::FindItem(void* aValue) const{
-  nsAVLNode* result=mRoot;
-  PRInt32 count=0;
-  while(result) {
-    count++;
-    PRInt32 cmp=mComparitor(aValue,result->mValue);
-    if(0==cmp) {
-      //we matched...
-      break;
-    }
-    else if(0>cmp){
-      //theNode was greater...
-      result=result->mLeft;
-    }
-    else {
-      //aValue is greater...
-      result=result->mRight;
-    }
-  }
-  if(result) {
-    return result->mValue;
-  }
-  return nsnull;
-}
-
-
-/**
- * 
- * @update	gess12/30/98
- * @param 
- * @return
- */
-eAVLStatus 
-nsAVLTree::RemoveItem(void* aValue){
-  PRBool delOk=PR_TRUE;
-  eAVLStatus result=avlRemove(mRoot,aValue,delOk,mComparitor);
-  if(eAVL_ok==result)
-    mCount--;
-  return result;
-} 
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void 
-avlForEachDepthFirst(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor){
-  if(aNode) {
-    avlForEachDepthFirst(aNode->mLeft,aFunctor);
-    avlForEachDepthFirst(aNode->mRight,aFunctor);
-    aFunctor(aNode->mValue);
-  }
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void 
-nsAVLTree::ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const{
-  ::avlForEachDepthFirst(mRoot,aFunctor);
-}
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void 
-avlForEach(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
-  if(aNode) {
-    avlForEach(aNode->mLeft,aFunctor);
-    aFunctor(aNode->mValue);
-    avlForEach(aNode->mRight,aFunctor);
-  }
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void 
-nsAVLTree::ForEach(nsAVLNodeFunctor& aFunctor) const{
-  ::avlForEach(mRoot,aFunctor);
-}
-
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-static void* 
-avlFirstThat(nsAVLNode* aNode, nsAVLNodeFunctor& aFunctor) {
-  void* result=nsnull;
-  if(aNode) {
-    result = avlFirstThat(aNode->mLeft,aFunctor);
-    if (result) {
-      return result;
-    }
-    result = aFunctor(aNode->mValue);
-    if (result) {
-      return result;
-    }
-    result = avlFirstThat(aNode->mRight,aFunctor);
-  }
-  return result;
-}
-
-/**
- * 
- * @update	gess9/11/98
- * @param 
- * @return
- */
-void* 
-nsAVLTree::FirstThat(nsAVLNodeFunctor& aFunctor) const{
-  return ::avlFirstThat(mRoot,aFunctor);
-}
-

mozilla/parser/htmlparser/src/nsAVLTree.h

@@ -1,74 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1999 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-#ifndef nsAVLTree_h___
-#define nsAVLTree_h___
-
-
-#include "nscore.h"
-
-
-enum eAVLStatus {eAVL_unknown,eAVL_ok,eAVL_fail,eAVL_duplicate};
-
-
-struct nsAVLNode;
-
-/**
- * 
- * @update	gess12/26/98
- * @param anObject1 is the first object to be compared
- * @param anObject2 is the second object to be compared
- * @return -1,0,1 if object1 is less, equal, greater than object2
- */
-class NS_COM nsAVLNodeComparitor {
-public:
-  virtual PRInt32 operator()(void* anItem1,void* anItem2)=0;
-}; 
-
-class NS_COM nsAVLNodeFunctor {
-public:
-  virtual void* operator()(void* anItem)=0;
-};
-
-class NS_COM nsAVLTree {
-public:
-              nsAVLTree(nsAVLNodeComparitor& aComparitor, nsAVLNodeFunctor* aDeallocator);
-              ~nsAVLTree(void);
-
-  PRBool      operator==(const nsAVLTree& aOther) const;
-  PRInt32     GetCount(void) const {return mCount;}
-
-              //main functions...
-  eAVLStatus  AddItem(void* anItem);
-  eAVLStatus  RemoveItem(void* anItem);
-  void*       FindItem(void* anItem) const;
-  void        ForEach(nsAVLNodeFunctor& aFunctor) const;
-  void        ForEachDepthFirst(nsAVLNodeFunctor& aFunctor) const;
-  void*       FirstThat(nsAVLNodeFunctor& aFunctor) const;
-
-protected: 
-
-  nsAVLNode*  mRoot;
-  PRInt32     mCount;
-  nsAVLNodeComparitor&  mComparitor;
-  nsAVLNodeFunctor*     mDeallocator;
-};
-
-
-#endif /* nsAVLTree_h___ */
-

mozilla/string/obsolete/nsStr.cpp

@@ -1,717 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL. 
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-  
-/******************************************************************************************
-  MODULE NOTES:
-
-  This file contains the nsStr data structure.
-  This general purpose buffer management class is used as the basis for our strings.
-  It's benefits include:
-    1. An efficient set of library style functions for manipulating nsStrs
-    2. Support for 1 and 2 byte character strings (which can easily be increased to n)
-    3. Unicode awareness and interoperability.
-
-*******************************************************************************************/
-
-#include "nsStr.h"
-#include "bufferRoutines.h"
-#include "stdio.h"  //only used for printf
-#include "nsCRT.h"
-#include "nsDeque.h"
-
- 
-//static const char* kCallFindChar =  "For better performance, call FindChar() for targets whose length==1.";
-//static const char* kCallRFindChar = "For better performance, call RFindChar() for targets whose length==1.";
-
-static const PRUnichar gCommonEmptyBuffer[1] = {0};
-
-/**
- * This method initializes all the members of the nsStr structure 
- *
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Initialize(nsStr& aDest,eCharSize aCharSize) {
-  aDest.mStr=(char*)gCommonEmptyBuffer;
-  aDest.mLength=0;
-  aDest.mCapacity=0;
-  aDest.mCharSize=aCharSize;
-  aDest.mOwnsBuffer=0;
-}
-
-/**
- * This method initializes all the members of the nsStr structure
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer){
-  aDest.mStr=(aCString) ? aCString : (char*)gCommonEmptyBuffer;
-  aDest.mLength=aLength;
-  aDest.mCapacity=aCapacity;
-  aDest.mCharSize=aCharSize;
-  aDest.mOwnsBuffer=aOwnsBuffer;
-}
-
-
-/**
- * This member destroys the memory buffer owned by an nsStr object (if it actually owns it)
- * @update	gess10/30/98
- * @param 
- * @return
- */
-void nsStr::Destroy(nsStr& aDest) {
-  if((aDest.mStr) && (aDest.mStr!=(char*)gCommonEmptyBuffer)) {
-    Free(aDest);
-  }
-}
-
-
-/**
- * This method gets called when the internal buffer needs
- * to grow to a given size. The original contents are not preserved.
- * @update  gess 3/30/98
- * @param   aNewLength -- new capacity of string in charSize units
- * @return  void
- */
-PRBool nsStr::EnsureCapacity(nsStr& aString,PRUint32 aNewLength) {
-  PRBool result=PR_TRUE;
-  if(aNewLength>aString.mCapacity) {
-    result=Realloc(aString,aNewLength);
-    if(aString.mStr)
-      AddNullTerminator(aString);
-  }
-  return result;
-}
-
-/**
- * This method gets called when the internal buffer needs
- * to grow to a given size. The original contents ARE preserved.
- * @update  gess 3/30/98
- * @param   aNewLength -- new capacity of string in charSize units
- * @return  void
- */
-PRBool nsStr::GrowCapacity(nsStr& aDest,PRUint32 aNewLength) {
-  PRBool result=PR_TRUE;
-  if(aNewLength>aDest.mCapacity) {
-    nsStr theTempStr;
-    nsStr::Initialize(theTempStr,aDest.mCharSize);
-
-    result=EnsureCapacity(theTempStr,aNewLength);
-    if(result) {
-      if(aDest.mLength) {
-        Append(theTempStr,aDest,0,aDest.mLength);        
-      } 
-      Free(aDest);
-      aDest.mStr = theTempStr.mStr;
-      theTempStr.mStr=0; //make sure to null this out so that you don't lose the buffer you just stole...
-      aDest.mLength=theTempStr.mLength;
-      aDest.mCapacity=theTempStr.mCapacity;
-      aDest.mOwnsBuffer=theTempStr.mOwnsBuffer;
-    }
-  }
-  return result;
-}
-
-/**
- * Replaces the contents of aDest with aSource, up to aCount of chars.
- * @update	gess10/30/98
- * @param   aDest is the nsStr that gets changed.
- * @param   aSource is where chars are copied from
- * @param   aCount is the number of chars copied from aSource
- */
-void nsStr::Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount){
-  if(&aDest!=&aSource){
-    Truncate(aDest,0);
-    Append(aDest,aSource,anOffset,aCount);
-  }
-}
-
-/**
- * This method appends the given nsStr to this one. Note that we have to 
- * pay attention to the underlying char-size of both structs.
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be manipulated
- * @param   aSource is where char are copied from
- * @aCount  is the number of bytes to be copied 
- */
-void nsStr::Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount){
-  if(anOffset<aSource.mLength){
-    PRUint32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
-    PRUint32 theLength=(anOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-anOffset);
-    if(0<theLength){
-      
-      PRBool isBigEnough=PR_TRUE;
-      if(aDest.mLength+theLength > aDest.mCapacity) {
-        isBigEnough=GrowCapacity(aDest,aDest.mLength+theLength);
-      }
-
-      if(isBigEnough) {
-        //now append new chars, starting at offset
-        (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDest.mLength,aSource.mStr,anOffset,theLength);
-
-        aDest.mLength+=theLength;
-        AddNullTerminator(aDest);
-      }
-    }
-  }
-}
-
-
-/**
- * This method inserts up to "aCount" chars from a source nsStr into a dest nsStr.
- * @update	gess10/30/98
- * @param   aDest is the nsStr that gets changed
- * @param   aDestOffset is where in aDest the insertion is to occur
- * @param   aSource is where chars are copied from
- * @param   aSrcOffset is where in aSource chars are copied from
- * @param   aCount is the number of chars from aSource to be inserted into aDest
- */
-void nsStr::Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount){
-  //there are a few cases for insert:
-  //  1. You're inserting chars into an empty string (assign)
-  //  2. You're inserting onto the end of a string (append)
-  //  3. You're inserting onto the 1..n-1 pos of a string (the hard case).
-  if(0<aSource.mLength){
-    if(aDest.mLength){
-      if(aDestOffset<aDest.mLength){
-        PRInt32 theRealLen=(aCount<0) ? aSource.mLength : MinInt(aCount,aSource.mLength);
-        PRInt32 theLength=(aSrcOffset+theRealLen<aSource.mLength) ? theRealLen : (aSource.mLength-aSrcOffset);
-
-        if(aSrcOffset<aSource.mLength) {
-            //here's the only new case we have to handle. 
-            //chars are really being inserted into our buffer...
-
-          if(aDest.mLength+theLength > aDest.mCapacity) {
-            nsStr theTempStr;
-            nsStr::Initialize(theTempStr,aDest.mCharSize);
-
-            PRBool isBigEnough=EnsureCapacity(theTempStr,aDest.mLength+theLength);  //grow the temp buffer to the right size
-
-            if(isBigEnough) {
-              if(aDestOffset) {
-                Append(theTempStr,aDest,0,aDestOffset); //first copy leftmost data...
-              } 
-              
-              Append(theTempStr,aSource,0,aSource.mLength); //next copy inserted (new) data
-            
-              PRUint32 theRemains=aDest.mLength-aDestOffset;
-              if(theRemains) {
-                Append(theTempStr,aDest,aDestOffset,theRemains); //next copy rightmost data
-              }
-
-              Free(aDest);
-              aDest.mStr = theTempStr.mStr;
-              theTempStr.mStr=0; //make sure to null this out so that you don't lose the buffer you just stole...
-              aDest.mCapacity=theTempStr.mCapacity;
-              aDest.mOwnsBuffer=theTempStr.mOwnsBuffer;
-            }
-
-          }
-
-          else {
-              //shift the chars right by theDelta...
-            (*gShiftChars[aDest.mCharSize][KSHIFTRIGHT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
-      
-            //now insert new chars, starting at offset
-            (*gCopyChars[aSource.mCharSize][aDest.mCharSize])(aDest.mStr,aDestOffset,aSource.mStr,aSrcOffset,theLength);
-          }
-
-            //finally, make sure to update the string length...
-          aDest.mLength+=theLength;
-          AddNullTerminator(aDest);
-
-        }//if
-        //else nothing to do!
-      }
-      else Append(aDest,aSource,0,aCount);
-    }
-    else Append(aDest,aSource,0,aCount);
-  }
-}
-
-
-/**
- * This method deletes up to aCount chars from aDest
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be manipulated
- * @param   aDestOffset is where in aDest deletion is to occur
- * @param   aCount is the number of chars to be deleted in aDest
- */
-void nsStr::Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount){
-  if(aDestOffset<aDest.mLength){
-
-    PRUint32 theDelta=aDest.mLength-aDestOffset;
-    PRUint32 theLength=(theDelta<aCount) ? theDelta : aCount;
-
-    if(aDestOffset+theLength<aDest.mLength) {
-
-      //if you're here, it means we're cutting chars out of the middle of the string...
-      //so shift the chars left by theLength...
-      (*gShiftChars[aDest.mCharSize][KSHIFTLEFT])(aDest.mStr,aDest.mLength,aDestOffset,theLength);
-      aDest.mLength-=theLength;
-      AddNullTerminator(aDest);
-    }
-    else Truncate(aDest,aDestOffset);
-  }//if
-}
-
-/**
- * This method truncates the given nsStr at given offset
- * @update	gess10/30/98
- * @param   aDest is the nsStr to be truncated
- * @param   aDestOffset is where in aDest truncation is to occur
- */
-void nsStr::Truncate(nsStr& aDest,PRUint32 aDestOffset){
-  if(aDestOffset<aDest.mLength){
-    aDest.mLength=aDestOffset;
-    AddNullTerminator(aDest);
-  }
-}
-
-
-/**
- * This method forces the given string to upper or lowercase
- * @update	gess1/7/99
- * @param   aDest is the string you're going to change
- * @param   aToUpper: if TRUE, then we go uppercase, otherwise we go lowercase
- * @return
- */
-void nsStr::ChangeCase(nsStr& aDest,PRBool aToUpper) {
-  // somehow UnicharUtil return failed, fallback to the old ascii only code
-  gCaseConverters[aDest.mCharSize](aDest.mStr,aDest.mLength,aToUpper);
-}
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
-
-  if((aDest.mLength>0) && aSet){
-    PRInt32 theIndex=-1;
-    PRInt32 theMax=aDest.mLength;
-    PRInt32 theSetLen=nsCRT::strlen(aSet);
-
-    if(aEliminateLeading) {
-      while(++theIndex<=theMax) {
-        PRUnichar theChar=GetCharAt(aDest,theIndex);
-        PRInt32 thePos=gFindChars[eOneByte](aSet,theSetLen,0,theChar,PR_FALSE);
-        if(kNotFound==thePos)
-          break;
-      }
-      if(0<theIndex) {
-        if(theIndex<theMax) {
-          Delete(aDest,0,theIndex);
-        }
-        else Truncate(aDest,0);
-      }
-    }
-
-    if(aEliminateTrailing) {
-      theIndex=aDest.mLength;
-      PRInt32 theNewLen=theIndex;
-      while(--theIndex>0) {
-        PRUnichar theChar=GetCharAt(aDest,theIndex);  //read at end now...
-        PRInt32 thePos=gFindChars[eOneByte](aSet,theSetLen,0,theChar,PR_FALSE);
-        if(kNotFound<thePos) 
-          theNewLen=theIndex;
-        else break;
-      }
-      if(theNewLen<theMax) {
-        Truncate(aDest,theNewLen);
-      }
-    }
-
-  }
-}
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::CompressSet(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing){
-  Trim(aDest,aSet,aEliminateLeading,aEliminateTrailing);
-  PRUint32 aNewLen=gCompressChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet);
-  aDest.mLength=aNewLen;
-}
-
-
-/**
- * 
- * @update	gess1/7/99
- * @param 
- * @return
- */
-void nsStr::StripChars(nsStr& aDest,const char* aSet){
-  if((0<aDest.mLength) && (aSet)) {
-    PRUint32 aNewLen=gStripChars[aDest.mCharSize](aDest.mStr,aDest.mLength,aSet);
-    aDest.mLength=aNewLen;
-  }
-}
-
-
-  /**************************************************************
-    Searching methods...
-   **************************************************************/
-
-
-/**
- *  This searches aDest for a given substring
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   aTarget is the substring you're trying to find.
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::FindSubstr(const nsStr& aDest,const nsStr& aTarget, PRBool aIgnoreCase,PRInt32 anOffset) {
-  // NS_PRECONDITION(aTarget.mLength!=1,kCallFindChar);
-
-  PRInt32 result=kNotFound;
-  
-  if((0<aDest.mLength) && (anOffset<(PRInt32)aDest.mLength)) {
-    PRInt32 theMax=aDest.mLength-aTarget.mLength;
-    PRInt32 index=(0<=anOffset) ? anOffset : 0;
-    
-    if((aDest.mLength>=aTarget.mLength) && (aTarget.mLength>0) && (index>=0)){
-      PRInt32 theTargetMax=aTarget.mLength;
-      while(index<=theMax) {
-        PRInt32 theSubIndex=-1;
-        PRBool  matches=PR_TRUE;
-        while((++theSubIndex<theTargetMax) && (matches)){
-          PRUnichar theChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aDest,index+theSubIndex)) : GetCharAt(aDest,index+theSubIndex);
-          PRUnichar theTargetChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aTarget,theSubIndex)) : GetCharAt(aTarget,theSubIndex);
-          matches=PRBool(theChar==theTargetChar);
-        }
-        if(matches) { 
-          result=index;
-          break;
-        }
-        index++;
-      } //while
-    }//if
-  }//if
-  return result;
-}
-
-
-/**
- *  This searches aDest for a given character 
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   char is the character you're trying to find.
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset) {
-  PRInt32 result=kNotFound;
-  if((0<aDest.mLength) && (anOffset<(PRInt32)aDest.mLength)) {
-    PRUint32 index=(0<=anOffset) ? (PRUint32)anOffset : 0;
-    result=gFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,index,aChar,aIgnoreCase);
-  }
-  return result;
-}
-
-
-/**
- *  This searches aDest for a character found in aSet. 
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   aSet contains a list of chars to be searched for
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset) {
-  //NS_PRECONDITION(aSet.mLength!=1,kCallFindChar);
-
-  PRInt32 index=(0<=anOffset) ? anOffset-1 : -1;
-  PRInt32 thePos;
-
-    //Note that the search is inverted here. We're scanning aDest, one char at a time
-    //but doing the search against the given set. That's why we use 0 as the offset below.
-  if((0<aDest.mLength) && (0<aSet.mLength)){
-    while(++index<(PRInt32)aDest.mLength) {
-      PRUnichar theChar=GetCharAt(aDest,index);
-      thePos=gFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase);
-      if(kNotFound!=thePos)
-        return index;
-    } //while
-  }
-  return kNotFound;
-}
-
-  /**************************************************************
-    Reverse Searching methods...
-   **************************************************************/
-
-
-/**
- *  This searches aDest (in reverse) for a given substring
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   aTarget is the substring you're trying to find.
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search (counting from left)
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::RFindSubstr(const nsStr& aDest,const nsStr& aTarget, PRBool aIgnoreCase,PRInt32 anOffset) {
-  //NS_PRECONDITION(aTarget.mLength!=1,kCallRFindChar);
-
-  PRInt32 result=kNotFound;
-
-  if((0<aDest.mLength) && (anOffset<(PRInt32)aDest.mLength)) {
-    PRInt32 index=(0<=anOffset) ? anOffset : aDest.mLength-1;
-
-    if((aDest.mLength>=aTarget.mLength) && (aTarget.mLength>0) && (index>=0)){
-
-      nsStr theCopy;
-      nsStr::Initialize(theCopy,eOneByte);
-      nsStr::Assign(theCopy,aTarget,0,aTarget.mLength);
-      if(aIgnoreCase){
-        nsStr::ChangeCase(theCopy,PR_FALSE); //force to lowercase
-      }
-    
-      PRInt32   theTargetMax=theCopy.mLength;
-      while(index>=0) {
-        PRInt32 theSubIndex=-1;
-        PRBool  matches=PR_FALSE;
-        if(index+theCopy.mLength<=aDest.mLength) {
-          matches=PR_TRUE;
-          while((++theSubIndex<theTargetMax) && (matches)){
-            PRUnichar theDestChar=(aIgnoreCase) ? nsCRT::ToLower(GetCharAt(aDest,index+theSubIndex)) : GetCharAt(aDest,index+theSubIndex);
-            PRUnichar theTargetChar=GetCharAt(theCopy,theSubIndex);
-            matches=PRBool(theDestChar==theTargetChar);
-          } //while
-        } //if
-        if(matches) {
-          result=index;
-          break;
-        }
-        index--;
-      } //while
-      nsStr::Destroy(theCopy);
-    }//if
-  }//if
-  return result;
-}
- 
-
-/**
- *  This searches aDest (in reverse) for a given character 
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   char is the character you're trying to find.
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset) {
-  PRInt32 result=kNotFound;
-  if((0<aDest.mLength) && (anOffset<(PRInt32)aDest.mLength)) {
-    PRUint32 index=(0<=anOffset) ? anOffset : aDest.mLength-1;
-    result=gRFindChars[aDest.mCharSize](aDest.mStr,aDest.mLength,index,aChar,aIgnoreCase);
-  }
-  return result;
-}
-
-/**
- *  This searches aDest (in reverese) for a character found in aSet. 
- *  
- *  @update  gess 3/25/98
- *  @param   aDest string to search
- *  @param   aSet contains a list of chars to be searched for
- *  @param   aIgnorecase indicates case sensitivity of search
- *  @param   anOffset tells us where to start the search
- *  @return  index in aDest where member of aSet occurs, or -1 if not found
- */
-PRInt32 nsStr::RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset) {
-  //NS_PRECONDITION(aSet.mLength!=1,kCallRFindChar);
-
-  PRInt32 index=(0<=anOffset) ? anOffset : aDest.mLength;
-  PRInt32 thePos;
-
-    //note that the search is inverted here. We're scanning aDest, one char at a time
-    //but doing the search against the given set. That's why we use 0 as the offset below.
-  if(0<aDest.mLength) {
-    while(--index>=0) {
-      PRUnichar theChar=GetCharAt(aDest,index);
-      thePos=gFindChars[aSet.mCharSize](aSet.mStr,aSet.mLength,0,theChar,aIgnoreCase);
-      if(kNotFound!=thePos)
-        return index;
-    } //while
-  }
-  return kNotFound;
-}
-
-
-/**
- * Compare source and dest strings, up to an (optional max) number of chars
- * @param   aDest is the first str to compare
- * @param   aSource is the second str to compare
- * @param   aCount -- if (-1), then we use length of longer string; if (0<aCount) then it gives the max # of chars to compare
- * @param   aIgnorecase tells us whether to search with case sensitivity
- * @return  aDest<aSource=-1;aDest==aSource==0;aDest>aSource=1
- */
-PRInt32 nsStr::Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase) {
-  PRInt32 result=0;
-
-  if(aCount) {
-    PRInt32 minlen=(aSource.mLength<aDest.mLength) ? aSource.mLength : aDest.mLength;
-
-    if(0==minlen) {
-      if ((aDest.mLength == 0) && (aSource.mLength == 0))
-        return 0;
-      if (aDest.mLength == 0)
-        return -1;
-      return 1;
-    }
-
-    PRInt32 maxlen=(aSource.mLength<aDest.mLength) ? aDest.mLength : aSource.mLength;
-    aCount = (aCount<0) ? maxlen : MinInt(aCount,maxlen);
-    result=(*gCompare[aDest.mCharSize][aSource.mCharSize])(aDest.mStr,aSource.mStr,aCount,aIgnoreCase);
-  }
-  return result;
-}
-
-//----------------------------------------------------------------------------------------
-
-PRBool nsStr::Alloc(nsStr& aDest,PRUint32 aCount) {
-
-  static int mAllocCount=0;
-  mAllocCount++;
-
-  //we're given the acount value in charunits; now scale up to next multiple.
-  PRUint32	theNewCapacity=kDefaultStringSize;
-  while(theNewCapacity<aCount){ 
-		theNewCapacity<<=1;
-  }
-
-  aDest.mCapacity=theNewCapacity++;
-  PRUint32 theSize=(theNewCapacity<<aDest.mCharSize);
-  aDest.mStr = (char*)nsAllocator::Alloc(theSize);
-
-  PRBool result=PR_FALSE;
-  if(aDest.mStr) {
-    aDest.mOwnsBuffer=1;
-    result=PR_TRUE;
-  }
-  return result;
-}
-
-PRBool nsStr::Free(nsStr& aDest){
-  if(aDest.mStr){
-    if(aDest.mOwnsBuffer){
-      nsAllocator::Free(aDest.mStr);
-    }
-    aDest.mStr=0;
-    aDest.mOwnsBuffer=0;
-    return PR_TRUE;
-  }
-  return PR_FALSE;
-}
-
-PRBool nsStr::Realloc(nsStr& aDest,PRUint32 aCount){
-
-  nsStr temp;
-  memcpy(&temp,&aDest,sizeof(aDest));
-
-  PRBool result=Alloc(temp,aCount);
-  if(result) {
-    Free(aDest);
-    aDest.mStr=temp.mStr;
-    aDest.mCapacity=temp.mCapacity;
-    aDest.mOwnsBuffer=temp.mOwnsBuffer;
-  }
-  return result;
-}
-
-//----------------------------------------------------------------------------------------
-
-CBufDescriptor::CBufDescriptor(char* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
-  mBuffer=aString;
-  mCharSize=eOneByte;
-  mStackBased=aStackBased;
-  mIsConst=PR_FALSE;
-  mLength=mCapacity=0;
-  if(aString && aCapacity>1) {
-    mCapacity=aCapacity-1;
-    mLength=(-1==aLength) ? strlen(aString) : aLength;
-    if(mLength>PRInt32(mCapacity))
-      mLength=mCapacity;
-  }
-}
-
-CBufDescriptor::CBufDescriptor(const char* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
-  mBuffer=(char*)aString;
-  mCharSize=eOneByte;
-  mStackBased=aStackBased;
-  mIsConst=PR_TRUE;
-  mLength=mCapacity=0;
-  if(aString && aCapacity>1) {
-    mCapacity=aCapacity-1;
-    mLength=(-1==aLength) ? strlen(aString) : aLength;
-    if(mLength>PRInt32(mCapacity))
-      mLength=mCapacity;
-  }
-}
-
-
-CBufDescriptor::CBufDescriptor(PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
-  mBuffer=(char*)aString;
-  mCharSize=eTwoByte;
-  mStackBased=aStackBased;
-  mLength=mCapacity=0;
-  mIsConst=PR_FALSE;
-  if(aString && aCapacity>1) {
-    mCapacity=aCapacity-1;
-    mLength=(-1==aLength) ? nsCRT::strlen(aString) : aLength;
-    if(mLength>PRInt32(mCapacity))
-      mLength=mCapacity;
-  }
-}
-
-CBufDescriptor::CBufDescriptor(const PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength) { 
-  mBuffer=(char*)aString;
-  mCharSize=eTwoByte;
-  mStackBased=aStackBased;
-  mLength=mCapacity=0;
-  mIsConst=PR_TRUE;
-  if(aString && aCapacity>1) {
-    mCapacity=aCapacity-1;
-    mLength=(-1==aLength) ? nsCRT::strlen(aString) : aLength;
-    if(mLength>PRInt32(mCapacity))
-      mLength=mCapacity;
-  }
-}
-
-//----------------------------------------------------------------------------------------
-
-

mozilla/string/obsolete/nsStr.h

@@ -1,450 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/*
- * The contents of this file are subject to the Netscape Public License
- * Version 1.0 (the "NPL"); you may not use this file except in
- * compliance with the NPL.  You may obtain a copy of the NPL at
- * http://www.mozilla.org/NPL/
- *
- * Software distributed under the NPL is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
- * for the specific language governing rights and limitations under the
- * NPL.
- *
- * The Initial Developer of this code under the NPL is Netscape
- * Communications Corporation.  Portions created by Netscape are
- * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
- * Reserved.
- */
-
-
-/***********************************************************************
-  MODULE NOTES:
-
-    1. There are two philosophies to building string classes:
-        A. Hide the underlying buffer & offer API's allow indirect iteration
-        B. Reveal underlying buffer, risk corruption, but gain performance
-        
-       We chose the option B for performance reasons. 
-
-    2  Our internal buffer always holds capacity+1 bytes.
-
-    The nsStr struct is a simple structure (no methods) that contains
-    the necessary info to be described as a string. This simple struct
-    is manipulated by the static methods provided in this class. 
-    (Which effectively makes this a library that works on structs).
-
-    There are also object-based versions called nsString and nsAutoString
-    which use nsStr but makes it look at feel like an object. 
-
- ***********************************************************************/
-
-/***********************************************************************
-  ASSUMPTIONS:
-
-    1. nsStrings and nsAutoString are always null terminated. 
-    2. If you try to set a null char (via SetChar()) a new length is set
-    3. nsCStrings can be upsampled into nsString without data loss
-    4. Char searching is faster than string searching. Use char interfaces
-       if your needs will allow it.
-    5. It's easy to use the stack for nsAutostring buffer storage (fast too!).
-       See the CBufDescriptor class in this file.
-    6. It's ONLY ok to provide non-null-terminated buffers to Append() and Insert()
-       provided you specify a 0<n value for the optional count argument.
-    7. Downsampling from nsString to nsCString is lossy -- avoid it if possible!
-    8. Calls to ToNewCString() and ToNewUnicode() should be matched with calls to Recycle().
-
- ***********************************************************************/
-
-
-/**********************************************************************************
-  
- AND NOW FOR SOME GENERAL DOCUMENTATION ON STRING USAGE...
-
-    The fundamental datatype in the string library is nsStr. It's a structure that
-    provides the buffer storage and meta-info. It also provides a C-style library
-    of functions for direct manipulation (for those of you who prefer K&R to Bjarne). 
-
-    Here's a diagram of the class hierarchy: 
-
-      nsStr
-        |___nsString
-        |      |
-        |      ------nsAutoString
-        |
-        |___nsCString
-               |
-               ------nsCAutoString
-
-    Why so many string classes? The 4 variants give you the control you need to 
-    determine the best class for your purpose. There are 2 dimensions to this 
-    flexibility: 1) stack vs. heap; and 2) 1-byte chars vs. 2-byte chars.
-
-    Note: While nsAutoString and nsCAutoString begin life using stack-based storage,
-          they may not stay that way. Like all nsString classes, autostrings will
-          automatically grow to contain the data you provide. When autostrings
-          grow beyond their intrinsic buffer, they switch to heap based allocations.
-          (We avoid alloca to avoid considerable platform difficulties; see the 
-           GNU documentation for more details).
-
-    I should also briefly mention that all the string classes use a "memory agent" 
-    object to perform memory operations. This class proxies the standard nsAllocator
-    for actual memory calls, but knows the structure of nsStr making heap operations
-    more localized.
-    
-
-  CHOOSING A STRING CLASS:
-
-    In order to choose a string class for you purpose, use this handy table:
-
-                        heap-based    stack-based
-                    -----------------------------------
-        ascii data  |   nsCString     nsCAutoString   |
-                    |----------------------------------
-      unicode data  |    nsString      nsAutoString   |
-                    ----------------------------------- 
-    
-  
-    Note: The i18n folks will stenuously object if we get too carried away with the
-          use of nsCString's that pass interface boundaries. Try to limit your
-          use of these to external interfaces that demand them, or for your own
-          private purposes in cases where they'll never be seen by humans. 
-
-    
-  PERFORMANCE CONSIDERATIONS:
-
-    Here are a few tricks to know in order to get better string performance: 
-    
-      1) Try to limit conversions between ascii and unicode; By sticking with nsString
-         wherever possible your code will be i18n-compliant.
-
-
-      2) Preallocating your string buffer cuts down trips to the allocator. So if you
-         have need for an arbitrarily large buffer, pre-size it like this:
-
-         {
-           nsString mBuffer;
-           mBuffer.SetCapacity(aReasonableSize);
-         }
-
-      3) Allocating nsAutoString or nsCAutoString on the heap is memory inefficient
-         (after all, the whole point is to avoid a heap allocation of the buffer).
-
-
-      4) Consider using an autoString to write into your arbitrarily-sized stack buffers, rather
-         than it's own buffers.
-
-         For example, let's say you're going to call printf() to emit pretty-printed debug output 
-         of your object. You know from experience that the pretty-printed version of your object 
-         exceeds the capacity of an autostring. Ignoring memory considerations, you could simply 
-         use nsCString, appending the stringized version of each of your class's data members. 
-         This will probably result in calls to the heap manager. 
-
-         But there's a way to do this without necessarily having to call the heap manager.
-         All you do is declare a stack based buffer and instruct nsCString to use that instead 
-         of it's own internal buffer by using the CBufDescriptor class:
-         
-         {
-           char theBuffer[256];
-           CBufDescritor theBufDecriptor( theBuffer, PR_TRUE, sizeof(theBuffer), 0);
-           nsCAutoString s3( theBufDescriptor );
-           s3="HELLO, my name is inigo montoya, you killed my father, prepare to die!.";
-         }
-
-         The assignment statment to s3 will cause the given string to be written to your
-         stack-based buffer via the normal nsString/nsCString interfaces. Cool, huh?  
-         Note however that just like any other nsStringXXX use, if you write more data 
-         than will fit in the buffer, a visit to the heap manager will be in order. 
-     
-
- **********************************************************************************/
-
-
-#ifndef _nsStr
-#define _nsStr
-
-#include "nscore.h"
-#include "nsIAllocator.h"
-#include <string.h>
-
-//----------------------------------------------------------------------------------------
-
-enum  eCharSize {eOneByte=0,eTwoByte=1};
-#define kDefaultCharSize eTwoByte
-#define kRadix10        (10)
-#define kRadix16        (16)
-#define kAutoDetect     (100)
-#define kRadixUnknown   (kAutoDetect+1)
-const   PRInt32 kDefaultStringSize = 64;
-const   PRInt32 kNotFound = -1;
-
-
-//----------------------------------------------------------------------------------------
-
-class NS_COM CBufDescriptor {
-public:
-  CBufDescriptor(char* aString,           PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
-  CBufDescriptor(const char* aString,     PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
-  CBufDescriptor(PRUnichar* aString,      PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
-  CBufDescriptor(const PRUnichar* aString,PRBool aStackBased,PRUint32 aCapacity,PRInt32 aLength=-1);
-
-  char*     mBuffer;
-  eCharSize mCharSize;
-  PRUint32  mCapacity;
-  PRInt32   mLength;
-  PRBool    mStackBased;
-  PRBool    mIsConst;
-};
-
-//----------------------------------------------------------------------------------------
-
-
-struct NS_COM nsStr {  
-
-//----------------------------------------------------------------------------------------
-
-  nsStr() {
-    MOZ_COUNT_CTOR(nsStr);
-  }
-
-  ~nsStr() {
-    MOZ_COUNT_DTOR(nsStr);
-  }
-
- /**
-  * This method initializes an nsStr for use
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be initialized
-  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
-  */
-  static void Initialize(nsStr& aDest,eCharSize aCharSize);
-
- /**
-  * This method initializes an nsStr for use
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be initialized
-  * @param  aCharSize tells us the requested char size (1 or 2 bytes)
-  */
-  static void Initialize(nsStr& aDest,char* aCString,PRUint32 aCapacity,PRUint32 aLength,eCharSize aCharSize,PRBool aOwnsBuffer);
-
- /**
-  * This method destroys the given nsStr, and *MAY* 
-  * deallocate it's memory depending on the setting
-  * of the internal mOwnsBUffer flag.
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be manipulated
-  * @param  anAgent is the allocator to be used to the nsStr
-  */
-  static void Destroy(nsStr& aDest); 
-
- /**
-  * These methods are where memory allocation/reallocation occur. 
-  *
-  * @update	gess 01/04/99
-  * @param  aString is the nsStr to be manipulated
-  * @param  anAgent is the allocator to be used on the nsStr
-  * @return  
-  */
-  static PRBool EnsureCapacity(nsStr& aString,PRUint32 aNewLength);
-  static PRBool GrowCapacity(nsStr& aString,PRUint32 aNewLength);
-
- /**
-  * These methods are used to append content to the given nsStr
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aSource is the buffer to be copied from
-  * @param  anOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to copy
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Append(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount);
-
- /**
-  * These methods are used to assign contents of a source string to dest string
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aSource is the buffer to be copied from
-  * @param  anOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to copy
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Assign(nsStr& aDest,const nsStr& aSource,PRUint32 anOffset,PRInt32 aCount);
-
- /**
-  * These methods are used to insert content from source string to the dest nsStr
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aDestOffset tells us where in dest to start insertion
-  * @param  aSource is the buffer to be copied from
-  * @param  aSrcOffset tells us where in source to start copying
-  * @param  aCount tells us the (max) # of chars to insert
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Insert( nsStr& aDest,PRUint32 aDestOffset,const nsStr& aSource,PRUint32 aSrcOffset,PRInt32 aCount);
-
- /**
-  * This method deletes chars from the given str. 
-  * The given allocator may choose to resize the str as well.
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be deleted from
-  * @param  aDestOffset tells us where in dest to start deleting
-  * @param  aCount tells us the (max) # of chars to delete
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Delete(nsStr& aDest,PRUint32 aDestOffset,PRUint32 aCount);
-
- /**
-  * This method is used to truncate the given string.
-  * The given allocator may choose to resize the str as well (but it's not likely).
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be appended to
-  * @param  aDestOffset tells us where in dest to start insertion
-  * @param  aSource is the buffer to be copied from
-  * @param  aSrcOffset tells us where in source to start copying
-  * @param  anAgent is the allocator to be used for alloc/free operations
-  */
-  static void Truncate(nsStr& aDest,PRUint32 aDestOffset);
-
- /**
-  * This method is used to perform a case conversion on the given string
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be case shifted
-  * @param  toUpper tells us to go upper vs. lower
-  */
-  static void ChangeCase(nsStr& aDest,PRBool aToUpper);
-
-
-  /**
-   * This method trims chars (given in aSet) from the edges of given buffer 
-   *
-   * @update	gess 01/04/99
-   * @param   aDest is the buffer to be manipulated
-   * @param   aSet tells us which chars to remove from given buffer
-   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
-   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
-   */
-  static void Trim(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing);
-  
-  /**
-   * This method compresses duplicate runs of a given char from the given buffer 
-   *
-   * @update	gess 01/04/99
-   * @param   aDest is the buffer to be manipulated
-   * @param   aSet tells us which chars to compress from given buffer
-   * @param   aChar is the replacement char
-   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
-   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
-   */
-  static void CompressSet(nsStr& aDest,const char* aSet,PRBool aEliminateLeading,PRBool aEliminateTrailing);
-
-  /**
-   * This method removes all occurances of chars in given set from aDest 
-   *
-   * @update	gess 01/04/99
-   * @param   aDest is the buffer to be manipulated
-   * @param   aSet tells us which chars to compress from given buffer
-   * @param   aChar is the replacement char
-   * @param   aEliminateLeading tells us whether to strip chars from the start of the buffer
-   * @param   aEliminateTrailing tells us whether to strip chars from the start of the buffer
-   */
-  static void StripChars(nsStr& aDest,const char* aSet);
-
-  /**
-   * This method compares the data bewteen two nsStr's 
-   *
-   * @update	gess 01/04/99
-   * @param   aStr1 is the first buffer to be compared
-   * @param   aStr2 is the 2nd buffer to be compared
-   * @param   aCount is the number of chars to compare
-   * @param   aIgnorecase tells us whether to use a case-sensitive comparison
-   * @return  -1,0,1 depending on <,==,>
-   */
-  static PRInt32  Compare(const nsStr& aDest,const nsStr& aSource,PRInt32 aCount,PRBool aIgnoreCase);
-
- /**
-  * These methods scan the given string for 1 or more chars in a given direction
-  *
-  * @update	gess 01/04/99
-  * @param  aDest is the nsStr to be searched to
-  * @param  aSource (or aChar) is the substr we're looking to find
-  * @param  aIgnoreCase tells us whether to search in a case-sensitive manner
-  * @param  anOffset tells us where in the dest string to start searching
-  * @return the index of the source (substr) in dest, or -1 (kNotFound) if not found.
-  */
-  static PRInt32 FindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset);
-  static PRInt32 FindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset);
-  static PRInt32 FindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset);
-
-  static PRInt32 RFindSubstr(const nsStr& aDest,const nsStr& aSource, PRBool aIgnoreCase,PRInt32 anOffset);
-  static PRInt32 RFindChar(const nsStr& aDest,PRUnichar aChar, PRBool aIgnoreCase,PRInt32 anOffset);
-  static PRInt32 RFindCharInSet(const nsStr& aDest,const nsStr& aSet,PRBool aIgnoreCase,PRInt32 anOffset);
-
-
-  PRUint32        mLength;
-  PRUint32        mCapacity;
-  eCharSize       mCharSize;
-  PRBool          mOwnsBuffer;
-
-  union { 
-    char*         mStr;
-    PRUnichar*    mUStr;
-  };
-
-private:
-  static PRBool Alloc(nsStr& aString,PRUint32 aCount);
-  static PRBool Realloc(nsStr& aString,PRUint32 aCount);
-  static PRBool Free(nsStr& aString);
-
-};
-
-/**************************************************************
-  A couple of tiny helper methods used in the string classes.
- **************************************************************/
-
-inline PRInt32 MinInt(PRInt32 anInt1,PRInt32 anInt2){
-  return (anInt1<anInt2) ? anInt1 : anInt2;
-}
-
-inline PRInt32 MaxInt(PRInt32 anInt1,PRInt32 anInt2){
-  return (anInt1<anInt2) ? anInt2 : anInt1;
-}
-
-inline void AddNullTerminator(nsStr& aDest) {
-  if(eTwoByte==aDest.mCharSize) 
-    aDest.mUStr[aDest.mLength]=0;
-  else aDest.mStr[aDest.mLength]=0;
-}
-
-/**
- * Return the given buffer to the heap manager. Calls allocator::Free()
- * @return string length
- */
-inline void Recycle( char* aBuffer) { nsAllocator::Free(aBuffer); }
-inline void Recycle( PRUnichar* aBuffer) { nsAllocator::Free(aBuffer); }
-
-/**
-* This method is used to access a given char in the given string
-*
-* @update	gess 01/04/99
-* @param  aDest is the nsStr to be appended to
-* @param  anIndex tells us where in dest to get the char from
-* @return the given char, or 0 if anIndex is out of range
-*/
-inline PRUnichar GetCharAt(const nsStr& aDest,PRUint32 anIndex){
-  if(anIndex<aDest.mLength)  {
-    return (eTwoByte==aDest.mCharSize) ? aDest.mUStr[anIndex] : aDest.mStr[anIndex];
-  }//if
-  return 0;
-}
-
-
-#endif
-