Mercurial > emacs

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.multi-tty	Mon Oct 25 18:17:28 2004 +0000
@@ -0,0 +1,943 @@
+			-*- coding: utf-8; mode: text; -*-
+GOAL
+----
+
+The goal of this branch is to implement support for opening multiple,
+different tty devices and simultaneous X and tty frames from a single
+Emacs session.
+
+Some use cases:
+Emacs is notoriously slow at startup, so most people use another
+editor or emacsclient for quick editing jobs from the console.
+Unfortunately, emacsclient was very awkward to use, because it did not
+support opening a new Emacs frame on the current virtual console.
+Now, with multi-tty support, it can do that.  (Emacsclient starts up
+faster than vi!)
+
+Some Gnus users (including me) run Gnus in an X frame in its own Emacs
+instance, which they typically leave running for weeks.  It would be
+nice if they could connect to this instance from a remote ssh session
+and check their messages without opening a remote X frame or resorting
+to gnus-slave.
+
+WHO IS DOING IT
+---------------
+
+I'm Károly Lőrentey.  My address: lorentey@elte.hu.
+
+Comments, bug reports, suggestions and patches are welcome; send them
+to multi-tty@lists.fnord.hu.
+
+MAILING LISTS
+-------------
+
+The multi-tty mailing list (discussion & bug reports):
+
+    	Address:	multi-tty@lists.fnord.hu
+	Signup:		http://lists.fnord.hu/mailman/listinfo/multi-tty
+	Archive:	http://news.gmane.org/gmane.emacs.multi-tty/
+
+Commit notifications (read-only):
+
+        Address:	multi-tty-commits@lists.fnord.hu
+	Signup:		http://lists.fnord.hu/mailman/listinfo/multi-tty-commits
+
+
+STATUS
+------
+
+The branch is now very stable and almost full-featured.  All of the
+major problems have been fixed, only a few minor issues remain.  (It
+still needs to be ported to Windows/Mac/DOS, though.)  Both multiple
+tty device support and simultaneous X and tty frame support works
+fine.  Emacsclient has been extended to support opening new tty and X
+frames.  It has been changed open new Emacs frames by default.
+
+The multi-tty branch has been scheduled for inclusion in the next
+major release of Emacs (version 22).  I expect the merge into the
+development trunk to occur sometime during next year (2005), after the
+merge of the Unicode branch.
+
+Tested on GNU/Linux, Solaris 8, FreeBSD and OpenBSD.  Please let me
+know if you succeed or fail to use it on other platforms---I'll have a
+few tricky test cases for you.
+
+Known problems:
+
+	* Mac, Windows and DOS support is broken, probably doesn't
+	  even compile -- this will be solved later.
+
+HOW TO GET THE BRANCH
+---------------------
+
+The branch uses GNU Arch (http://www.gnuarch.org) for version control.
+
+Retrieving the latest version of the branch:
+
+	tla register-archive http://lorentey.hu/arch/2004/
+	tla get lorentey@elte.hu--2004/emacs--multi-tty <directory>
+
+This incantation uses my private archive mirror that is hosted on a
+relatively low-bandwidth site; if you are outside Hungary, you will
+probably want to you use the Arch supermirror instead:
+
+	tla register-archive http://mirrors.gnuarch.org/lorentey@elte.hu--2004/
+	tla get lorentey@elte.hu--2004/emacs--multi-tty <directory>
+
+(I use a recent tla development snapshot, but any of the released
+versions of arch will do fine, I think.)  My GPG key id is 0FB27A3F;
+it is available from hkp://wwwkeys.eu.pgp.net/, or my homepage at
+http://lorentey.hu/rolam/gpg.html)
+
+To update your source tree to the latest revision after the first
+checkout, simply use the following command:
+
+	tla replay lorentey@elte.hu--2004/emacs--multi-tty--0
+
+If you are interested, you can find more information about Arch on
+http://wiki.gnuarch.org/.  It's a wonderful source control system, I
+highly recommend it.
+
+If you don't have tla, the branch has a homepage from which you can
+download conventional patches against Emacs CVS HEAD:
+
+	http://lorentey.hu/project/emacs.html
+
+
+COMPILATION
+-----------
+
+The multi-tty branch is compiled the same way as Emacs itself:
+
+	make maintainer-clean  # (If you have compiled Emacs before)
+
+	./configure <your favourite options>
+	make bootstrap
+	make install
+
+If you have strange compilation errors, they may be caused by old
+*.elc files that are left over from an earlier bootstrap.  The `make
+maintainer-clean' target deletes them, so it is a good idea to run
+that before reporting a bug.  (Emacs requires a clean recompilation
+after certain kinds of source code changes.)
+
+TESTING
+-------
+
+To test the multi-tty branch, start up the Emacs server with the
+following commands:
+
+	emacs
+	M-x server-start
+
+and then (from a shell prompt on another terminal) start emacsclient
+with
+	emacsclient -t /optional/file/names...   (for a tty frame)
+	emacsclient /optional/file/names...      (for an X frame)
+
+(Make sure both emacs and emacsclient are multi-tty versions.)
+You'll hopefully have two fully working, independent frames on
+separate terminals. The new frame is closed automatically when you
+finish editing the specified files (C-x #), but delete-frame (C-x 5 0)
+also works.  Of course, you can create frames on more than two tty
+devices.
+
+Creating new frames on the same tty with C-x 5 2 works, and they
+behave the same way as in previous Emacs versions.  If you exit emacs,
+all terminals should be restored to their previous states.
+
+This is work in progress, and probably full of bugs.  You should
+always run emacs from gdb, so that you'll have a live instance to
+debug if something goes wrong.  Please send me
+(multi-tty@lists.fnord.hu) your bug reports.
+
+TIPS & TRICKS
+-------------
+
+I think the best way to use the new Emacs is to have it running inside
+a disconnected GNU screen session, and always use emacsclient for
+normal work.  One advantage of this is that not a single keystroke of
+your work will be lost if the display device that you are using
+crashes, or the network connection times out, or whatever.  (I had an
+extremely unstable X server for some time while I was developing these
+patches, and running Emacs this way has saved me a number of M-x
+recover-session invocations.)
+
+I use the following two bash functions to handle my Emacs sessions:
+
+,----[ ~/.bash_profile
+| # Usage: preload-emacs <name> [<waitp>]
+| #
+| # Preloads the Emacs instance called NAME in a detached screen
+| # session.  Does nothing if the instance is already running.  If WAITP
+| # is non-empty, the function waits until the server starts up and
+| # creates its socket; otherwise it returns immediately.
+| function preload-emacs {
+|     local name="$1"
+|     local waitp="$2"
+|     local screendir="/var/run/screen/S-$USER"
+|     local serverdir="/tmp/emacs$UID"
+|     local emacs=emacs # Or wherever you installed your multi-tty Emacs
+|
+|     if [ -z "$name" ]; then
+| 	echo "Usage: preload-emacs <name> [<waitp>]" >&2
+| 	return 1
+|     fi
+|
+|     if [ ! -e "$screendir"/*."$name" ]; then
+| 	if [ -e "$serverdir/$name" ]; then
+| 	    # Delete leftover socket (for the wait option)
+| 	    rm "$serverdir/$name"
+| 	fi
+| 	screen -dmS "$name" "$emacs" -nw --eval "(setq server-name \"$name\")" -f server-start
+|     fi
+|     if [ ! -z "$waitp" ]; then
+| 	while [ ! -e "$serverdir/$name" ]; do sleep 0.1; done
+|     fi
+|     return 0
+| }
+|
+| # Usage: connect-emacs <name> <args>...
+| #
+| # Connects to the Emacs instance called NAME.  Starts up the instance
+| # if it is not already running.  The rest of the arguments are passed
+| # to emacsclient.
+| function connect-emacs {
+|     local name="$1"
+|     shift
+|
+|     if [ -z "$name" ]; then
+| 	echo "Usage: connect-emacs <name> <args>..." >&2
+|     fi
+|     preload-emacs "$name" wait
+|     emacsclient -s "$name" "$@"
+| }
+|
+| export -f preload-emacs connect-emacs
+|
+| # Preload editor and gnus sessions for speedy initial connects.
+| preload-emacs editor
+| preload-emacs gnus
+`----
+
+,----[ ~/.bashrc
+| alias gnus="connect-emacs gnus"
+| alias edit="connect-emacs editor"
+| alias et="connect-emacs editor -t"
+| alias e=edit
+`----
+
+
+NEWS
+----
+
+For the NEWS file:  (Needs work)
+
+** Support for multiple terminal devices has been added.
+
+*** You can specify a terminal device (`tty' parameter) and a terminal
+    type (`tty-type' parameter) to `make-terminal-frame'.
+
+*** You can test for the presence of multiple terminal support by
+    testing for the `multi-tty' feature.
+
+*** Emacsclient has been extended to support opening a new terminal
+    frame. Its behaviour has been changed to open a new Emacs frame by
+    default.  Use the -c option to get the old behavior of opening
+    files in the currently selected Emacs frame.
+
+*** A make-frame-on-tty function has been added to make it easier to
+    create frames on new terminals.
+
+*** New functions: frame-tty-name, frame-tty-type for accessing
+    terminal parameters, and delete-tty for closing the terminal
+    device.
+
+*** talk.el has been extended for multiple tty support.
+
+
+** Support for simultaneous graphical and terminal frames has been
+   added.
+
+*** The function `make-frame-on-display' now works during a terminal
+    session, and `make-frame-on-tty' works during a graphical session.
+
+*** The `window-system' variable has been made frame-local.
+
+*** The new `initial-window-system' variable contains the
+    `window-system' value for the first frame.
+
+THANKS
+------
+
+The following is a (sadly incomplete) list of people who have
+contributed to the project by testing, submitting patches, bug
+reports, and suggestions.  Thanks!
+
+ARISAWA Akihiro <ari at mbf dot ocn dot ne dot jp>
+Han Boetes <han at mijncomputer dot nl>
+Robert J. Chassell <bob at rattlesnake dot com>
+Romain Francoise <romain at orebokech dot com>
+Ami Fischman <ami at fischman dot org>
+Friedrich Delgado Friedrichs <friedel at nomaden dot org>
+IRIE Tetsuya <irie at t dot email dot ne dot jp>
+Yoshiaki Kasahara <kasahara at nc dot kyushu-u dot ac dot jp>
+Jurej Kubelka <Juraj dot Kubelka at email dot cz>
+David Lichteblau <david at lichteblau dot com>
+Istvan Marko <mi-mtty at kismala dot com>
+Ted Morse <morse at ciholas dot com>
+Dan Nicolaescu <dann at ics dot uci dot edu>
+Gergely Nagy <algernon at debian dot org>
+Mark Plaksin <happy at mcplaksin dot org>
+Francisco Borges <borges at let dot rug dot nl>
+Frank Ruell <stoerte at dreamwarrior dot net>
+Dan Waber <dwaber at logolalia dot com>
+and many others.
+
+Richard Stallman was kind enough to review an earlier version of my
+patches.
+
+CHANGELOG
+---------
+
+See arch logs.
+
+* * *
+
+(The rest of this file consists of my development notes and as such it
+is probably not very interesting for anyone else.)
+
+THINGS TO DO
+------------
+
+** rif->flush_display_optional (NULL) calls should be replaced by a
+   new global function.
+
+** Hunt down display-related functions in frame.el and extend them all
+   to accept display ids.
+
+** Have a look at fatal_error_hook.
+
+** Check if we got term-setup-hook right.
+
+** make-frame does not correctly handle extra parameters in its
+   argument:
+
+	(frame-parameter (make-frame (list (cons 'foobar 42))) 'foobar)
+		=> nil
+
+   (This is likely an error in the CVS trunk.)
+
+** Fix set-input-mode for multi-tty.  It's a truly horrible interface;
+   what if we'd blow it up into several separate functions (with a
+   compatibility definition)?
+
+** Lisp-level stuff that needs to be updated for multi-tty:
+
+	- normal-erase-is-backspace-mode (simple.el)  (rep. by Dan Waber)
+
+
+** The single-keyboard mode of MULTI_KBOARD is extremely confusing
+   sometimes; Emacs does not respond to stimuli from other keyboards.
+   At least a beep or a message would be important, if the single-mode
+   is still required to prevent interference.  (Reported by Dan
+   Nicolaescu.)  (Update: selecting a region with the mouse enables
+   single_kboard under X.  This is very confusing.)  Update:
+   After discussions with Richard, this will be resolved by having
+   locked displays warn the user to wait, and introducing a complex
+   protocol to remotely bail out of single-kboard mode by pressing C-g.
+
+** The terminal customization files in term/*.el tend to change global
+   parameters, which may confuse Emacs with multiple displays.  Change
+   them to tweak only frame-local settings, if possible.
+
+** Dan Nicolaescu suggests that -nw should be added as an alias for -t
+   in emacsclient.  Good idea.  (Alas, implementing this is not
+   trivial, getopt_long does not seem to support two-letter ``short''
+   options.  Patches are welcome.) :-)
+
+** Mark Plaksin suggests that emacsclient should accept the same
+   X-related command-line arguments as Emacs.  Most of the X-related
+   argument-handling is done in Lisp, so this should be quite easy to
+   implement.
+
+** Gergely Nagy suggests that C-x # should only kill the current
+   frame, not any other emacsclient frame that may have the same file
+   opened for editing.  I think I agree with him.
+
+** Miles Bader suggests that C-x C-c on an emacsclient frame should
+   only close the frame, not exit the entire Emacs session.  Update:
+   see above for a function that does this.  Maybe this should be the
+   new default?
+
+** Very strange bug: visible-bell does not work on secondary
+   terminals in xterm and konsole.  The screen does flicker a bit,
+   but it's so quick it isn't noticable.
+
+** Clean up the frame-local variable system.  I think it's ugly and
+   error-prone.  But maybe I just haven't yet fully understood it.
+
+** Move baud_rate to struct display.
+
+** Implement support for starting an interactive Emacs session without
+   an initial frame.  (The user would connect to it and open frames
+   later, with emacsclient.)
+
+** Fix Mac support (I can't do this entirely myself).  Note that the
+   current state of Mac-specific source files in the multi-tty tree
+   are not useful; before starting work on Mac support, revert to
+   pristine, pre-multi-tty versions.
+
+** Fix W32 support (I can't do this entirely myself).  Note that the
+   current state of W32-specific source files in the multi-tty tree
+   are not useful; before starting work on W32 support, revert to
+   pristine, pre-multi-tty versions.
+
+** Fix DOS support (I can't do this entirely myself).  Note that the
+   current state of DOS-specific source files in the multi-tty tree
+   are not useful; before starting work on DOS support, revert to
+   pristine, pre-multi-tty versions.
+
+** Do a grep on XXX and ?? for more issues.
+
+** Understand Emacs's low-level input system (it's black magic) :-)
+   What exactly does interrupt_input do?  I tried to disable it for
+   raw secondary tty support, but it does not seem to do anything
+   useful.  (Update: Look again. X unconditionally enables this, maybe
+   that's why raw terminal support is broken again.  I really do need
+   to understand input.)
+
+** Maybe standard-display-table should be display-local.
+
+DIARY OF CHANGES
+----------------
+
+(ex-TODO items with explanations.)
+
+-- Introduce a new struct for terminal devices.
+
+   (Done, see struct tty_output.  The list of members is not yet
+   complete.)
+
+-- Change the bootstrap procedure to initialize tty_list.
+
+   (Done, but needs review.)
+
+-- Change make-terminal-frame to support specifying another tty.
+
+   (Done, new frame parameters: `tty' and `tty-type'.)
+
+-- Implement support for reading from multiple terminals.
+
+   (Done, read_avail_input tries to read from each terminal, until one
+   succeeds.  MULTI_KBOARD is not used.  Secondary terminals don't send
+   SIGIO!)
+
+   (Update: They do, now.)
+
+   (Update2: After enabling X, they don't.)
+
+-- other-frame should cycle through the frames on the `current'
+   terminal only.
+
+   (Done, by trivially modifiying next_frame and prev_frame.)
+
+-- Support different terminal sizes.
+
+   (Done, no problem.)
+
+-- Make sure terminal resizes are handled gracefully.  (Could be
+   problematic.)
+
+   (Done.  We don't get automatic SIGWINCH for additional ttys,
+   though.)
+
+-- Extend emacsclient to automatically open a new tty when it connects
+   to Emacs.
+
+   (Done.  It's an ugly hack, needs more work.)
+
+-- Redisplay must refresh the topmost frame on *all* terminals, not
+   just the initial terminal.
+
+   (Done, but introduced an ugly redisplay problems.  Ugh.)
+
+-- Fix redisplay problems.
+
+   (Done; it turned out that the entire Wcm structure must be moved
+   inside tty_output.  Why didn't I catch this earlier?)
+
+-- Provide a way for emacsclient to tell Emacs that the tty has been
+   resized.
+
+   (Done, simply forward the SIGWINCH signal.)
+
+-- Each keypress should automatically select the frame corresponding
+   to the terminal that it was coming from.  This means that Emacs
+   must know from which terminal the last keyboard event came from.
+
+   (Done, it was quite simple, the input event system already
+   supported multiple frames.)
+
+-- Fix SIGIO issue with secondary terminals.
+
+   (Done, emacsclient signals Emacs after writing to the proxy pseudo
+   terminal.  Note that this means that multi-tty does not work with
+   raw ttys!)
+
+   (Update: This is bullshit.  There is a read_input_waiting function,
+   extend that somehow.)
+
+   (Update of update: The first update was not right either, extending
+   read_input_waiting was not necessary.  Secondary ttys do seem to
+   send signals on input.)
+
+   (Update^3: Not any more.)
+
+-- Make make-terminal-frame look up the `tty' and `tty-type' frame
+   parameters from the currently selected terminal before the global
+   default.
+
+   (Done.)
+
+-- Put all cached terminal escape sequences into struct tty_output.
+   Currently, they are still stored in global variables, so we don't
+   really support multiple terminal types.
+
+   (Done.  It was not fun.)
+
+-- Implement sane error handling after initialization.  (Currently
+   emacs exits if you specify a bad terminal type.)  The helpful error
+   messages must still be provided when Emacs starts.
+
+   (Done.)
+
+-- Implement terminal deletion, i.e., deleting local frames, closing
+   the tty device and restoring its previous state without exiting
+   Emacs.
+
+   (Done, but at the moment only called when an error happens during
+   initialization.  There is a memory corruption error around this
+   somewhere.)  (Update: now it is fully enabled.)
+
+-- Implement automatic deletion of terminals when the last frame on
+   that terminal is closed.
+
+   (Done.)
+
+-- Restore tty screen after closing the terminal.
+
+   (Done, we do the same as Emacs 21.2 for all terminals.)
+
+-- 'TERM=dumb src/emacs' does not restore the terminal state.
+
+   (Done.)
+
+-- C-g should work on secondary terminals.
+
+   (Done, but the binding is not configurable.)
+
+-- Deal with SIGHUP in Emacs and in emacsclient.  (After this, the
+   server-frames may be removed from server.el.)
+
+   (Done, nothing to do.  It seems that Emacs does not receive SIGHUP
+   from secondary ttys, which is actually a good thing.)  (Update: I
+   think it would be a bad idea to remove server-frames.)
+
+-- Change emacsclient/server.el to support the -t argument better,
+   i.e. automatically close the socket when the frame is closed.
+
+   (Seems to be working OK.)
+
+-- Fix mysterious memory corruption error with tty deletion.  To
+   trigger it, try the following shell command:
+
+	while true; do TERM=no-such-terminal-definition emacsclient -h; done
+
+   Emacs usually dumps core after a few dozen iterations.  (The bug
+   seems to be related to the xfreeing or bzeroing of
+   tty_output.Wcm.  Maybe there are outside references to struct Wcm?
+   Why were these vars collected into a struct before multi-tty
+   support?)
+
+   (Done.  Whew.  It turned out that the problem had nothing to do
+   with hypothetical external references to Wcm, or any other
+   tty_output component; it was simply that delete_tty closed the
+   filehandles of secondary ttys twice, resulting in fclose doubly
+   freeing memory.  Utterly trivial matter.  I love the C's memory
+   management, it puts hair on your chest.)
+
+-- Support raw secondary terminals.  (Note that SIGIO works only on
+   the controlling terminal.) Hint: extend read_input_waiting for
+   multiple ttys and hopefully this will be fixed.
+
+   (Done, it seems to have been working already for some time.  It
+   seems F_SETOWN does work, after all.  Not sure what made it fail
+   earlier, but it seems to be fixed (there were several changes
+   around request_sigio, maybe one of them did it).
+   read_input_waiting is only used in sys_select, don't change
+   it.)  (Update: After adding X support, it's broken again.)
+   (Update^2: No it isn't.) :-)
+
+-- Find out why does Emacs abort when it wants to close its
+   controlling tty.  Hint: chan_process[] array.  Hey, maybe
+   noninterrupt-IO would work, too?  Update: no, there is no process
+   for stdin/out.
+
+   (Done.  Added add/delete_keyboard_wait_descriptor to
+   term_init/delete_tty.  The hint was right, in a way.)
+
+-- Issue with SIGIO: it needs to be disabled during redisplay.  See if
+   fcntl kernel behaviour could be emulated by emacsclient.
+
+   (Done.  Simply disabled the SIGIO emulation hack in emacsclient.)
+   (Update: it was added back.)  (Update^2: and removed again.)
+
+-- server.el: There are issues with saving files in buffers of closed
+   clients.  Try editing a file with emacsclient -f, and (without
+   saving it) do a delete-frame.  The frame is closed without
+   question, and a surprising confirmation prompt appears in another
+   frame.
+
+   (Done.  delete-frame now asks for confirmation if it still has
+   pending buffers, and modified buffers don't seem to be deleted.)
+
+-- emacsclient.el, server.el: Handle eval or file open errors when
+   doing -t.
+
+   (Done.)
+
+-- Make parts of struct tty_output accessible from Lisp.  The device
+   name and the type is sufficient.
+
+   (Done, see frame-tty-name and frame-tty-type.)
+
+-- Export delete_tty to the Lisp environment, for emacsclient.
+
+   (Done, see delete-tty.)
+
+-- Get rid of the accessor macros in termchar.h, or define macros for
+   all members.
+
+   (Done.)
+
+-- Move device-specific parameters (like costs) commonly used by
+   device backends to a common, device-dependent structure.
+
+   (Done.  See struct display_method in termhooks.h.)
+
+-- Fix X support.
+
+   (Done.  Well, it seems to be working.)
+
+-- Allow simultaneous X and tty frames.  (Handling input could be
+   tricky.  Or maybe not.)
+
+   (Done.  Allowed, that is.  It is currently extremely unstable, to
+   the point of being unusable.  The rif variable causes constant
+   core dumps.  Handling input is indeed tricky.)
+
+-- Rewrite multi-tty input in terms of MULTI_KBOARD.
+
+   (Done.  In fact, there was no need to rewrite anything, I just
+   added a kboard member to tty_display_info, and initialized the
+   frame's kboard from there.)
+
+-- Fix rif issue with X-tty combo sessions.  IMHO the best thing to do
+   is to get rid of that global variable (and use the value value in
+   display_method, which is guaranteed to be correct).
+
+   (Done, did exactly that.  Core dumps during combo sessions became
+   much rarer.  In fact, I have not yet met a single one.)
+
+-- Add multi-tty support to talk.el.
+
+   (Done.)
+
+-- Clean up the source of emacsclient.  It is a mess.
+
+   (Done, eliminated stupid proxy-pty kludge.)
+
+-- Fix faces on tty frames during X-tty combo sessions.  There is an
+   init_frame_faces call in init_sys_modes, see if there is a problem
+   with it.
+
+   (Done, there was a stupid mistake in
+   Ftty_supports_face_attributes_p. Colors are broken, though.)
+
+-- C-x 5 2, C-x 5 o, C-x 5 0 on an emacsclient frame unexpectedly
+   exits emacsclient.  This is a result of trying to be clever with
+   delete-frame-functions.
+
+   (Fixed, added delete-tty-after-functions, and changed server.el to
+   use it.)
+
+-- Something with (maybe) multi-keyboard support broke function keys
+   and arrows on ttys during X+tty combo sessions.  Debug this.
+
+   (I can't reproduce it, maybe the terminal type was wrong.)
+
+-- Fix input from raw ttys (again).
+
+   (Now it seems to work all right.)
+
+-- During an X-tty combo session, a (message "Hello") from a tty frame
+   goes to the X frame.  Fix this.
+
+   (Done.  There was a safeguard against writing to the initial
+   terminal frame during bootstrap which prevented echo_area_display
+   from working correctly on a tty frame during a combo session.)
+
+-- If there are no frames on its controlling terminal, Emacs should
+   exit if the user presses C-c there.
+
+   (Done, as far as possible.  See the SIGTERM comment in
+   interrupt_signal on why this seems to be impossible to solve this
+   in general.)
+
+-- During an X session, Emacs seems to read from stdin.  Also, Emacs
+   fails to start without a controlling tty.
+
+   (Fixed by replacing the troublesome termcap display with a dummy
+   bootstrap display during bootstrap.
+
+-- Do tty output through struct display, like graphical display
+   backends.
+
+   (Done.)
+
+-- Define an output_initial value for output_method for the initial
+   frame that is dumped with Emacs.  Checking for this frame (e.g. in
+   cmd_error_internal) is ugly.
+
+   (Done, broking interactive temacs.)
+
+-- The command `emacsclient -t -e '(delete-frame)'' fails to exit.
+
+   (Fixed.)
+
+-- frame-creation-function should always create a frame that is on the
+   same display as the selected frame.  Maybe frame-creation-function
+   should simply be removed and make-frame changed to do the right
+   thing.
+
+   (Done, with a nice hack.  frame-creation-function is now frame-local.)
+
+-- Fix C-g on raw ttys.
+
+   (Done.  I disabled the interrupt/quit keys on all secondary
+   terminals, so Emacs sees C-g as normal input.  This looks like an
+   overkill, because emacsclient has extra code to pass SIGINT to
+   Emacs, so C-g should remain the interrupt/quit key on emacsclient
+   frames.  See the next entry why implementing this distinction would
+   be a bad idea.)
+
+-- Make sure C-g goes to the right frame with ttys.  This is hard, as
+   SIGINT doesn't have a tty parameter. :-(
+
+   (Done, the previous change fixes this as a pleasant side effect.)
+
+-- I have seen a case when Emacs with multiple ttys fell into a loop
+   eating 100% of CPU time.  Strace showed this loop:
+
+	getpid()                                = 30284
+	kill(30284, SIGIO)                      = 0
+	--- SIGIO (I/O possible) @ 0 (0) ---
+	ioctl(6, FIONREAD, [0])                 = -1 EIO (Input/output error)
+	ioctl(5, FIONREAD, [0])                 = -1 EIO (Input/output error)
+	ioctl(0, FIONREAD, [0])                 = 0
+	sigreturn()                             = ? (mask now [])
+	gettimeofday({1072842297, 747760}, NULL) = 0
+	gettimeofday({1072842297, 747806}, NULL) = 0
+	select(9, [0 3 5 6], NULL, NULL, {0, 0}) = 2 (in [5 6], left {0, 0})
+	select(9, [0 3 5 6], NULL, NULL, {0, 0}) = 2 (in [5 6], left {0, 0})
+	gettimeofday({1072842297, 748245}, NULL) = 0
+
+   I have seen something similar with a single X frame, but have not
+   been able to reproduce it for debugging.
+
+   Update: This may have been caused by checking for nread != 0
+   instead of nread > 0 after calling read_socket_hook in
+   read_avail_input.
+
+   (Fixed.  This was caused by unconditionally including stdin in
+   input_wait_mask in init_process.  The select call in
+   wait_reading_process_input always returned immediately, indicating
+   that there is pending input from stdin, which nobody read.
+
+   Note that the above strace output seems to be an unrelated but
+   similar bug.  I think that is now fixed.)
+
+-- Exiting Emacs while there are emacsclient frames doesn't restore the
+   ttys to their default states.
+
+   (This seems to be fixed by some previous change.)
+
+-- Allow opening an X session after -nw.
+
+   (Done.)
+
+-- Fix color handling during tty+X combo sessions.  (It seems that tty
+   sessions automatically convert the face colors to terminal colors
+   when the face is loaded.  This conversion must happen instead on
+   the fly in write_glyphs, which might be problematic, as color
+   approximation is currently done in lisp (term/tty-colors.el).)
+   (Update: hm, colors seem to work fine if I start emacs with -nw and
+   then create an X frame.  Maybe it's just a small buglet somewhere.)
+
+   (Seems to be fixed.  The problem was in startup.el, it did not
+   initialize tty colors when the initial window system was
+   graphical.)
+
+-- emacs -nw --eval '(y-or-n-p "Foobar")' segfaults.  (Reported by
+   Romain Francoise)
+
+   (Fixed, there was a keyboard initialization problem.)
+
+-- Fix interactive use of temacs.  There are face-related SEGVs, most
+   likely because of changes in realize_default_face, realize_face.
+
+   (Fixed.)
+
+-- Don't exit Emacs when the last X connection fails during a
+   multi-display session.
+
+   (Fixed.)
+
+-- Dan Nicolaescu noticed that starting emacsclient on the same
+   terminal device that is the controlling tty of the Emacs process
+   gives unexpected results.
+
+   (Fixed.)
+
+-- Istvan Marko reported that Emacs hang on ttys if it was started
+   from a shell script.
+
+   (Fixed.  There was a bug in the multi-tty version of
+   narrow_foreground_group.  tcsetpgrp blocks if it is called from a
+   process that is not in the same process group as the tty.)
+
+-- emacsclient -t from an Emacs term buffer does not work, complains
+   about face problems.  This can even lock up Emacs (if the recursive
+   frame sets single_kboard).  Update: the face problems are caused by
+   bugs in term.el, not in multi-tty.  The lockup is caused by
+   single_kboard mode, and is not easily resolvable.  The best thing to
+   do is to simply refuse to create a tty frame of type `eterm'.
+
+   (Fixed, changed emacsclient to check for TERM=eterm.  The face
+   complaints seem to be caused by bugs in term.el; they are not
+   related to multi-tty.)
+
+-- Find out the best way to support suspending Emacs with multiple
+   ttys.  My guess: disable it on the controlling tty, but from other
+   ttys pass it on to emacsclient somehow.  (It is (I hope) trivial to
+   extend emacsclient to handle suspend/resume.  A `kill -STOP' almost
+   works right now.)
+
+   (Done.  I needed to play with signal handling and the server
+   protocol a bit to make emacsclient behave as a normal UNIX program
+   wrt foreground/background process groups.)
+
+-- There is a flicker during the startup of `emacs -nw'; it's as if
+   the terminal is initialized, reset and then initialialized again.
+   Debug this.  (Hint: narrow_foreground_group is called twice during
+   startup.)
+
+   (This is gone.)
+
+-- Robert Chassell has found serious copy-paste bugs with the
+   multi-tty branch.  There seem to be redisplay bugs while copying
+   from X to a terminal frame.  Copying accented characters do not
+   work for me.
+
+   (Patch-124 should fix this, by changing the interprogram-*-function
+   variables to be frame-local, as suggested by Mark Plaksin
+   (thanks!).  I think that the redisplay bugs are in fact not bugs,
+   but delays caused by single_kboard --> perhaps MULTI_KBOARD should
+   be removed.)
+
+-- frame-creation-function was removed, which might be a bad idea.
+   Think up a compatible solution.
+
+   (It was an internal interface that may be changed when necessary.)
+
+-- Change Lisp code not to (getenv "TERM"); use the `tty-type' frame
+   parameter or the frame-tty-type function instead.  (M-x tags-search
+   "TERM" helps with this.)  Update: Actually, all getenv invocations
+   should be checked for multi-tty compatibility, and an interface
+   must be implemented to get the remote client's environment.
+
+   (Done.  Only getenv calls in lisp/term/*.el were changed; other
+   calls should be mostly left as they are.)
+
+-- Add an elaborate mechanism for display-local variables.  (There are
+   already a few of these; search for `terminal-local' in the Elisp
+   manual.)
+
+   (Not needed.  Display-local variables could be emulated by
+   frame-local variables.)
+
+-- Emacs assumes that all terminal frames have the same locale
+   settings as Emacs itself.  This may lead to bogus results in a
+   multi-locale setup. (E.g., while logging in from a remote client
+   with a different locale.)
+   (Update after new bugreport by Friedrich Delgado Friedrichs:
+   (at least) the structs terminal_coding and keyboard_coding in
+   coding.c must be moved to struct display, and the Lisp interface
+   [set-]keyboard-coding-system must be adapted for the change.)
+
+   (Fixed.  Emacs now uses the locale settings as seen by the
+   emacsclient process for server tty frames.)
+
+
+-- Make `struct display' accessible to Lisp programs.  Accessor functions:
+
+	(displayp OBJECT):  Returns t if OBJECT is a display.
+		=> Implemented as display-live-p.
+
+	(display-list):  Returns list of currently active displays.
+		=> Implemented.
+
+	(selected-display):  Returns the display object of the selected frame.
+		=> Not strictly necessary, but implemented anyway.
+
+	(frame-display FRAME):  Returns the display object of FRAME.
+	        => Implemented.
+
+	(display-frames DISPLAY):  Returns a list of frames on DISPLAY.
+		=> Already implemented, see frames-on-display-list.
+
+	(display-type DISPLAY):  Returns the type of DISPLAY, as a
+		symbol.  (See `framep'.)
+		=> Implemented as display-live-p.
+
+	(display-device DISPLAY): Returns the name of the device that
+		DISPLAY uses, as a string.  (E.g: "/dev/pts/16", or
+		":0.0")
+		=> Implemented as display-name.
+
+	etc.
+
+   See next issue why this is necessary.
+
+   (Update: The consensus on emacs-devel seems to be to do this via
+   integer identifiers.  That's fine by me.)
+
+   (Done.)
+
+-- The following needs to be supported:
+
+	$ emacsclient -t
+		C-z
+	$ emacsclient -t
+		(This fails now.)
+
+   The cleanest way to solve this is to allow multiple displays on the
+   same terminal device; each new emacsclient process should create
+   its own display.  As displays are currently identified by their
+   device names, this is not possible until struct display becomes
+   accessible as a Lisp-level object.
+
+   (Done.)
+
+;;; arch-tag: 8da1619e-2e79-41a8-9ac9-a0485daad17d
--- a/admin/notes/BRANCH	Mon Oct 25 02:03:47 2004 +0000
+++ b/admin/notes/BRANCH	Mon Oct 25 18:17:28 2004 +0000
@@ -1,18 +1,27 @@
-This file describes the CVS branch in which it is maintained.
+This file describes the Arch branch in which it is maintained.
 Everything below the line is branch-specific.
 ________________________________________________________________________

-This is the "HEAD" branch, otherwise known as the "trunk".  Its primary
-purpose is to accumulate changes that are not yet partitioned into a
-specific (versioned) release.  When people say "use CVS emacs", this is
-the branch they are talking about.  Likewise, a "cvs checkout" without
-the "-r" option results in this branch.
+This is the "multi-tty" branch.  It contains a version of Emacs that
+is able to create frames on multiple display devices and display
+types, including multiple tty devices and tty+X combined sessions.
+The branch has an enhanced version of emacsclient that is capable of
+opening a new Emacs frame on the terminal it runs on.
+
+Commit access to the multi-tty branch is only available to its
+maintainer, K�roly Lőrentey (lorentey@elte.hu).  The best way to
+contribute to the project is to create your own public Arch branch,
+and publish your changes there.  (I will then be able to easily "pull"
+your changes into the multi-tty branch.)

-The plans for this branch are not specified; Emacs hackers add to it
-relatively free of constraint (aside from proper legal / accounting
-practices), although sometimes there is related discussion on the
-emacs-devel mailing list.
+The branch is scheduled for inclusion in the next major release of
+Emacs, version 22.
+
+Please read the file README.multi-tty in the base directory for
+details.

-The closure process for this branch is undocumented; concepts such as
-"freeze", "release", or "integration with the trunk" are not applicable
-to this branch.
+
+
+Local Variables:
+coding: utf-8
+End:
--- a/etc/ONEWS	Mon Oct 25 02:03:47 2004 +0000
+++ b/etc/ONEWS	Mon Oct 25 18:17:28 2004 +0000
@@ -1029,7 +1029,7 @@
 *** RCS customization.

 There is a new variable vc-consult-headers.  If it is t (the default),
-VC searches for RCS headers in working files (like `$Id: ONEWS,v 1.8 2003/02/04 14:30:40 lektu Exp $') and
+VC searches for RCS headers in working files (like `$Id$') and
 determines the state of the file from them, not from the master file.
 This is fast and more reliable when you use branches.  (The variable
 was already present in Emacs 19.29, but didn't get mentioned in the
--- a/etc/TODO	Mon Oct 25 02:03:47 2004 +0000
+++ b/etc/TODO	Mon Oct 25 18:17:28 2004 +0000
@@ -133,7 +133,7 @@
   thread has processed the MENU_BAR_ACTIVATE_EVENT and regenerated
   the whole menu bar.  In the mean time, it should process other messages.

-** Get some major packages installed: W3 (development version needs
+** Get some major packages installed: W3/url (development version needs
   significant work), PSGML.  Check the assignments file for other
   packages which might go in and have been missed.

@@ -151,7 +151,10 @@
 ** Highlight rectangles (`mouse-track-rectangle-p' in XEmacs).  Already in CUA,
   but it's a valuable feature worth making more general.

-** Support simultaneous tty and X frames.
+** Support simultaneous tty and X frames.  [For a partial
+  implementation, see tla branch
+  lorentey@elte.hu--2004/emacs--multi-tty--0 at
+  http://lorentey.hu/arch/2004]

 ** Provide MIME support for Rmail using the Gnus MIME library.  [Maybe
   not now feasible, given Gnus maintenance decisions.  fx looked at
--- a/info/.cvsignore	Mon Oct 25 02:03:47 2004 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-emacs
-emacs-[1-9]*
-emacs-mime
-ccmode
-ccmode-[1-9]*
-cl
-cl-[1-9]*
-dired-x
-ediff
-ediff-[1-9]*
-eshell
-forms
-gnus
-gnus-[1-9]*
-info
-message
-message-[1-9]*
-mh-e
-mh-e-[1-9]*
-reftex
-reftex-[1-9]*
-sc
-sc-[1-9]*
-vip
-vip-[1-9]*
-viper
-viper-[1-9]*
-widget
-ada-mode
-eudc
-autotype
-efaq
-efaq-[1-9]*
-idlwave
-idlwave-[1-9]*
-ebrowse
-pcl-cvs
-woman
-woman-[1-9]*
-speedbar
-elisp
-elisp-[1-9]*
-calc
-calc-[1-9]*
-eintr
-eintr-[1-9]*
-tramp
-tramp-[1-9]*
-ses
-smtpmail
-flymake
-emacs-xtra
-pgg
-sieve
--- a/info/COPYING	Mon Oct 25 02:03:47 2004 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,340 +0,0 @@
-		    GNU GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-		    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-			    NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-	    How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year  name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
-Public License instead of this License.
--- a/info/dir	Mon Oct 25 02:03:47 2004 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,75 +0,0 @@
--*- Text -*-
-This is the file .../info/dir, which contains the topmost node of the
-Info hierarchy.  The first time you invoke Info you start off
-looking at that node, which is (dir)Top.
-
-File: dir	Node: Top	This is the top of the INFO tree
-
-The Info Directory
-******************
-
-  The Info Directory is the top-level menu of major Info topics.
-  Type "d" in Info to return to the Info Directory.  Type "q" to exit Info.
-  Type "?" for a list of Info commands, or "h" to visit an Info tutorial.
-  Type "m" to choose a menu item--for instance,
-    "mEmacs<Return>" visits the Emacs manual.
-  In Emacs Info, you can click mouse button 2 on a menu item
-  or cross reference to follow it to its target.
-  Each menu line that starts with a * is a topic you can select with "m".
-  Every third topic has a red * to help pick the right number to type.
-
-* Menu:
-
-* Info: (info).		How to use the documentation browsing system.
-
-Emacs
-* Emacs: (emacs).	The extensible self-documenting text editor.
-* Emacs FAQ: (efaq).	Frequently Asked Questions about Emacs.
-* Emacs Lisp Introduction: (eintr).
-  			A simple introduction to Emacs Lisp programming.
-* Elisp: (elisp).	The Emacs Lisp Reference Manual.
-
-* CL: (cl).		Partial Common Lisp support for Emacs Lisp.
-* Dired-X: (dired-x).   Dired Extra Features.
-* Ediff: (ediff).	A visual interface for comparing and merging programs.
-* Emacs-Xtra: (emacs-xtra).    Specialized Emacs features.
-* PCL-CVS: (pcl-cvs).	Emacs front-end to CVS.
-* Speedbar: (speedbar).	File/Tag summarizing utility.
-
-* Ada mode: (ada-mode). Emacs mode for editing Ada code.
-* CC mode: (ccmode).	Emacs mode for editing C, C++, Objective-C,
-			  Java, Pike, and IDL code.
-* Ebrowse: (ebrowse).	A C++ class browser for Emacs.
-* Flymake: (flymake).   An on-the-fly syntax checker for Emacs.
-* IDLWAVE: (idlwave).	Major mode and shell for IDL and WAVE/CL files.
-
-* Gnus: (gnus).		The news reader Gnus.
-* Message: (message).	Mail and news composition mode that goes with Gnus.
-* MH-E: (mh-e).		Emacs interface to the MH mail system.
-* MIME: (emacs-mime).   Emacs MIME de/composition library.
-* PGG: (pgg).   	Emacs interface to various PGP implementations.
-* SC: (sc).		Supercite lets you cite parts of messages you're
-			  replying to, in flexible ways.
-* SMTP: (smtpmail).     Emacs library for sending mail via SMTP.
-* Sieve: (sieve).       Managing Sieve scripts in Emacs.
-
-* Autotype: (autotype). Convenient features for text that you enter frequently
-                          in Emacs.
-* Calc: (calc). 	Advanced desk calculator and mathematical tool.
-* Eshell: (eshell).	A command shell implemented in Emacs Lisp.
-* EUDC: (eudc).		An Emacs client for directory servers (LDAP, PH).
-* Forms: (forms).	Emacs package for editing data bases
-			  by filling in forms.
-* RefTeX: (reftex).	Emacs support for LaTeX cross-references and citations.
-* SES: (ses).           Simple Emacs Spreadsheet
-* Tramp: (tramp).	Transparent Remote (file) Access, Multiple Protocol.
-                          Edit remote files via a remote shell (rsh,
-                          ssh, telnet).
-* Widget: (widget).     The "widget" package used by the Emacs Customization
-                          facility.
-* WoMan: (woman).       Browse UN*X Manual Pages "Wo (without) Man".
-
-* VIPER: (viper).       The newest Emacs VI-emulation mode.
-                          (also, A VI Plan for Emacs Rescue
-                           or the VI PERil.)
-* VIP: (vip).		An older VI-emulation for Emacs.
--- a/lib-src/b2m.pl	Mon Oct 25 02:03:47 2004 +0000
+++ b/lib-src/b2m.pl	Mon Oct 25 18:17:28 2004 +0000
@@ -30,7 +30,7 @@
 use Date::Parse;

 my($whoami) = basename $0;
-my($version) = '$Revision: 1.5 $';
+my($version) = '$Revision$';
 my($usage) = "Usage: $whoami [--help] [--version] [--[no]full-headers] [Babyl-file]
 \tBy default, full headers are printed.\n";
--- a/lib-src/emacsclient.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/lib-src/emacsclient.c	Mon Oct 25 18:17:28 2004 +0000
@@ -41,6 +41,10 @@
 # include <pwd.h>
 #endif /* not VMS */

+#include <signal.h>
+#include <errno.h>
+
+
 char *getenv (), *getwd ();
 char *getcwd ();

@@ -51,15 +55,27 @@
 /* Name used to invoke this program.  */
 char *progname;

+/* The first argument to main. */
+int main_argc;
+
+/* The second argument to main. */
+char **main_argv;
+
 /* Nonzero means don't wait for a response from Emacs.  --no-wait.  */
 int nowait = 0;

 /* Nonzero means args are expressions to be evaluated.  --eval.  */
 int eval = 0;

+/* Nonzero means open a new graphical frame. */
+int window_system = 0;
+
 /* The display on which Emacs should work.  --display.  */
 char *display = NULL;

+/* Nonzero means open a new Emacs frame on the current terminal. */
+int tty = 0;
+
 /* If non-NULL, the name of an editor to fallback to if the server
    is not running.  --alternate-editor.   */
 const char * alternate_editor = NULL;
@@ -75,6 +91,8 @@
   { "eval",	no_argument,	   NULL, 'e' },
   { "help",	no_argument,	   NULL, 'H' },
   { "version",	no_argument,	   NULL, 'V' },
+  { "tty",	no_argument,       NULL, 't' },
+  { "current-frame", no_argument,  NULL, 'c' },
   { "alternate-editor", required_argument, NULL, 'a' },
   { "socket-name",	required_argument, NULL, 's' },
   { "display",	required_argument, NULL, 'd' },
@@ -90,11 +108,19 @@
      char **argv;
 {
   alternate_editor = getenv ("ALTERNATE_EDITOR");
+  display = getenv ("DISPLAY");
+  if (display && strlen (display) == 0)
+    display = NULL;
+
+  if (display)
+    window_system = 1;
+  else
+    tty = 1;

   while (1)
     {
       int opt = getopt_long (argc, argv,
-			     "VHnea:s:d:", longopts, 0);
+			     "VHnea:s:d:tc", longopts, 0);

       if (opt == EOF)
 	break;
@@ -131,6 +157,16 @@
 	  exit (EXIT_SUCCESS);
 	  break;

+        case 't':
+          tty = 1;
+          window_system = 0;
+          break;
+
+        case 'c':
+          window_system = 0;
+          tty = 0;
+          break;
+
 	case 'H':
 	  print_help_and_exit ();
 	  break;
@@ -141,6 +177,11 @@
 	  break;
 	}
     }
+
+  if (tty) {
+    nowait = 0;
+    display = 0;
+  }
 }

 void
@@ -154,6 +195,8 @@
 The following OPTIONS are accepted:\n\
 -V, --version           Just print a version info and return\n\
 -H, --help              Print this usage information message\n\
+-t, --tty               Open a new Emacs frame on the current terminal\n\
+-c, --current-frame	Do not create a new frame; use the current Emacs frame\n\
 -n, --no-wait           Don't wait for the server to return\n\
 -e, --eval              Evaluate the FILE arguments as ELisp expressions\n\
 -d, --display=DISPLAY   Visit the file in the given display\n\
@@ -166,19 +209,50 @@
   exit (EXIT_SUCCESS);
 }

-/* In NAME, insert a & before each &, each space, each newline, and
+/* Like malloc but get fatal error if memory is exhausted.  */
+
+long *
+xmalloc (size)
+     unsigned int size;
+{
+  long *result = (long *) malloc (size);
+  if (result == NULL)
+    {
+      perror ("malloc");
+      exit (EXIT_FAILURE);
+    }
+  return result;
+}
+
+/* Like strdup but get a fatal error if memory is exhausted. */
+
+char *
+xstrdup (const char *s)
+{
+  char *result = strdup (s);
+  if (result == NULL)
+    {
+      perror ("strdup");
+      exit (EXIT_FAILURE);
+    }
+  return result;
+}
+
+/* In STR, insert a & before each &, each space, each newline, and
    any initial -.  Change spaces to underscores, too, so that the
-   return value never contains a space.  */
+   return value never contains a space.
+
+   Does not change the string.  Outputs the result to STREAM.  */

 void
-quote_file_name (name, stream)
-     char *name;
+quote_argument (str, stream)
+     char *str;
      FILE *stream;
 {
-  char *copy = (char *) malloc (strlen (name) * 2 + 1);
+  char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
   char *p, *q;

-  p = name;
+  p = str;
   q = copy;
   while (*p)
     {
@@ -196,7 +270,7 @@
 	}
       else
 	{
-	  if (*p == '&' || (*p == '-' && p == name))
+	  if (*p == '&' || (*p == '-' && p == str))
 	    *q++ = '&';
 	  *q++ = *p++;
 	}
@@ -208,34 +282,53 @@
   free (copy);
 }

-/* Like malloc but get fatal error if memory is exhausted.  */
+
+/* The inverse of quote_argument.  Removes quoting in string STR by
+   modifying the string in place.   Returns STR. */

-long *
-xmalloc (size)
-     unsigned int size;
+char *
+unquote_argument (str)
+     char *str;
 {
-  long *result = (long *) malloc (size);
-  if (result == NULL)
-  {
-    perror ("malloc");
-    exit (EXIT_FAILURE);
-  }
-  return result;
+  char *p, *q;
+
+  if (! str)
+    return str;
+
+  p = str;
+  q = str;
+  while (*p)
+    {
+      if (*p == '&')
+        {
+          p++;
+          if (*p == '&')
+            *p = '&';
+          else if (*p == '_')
+            *p = ' ';
+          else if (*p == 'n')
+            *p = '\n';
+          else if (*p == '-')
+            *p = '-';
+        }
+      *q++ = *p++;
+    }
+  *q = 0;
+  return str;
 }
+

 /*
   Try to run a different command, or --if no alternate editor is
   defined-- exit with an errorcode.
 */
 void
-fail (argc, argv)
-     int argc;
-     char **argv;
+fail (void)
 {
   if (alternate_editor)
     {
       int i = optind - 1;
-      execvp (alternate_editor, argv + i);
+      execvp (alternate_editor, main_argv + i);
       return;
     }
   else
@@ -244,6 +337,101 @@
     }
 }

+/* The process id of Emacs. */
+int emacs_pid;
+
+/* File handles for communicating with Emacs. */
+FILE *out, *in;
+
+/* A signal handler that passes the signal to the Emacs process.
+   Useful for SIGWINCH.  */
+
+SIGTYPE
+pass_signal_to_emacs (int signalnum)
+{
+  int old_errno = errno;
+
+  if (emacs_pid)
+    kill (emacs_pid, signalnum);
+
+  signal (signalnum, pass_signal_to_emacs);
+  errno = old_errno;
+}
+
+/* Signal handler for SIGCONT; notify the Emacs process that it can
+   now resume our tty frame.  */
+
+SIGTYPE
+handle_sigcont (int signalnum)
+{
+  int old_errno = errno;
+
+  if (tcgetpgrp (1) == getpgrp ())
+    {
+      /* We are in the foreground. */
+      fprintf (out, "-resume \n");
+      fflush (out);
+      fsync (fileno (out));
+    }
+  else
+    {
+      /* We are in the background; cancel the continue. */
+      kill (getpid (), SIGSTOP);
+    }
+  errno = old_errno;
+}
+
+/* Signal handler for SIGTSTP; notify the Emacs process that we are
+   going to sleep.  Normally the suspend is initiated by Emacs via
+   server-handle-suspend-tty, but if the server gets out of sync with
+   reality, we may get a SIGTSTP on C-z.  Handling this signal and
+   notifying Emacs about it should get things under control again. */
+
+SIGTYPE
+handle_sigtstp (int signalnum)
+{
+  int old_errno = errno;
+  sigset_t set;
+
+  if (out)
+    {
+      fprintf (out, "-suspend \n");
+      fflush (out);
+      fsync (fileno (out));
+    }
+
+  /* Unblock this signal and call the default handler by temprarily
+     changing the handler and resignalling. */
+  sigprocmask (SIG_BLOCK, NULL, &set);
+  sigdelset (&set, signalnum);
+  signal (signalnum, SIG_DFL);
+  kill (getpid (), signalnum);
+  sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
+  signal (signalnum, handle_sigtstp);
+
+  errno = old_errno;
+}
+
+/* Set up signal handlers before opening a frame on the current tty.  */
+
+void
+init_signals (void)
+{
+  /* Set up signal handlers. */
+  signal (SIGWINCH, pass_signal_to_emacs);
+
+  /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
+     deciding which terminal the signal came from.  C-g is now a
+     normal input event on secondary terminals.  */
+#if 0
+  signal (SIGINT, pass_signal_to_emacs);
+  signal (SIGQUIT, pass_signal_to_emacs);
+#endif
+
+  signal (SIGCONT, handle_sigcont);
+  signal (SIGTSTP, handle_sigtstp);
+  signal (SIGTTOU, handle_sigtstp);
+}


 #if !defined (HAVE_SOCKETS) || defined (NO_SOCKETS_IN_FILE_SYSTEM)
@@ -257,7 +445,7 @@
 	   argv[0]);
   fprintf (stderr, "on systems with Berkeley sockets.\n");

-  fail (argc, argv);
+  fail ();
 }

 #else /* HAVE_SOCKETS */
@@ -291,23 +479,41 @@
   return 0;
 }

+/* Returns 1 if PREFIX is a prefix of STRING. */
+static int
+strprefix (char *prefix, char *string)
+{
+  int i;
+  if (! prefix)
+    return 1;
+
+  if (!string)
+    return 0;
+
+  for (i = 0; prefix[i]; i++)
+    if (!string[i] || string[i] != prefix[i])
+      return 0;
+  return 1;
+}
+
 int
 main (argc, argv)
      int argc;
      char **argv;
 {
   int s, i, needlf = 0;
-  FILE *out, *in;
   struct sockaddr_un server;
   char *cwd, *str;
   char string[BUFSIZ];

+  main_argc = argc;
+  main_argv = argv;
   progname = argv[0];

   /* Process options.  */
   decode_options (argc, argv);

-  if ((argc - optind < 1) && !eval)
+  if ((argc - optind < 1) && !eval && !tty && !window_system)
     {
       fprintf (stderr, "%s: file name or argument required\n", progname);
       fprintf (stderr, "Try `%s --help' for more information\n", progname);
@@ -322,7 +528,7 @@
     {
       fprintf (stderr, "%s: ", argv[0]);
       perror ("socket");
-      fail (argc, argv);
+      fail ();
     }

   server.sun_family = AF_UNIX;
@@ -330,30 +536,31 @@
   {
     int sock_status = 0;
     int default_sock = !socket_name;
-    int saved_errno;
-    char *server_name = "server";
+    int saved_errno = 0;
+
+     char *server_name = "server";

-    if (socket_name && !index (socket_name, '/') && !index (socket_name, '\\'))
-      { /* socket_name is a file name component.  */
-	server_name = socket_name;
-	socket_name = NULL;
-	default_sock = 1;	/* Try both UIDs.  */
-      }
+     if (socket_name && !index (socket_name, '/') && !index (socket_name, '\\'))
+       { /* socket_name is a file name component.  */
+ 	server_name = socket_name;
+ 	socket_name = NULL;
+ 	default_sock = 1;	/* Try both UIDs.  */
+       }

-    if (default_sock)
+     if (default_sock)
       {
-	socket_name = alloca (100 + strlen (server_name));
-	sprintf (socket_name, "/tmp/emacs%d/%s",
-		 (int) geteuid (), server_name);
+ 	socket_name = alloca (100 + strlen (server_name));
+ 	sprintf (socket_name, "/tmp/emacs%d/%s",
+ 		 (int) geteuid (), server_name);
       }

     if (strlen (socket_name) < sizeof (server.sun_path))
       strcpy (server.sun_path, socket_name);
     else
       {
-	fprintf (stderr, "%s: socket-name %s too long",
-		 argv[0], socket_name);
-	exit (EXIT_FAILURE);
+        fprintf (stderr, "%s: socket-name %s too long",
+                 argv[0], socket_name);
+        fail ();
       }

     /* See if the socket exists, and if it's owned by us. */
@@ -392,7 +599,7 @@
 		  }

 		sock_status = socket_status (server.sun_path);
-		saved_errno = errno;
+                saved_errno = errno;
 	      }
 	    else
 	      errno = saved_errno;
@@ -407,7 +614,7 @@
 	 if (0 != geteuid ())
 	   {
 	     fprintf (stderr, "%s: Invalid socket owner\n", argv[0]);
-	     fail (argc, argv);
+	     fail ();
 	   }
 	 break;

@@ -421,7 +628,7 @@
 	 else
 	   fprintf (stderr, "%s: can't stat %s: %s\n",
 		    argv[0], server.sun_path, strerror (saved_errno));
-	 fail (argc, argv);
+	 fail ();
 	 break;
        }
   }
@@ -431,18 +638,18 @@
     {
       fprintf (stderr, "%s: ", argv[0]);
       perror ("connect");
-      fail (argc, argv);
+      fail ();
     }

-  /* We use the stream OUT to send our command to the server.  */
+  /* We use the stream OUT to send our commands to the server.  */
   if ((out = fdopen (s, "r+")) == NULL)
     {
       fprintf (stderr, "%s: ", argv[0]);
       perror ("fdopen");
-      fail (argc, argv);
+      fail ();
     }

-  /* We use the stream IN to read the response.
+  /* We use the stream IN to read the responses.
      We used to use just one stream for both output and input
      on the socket, but reversing direction works nonportably:
      on some systems, the output appears as the first input;
@@ -451,7 +658,7 @@
     {
       fprintf (stderr, "%s: ", argv[0]);
       perror ("fdopen");
-      fail (argc, argv);
+      fail ();
     }

 #ifdef HAVE_GETCWD
@@ -465,87 +672,208 @@

 #ifdef HAVE_GETCWD
       fprintf (stderr, "%s: %s (%s)\n", argv[0],
-	       "Cannot get current working directory", strerror (errno));
+	       "cannot get current working directory", strerror (errno));
 #else
       fprintf (stderr, "%s: %s (%s)\n", argv[0], string, strerror (errno));
 #endif
-      fail (argc, argv);
+      fail ();
     }

+  /* First of all, send our version number for verification. */
+  fprintf (out, "-version %s ", VERSION);
+
+  /* Send over our environment. */
+  {
+    extern char **environ;
+    int i;
+    for (i = 0; environ[i]; i++)
+      {
+        char *name = xstrdup (environ[i]);
+        char *value = strchr (name, '=');
+        if (value && strlen (value) > 1)
+          {
+            *value++ = 0;
+            fprintf (out, "-env ");
+            quote_argument (name, out);
+            fprintf (out, " ");
+            quote_argument (value, out);
+            fprintf (out, " ");
+            fflush (out);
+          }
+        free (name);
+      }
+  }
+
   if (nowait)
     fprintf (out, "-nowait ");

-  if (eval)
-    fprintf (out, "-eval ");
-
   if (display)
     {
       fprintf (out, "-display ");
-      quote_file_name (display, out);
+      quote_argument (display, out);
       fprintf (out, " ");
     }

+  if (tty)
+    {
+      char *tty_name = ttyname (fileno (stdin));
+      char *type = getenv ("TERM");
+
+      if (! tty_name)
+        {
+          fprintf (stderr, "%s: could not get terminal name\n", progname);
+          fail ();
+        }
+
+      if (! type)
+        {
+          fprintf (stderr, "%s: please set the TERM variable to your terminal type\n",
+                   progname);
+          fail ();
+        }
+
+      if (! strcmp (type, "eterm"))
+        {
+          /* This causes nasty, MULTI_KBOARD-related input lockouts. */
+          fprintf (stderr, "%s: opening a frame in an Emacs term buffer"
+                   " is not supported\n", progname);
+          fail ();
+        }
+
+      init_signals ();
+
+      fprintf (out, "-tty ");
+      quote_argument (tty_name, out);
+      fprintf (out, " ");
+      quote_argument (type, out);
+      fprintf (out, " ");
+    }
+
+  if (window_system)
+    fprintf (out, "-window-system ");
+
   if ((argc - optind > 0))
     {
       for (i = optind; i < argc; i++)
 	{
+          int relative = 0;
+
 	  if (eval)
-	    ; /* Don't prepend any cwd or anything like that.  */
-	  else if (*argv[i] == '+')
-	    {
+            {
+              /* Don't prepend any cwd or anything like that.  */
+              fprintf (out, "-eval ");
+              quote_argument (argv[i], out);
+              fprintf (out, " ");
+              continue;
+            }
+
+          if (*argv[i] == '+')
+            {
 	      char *p = argv[i] + 1;
 	      while (isdigit ((unsigned char) *p) || *p == ':') p++;
-	      if (*p != 0)
-		{
-		  quote_file_name (cwd, out);
-		  fprintf (out, "/");
-		}
-	    }
-	  else if (*argv[i] != '/')
-	    {
-	      quote_file_name (cwd, out);
-	      fprintf (out, "/");
-	    }
+	      if (*p == 0)
+                {
+                  fprintf (out, "-position ");
+                  quote_argument (argv[i], out);
+                  fprintf (out, " ");
+                  continue;
+                }
+              else
+                relative = 1;
+            }
+          else if (*argv[i] != '/')
+            relative = 1;

-	  quote_file_name (argv[i], out);
-	  fprintf (out, " ");
-	}
+          fprintf (out, "-file ");
+          if (relative)
+            {
+              quote_argument (cwd, out);
+              fprintf (out, "/");
+            }
+          quote_argument (argv[i], out);
+          fprintf (out, " ");
+        }
     }
   else
     {
-      while ((str = fgets (string, BUFSIZ, stdin)))
-	{
-	  quote_file_name (str, out);
-	}
-      fprintf (out, " ");
+      if (!tty && !window_system)
+        {
+          while ((str = fgets (string, BUFSIZ, stdin)))
+            {
+              if (eval)
+                fprintf (out, "-eval ");
+              else
+                fprintf (out, "-file ");
+              quote_argument (str, out);
+            }
+          fprintf (out, " ");
+        }
     }

   fprintf (out, "\n");
   fflush (out);
+  fsync (fileno (out));

-  /* Maybe wait for an answer.   */
-  if (nowait)
-    return EXIT_SUCCESS;
-
-  if (!eval)
+  /* Wait for an answer. */
+  if (!eval && !tty && !nowait)
     {
       printf ("Waiting for Emacs...");
       needlf = 2;
     }
   fflush (stdout);
+  fsync (1);

   /* Now, wait for an answer and print any messages.  */
   while ((str = fgets (string, BUFSIZ, in)))
     {
-      if (needlf == 2)
-	printf ("\n");
-      printf ("%s", str);
-      needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
+      char *p = str + strlen (str) - 1;
+      while (p > str && *p == '\n')
+        *p-- = 0;
+
+      if (strprefix ("-good-version ", str))
+        {
+          /* OK, we got the green light. */
+        }
+      else if (strprefix ("-emacs-pid ", str))
+        {
+          emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
+        }
+      else if (strprefix ("-print ", str))
+        {
+          str = unquote_argument (str + strlen ("-print "));
+          if (needlf)
+            printf ("\n");
+          printf ("%s", str);
+          needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
+        }
+      else if (strprefix ("-error ", str))
+        {
+          str = unquote_argument (str + strlen ("-error "));
+          if (needlf)
+            printf ("\n");
+          printf ("*ERROR*: %s", str);
+          needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
+        }
+      else if (strprefix ("-suspend ", str))
+        {
+          if (needlf)
+            printf ("\n");
+          needlf = 0;
+          kill (0, SIGSTOP);
+        }
+      else
+        {
+          if (needlf)
+            printf ("\n");
+          printf ("*ERROR*: Unknown message: %s", str);
+          needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
+        }
     }

   if (needlf)
     printf ("\n");
   fflush (stdout);
+  fsync (1);

   return EXIT_SUCCESS;
 }
--- a/lib-src/rcs2log	Mon Oct 25 02:03:47 2004 +0000
+++ b/lib-src/rcs2log	Mon Oct 25 18:17:28 2004 +0000
@@ -52,7 +52,7 @@

 Report bugs to <bug-gnu-emacs@gnu.org>.'

-Id='$Id: rcs2log,v 1.53 2004/02/15 07:41:58 uid65632 Exp $'
+Id='$Id$'

 # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2001, 2002, 2003,
 # 2004 Free Software Foundation, Inc.
--- a/lisp/allout.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/allout.el	Mon Oct 25 18:17:28 2004 +0000
@@ -507,7 +507,7 @@
 ;;;_  : Version
 ;;;_   = allout-version
 (defvar allout-version
-  (let ((rcs-rev "$Revision: 1.49 $"))
+  (let ((rcs-rev "$Revision$"))
     (condition-case err
 	(save-match-data
 	  (string-match "Revision: \\([0-9]+\\.[0-9]+\\)" rcs-rev)
--- a/lisp/bindings.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/bindings.el	Mon Oct 25 18:17:28 2004 +0000
@@ -214,7 +214,7 @@

 (make-variable-buffer-local 'mode-line-buffer-identification)

-(defvar mode-line-frame-identification '("-%F  ")
+(defvar mode-line-frame-identification '(window-system "  " "-%F  ")
   "Mode-line control to describe the current frame.")

 (defvar mode-line-process nil "\
--- a/lisp/cus-face.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/cus-face.el	Mon Oct 25 18:17:28 2004 +0000
@@ -39,15 +39,18 @@
     (when (fboundp 'facep)
       (unless (facep face)
 	;; If the user has already created the face, respect that.
-	(let ((value (or (get face 'saved-face) spec)))
+	(let ((value (or (get face 'saved-face) spec))
+	      (have-window-system (memq initial-window-system '(x w32))))
 	  ;; Create global face.
 	  (make-empty-face face)
 	  ;; Create frame-local faces
 	  (dolist (frame (frame-list))
-	    (face-spec-set face value frame)))
-	;; When making a face after frames already exist
-	(if (memq window-system '(x w32))
-	    (make-face-x-resource-internal face))))
+	    (face-spec-set face value frame)
+	    (when (memq (window-system frame) '(x w32))
+	      (setq have-window-system t)))
+	  ;; When making a face after frames already exist
+	  (if have-window-system
+	      (make-face-x-resource-internal face)))))
     ;; Don't record SPEC until we see it causes no errors.
     (put face 'face-defface-spec spec)
     (when (and doc (null (face-documentation face)))
--- a/lisp/emulation/viper-init.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/emulation/viper-init.el	Mon Oct 25 18:17:28 2004 +0000
@@ -97,7 +97,7 @@
 (defun viper-has-face-support-p ()
   (cond ((viper-window-display-p))
 	(viper-force-faces)
-	(viper-emacs-p (memq (viper-device-type) '(pc)))
+	(viper-emacs-p (memq (viper-device-type) '(nil pc)))
 	(viper-xemacs-p (memq (viper-device-type) '(tty pc)))))
--- a/lisp/emulation/viper-util.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/emulation/viper-util.el	Mon Oct 25 18:17:28 2004 +0000
@@ -100,10 +100,9 @@
    (fset 'viper-int-to-char (symbol-function 'identity))
    (if (viper-window-display-p)
        (fset 'viper-iconify (symbol-function 'iconify-or-deiconify-frame)))
-   (cond ((viper-has-face-support-p)
-	  (fset 'viper-get-face (symbol-function 'internal-get-face))
-	  (fset 'viper-color-defined-p (symbol-function 'x-color-defined-p))
-	  )))
+   (fset 'viper-get-face (symbol-function 'internal-get-face))
+   (fset 'viper-color-defined-p (symbol-function 'x-color-defined-p))
+          )
  )
--- a/lisp/faces.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/faces.el	Mon Oct 25 18:17:28 2004 +0000
@@ -902,7 +902,7 @@
   (let ((valid
          (case attribute
            (:family
-            (if window-system
+            (if (window-system frame)
                 (mapcar #'(lambda (x) (cons (car x) (car x)))
                         (x-font-family-list))
 	      ;; Only one font on TTYs.
@@ -911,7 +911,7 @@
             (mapcar #'(lambda (x) (cons (symbol-name x) x))
                     (internal-lisp-face-attribute-values attribute)))
            ((:underline :overline :strike-through :box)
-            (if window-system
+            (if (window-system frame)
                 (nconc (mapcar #'(lambda (x) (cons (symbol-name x) x))
                                (internal-lisp-face-attribute-values attribute))
                        (mapcar #'(lambda (c) (cons c c))
@@ -924,7 +924,7 @@
            ((:height)
             'integerp)
            (:stipple
-            (and (memq window-system '(x w32 mac))
+            (and (memq (window-system frame) '(x w32 mac))
                  (mapcar #'list
                          (apply #'nconc
                                 (mapcar (lambda (dir)
@@ -1042,7 +1042,7 @@
 	       ;; explicitly in VALID, using color approximation code
 	       ;; in tty-colors.el.
 	       (when (and (memq attribute '(:foreground :background))
-			  (not (memq window-system '(x w32 mac)))
+			  (not (memq (window-system frame) '(x w32 mac)))
 			  (not (member new-value
 				       '("unspecified"
 					 "unspecified-fg" "unspecified-bg"))))
@@ -1295,14 +1295,14 @@
 	    req (car conjunct)
 	    options (cdr conjunct)
 	    match (cond ((eq req 'type)
-			 (or (memq window-system options)
+			 (or (memq (window-system frame) options)
 			     ;; FIXME: This should be revisited to use
 			     ;; display-graphic-p, provided that the
 			     ;; color selection depends on the number
 			     ;; of supported colors, and all defface's
 			     ;; are changed to look at number of colors
 			     ;; instead of (type graphic) etc.
-			     (and (null window-system)
+			     (and (null (window-system frame))
 				  (memq 'tty options))
 			     (and (memq 'motif options)
 				  (featurep 'motif))
@@ -1512,22 +1512,32 @@
 Display-dependent faces are those which have different definitions
 according to the `background-mode' and `display-type' frame parameters."
   (let* ((bg-resource
-	  (and window-system
+	  (and (window-system frame)
 	       (x-get-resource "backgroundMode" "BackgroundMode")))
 	 (bg-color (frame-parameter frame 'background-color))
+	 (tty-type (frame-parameter frame 'tty-type))
 	 (bg-mode
 	  (cond (frame-background-mode)
 		(bg-resource
 		 (intern (downcase bg-resource)))
-		((and (null window-system) (null bg-color))
-		 ;; No way to determine this automatically (?).
-		 'dark)
-		;; Unspecified frame background color can only happen
-		;; on tty's.
-		((member bg-color '(unspecified "unspecified-bg"))
-		 'dark)
+		((and (null (window-system frame))
+		      ;; Unspecified frame background color can only
+		      ;; happen on tty's.
+		      (member bg-color '(nil unspecified "unspecified-bg")))
+		 ;; There is no way to determine the background mode
+		 ;; automatically, so we make a guess based on the
+		 ;; terminal type.
+		 (if (and tty-type
+			  (string-match "^\\(xterm\\|rxvt\\|dtterm\\|eterm\\)"
+					tty-type))
+		     'light
+		   'dark))
 		((equal bg-color "unspecified-fg") ; inverted colors
-		 'light)
+		 (if (and tty-type
+			  (string-match "^\\(xterm\\|rxvt\\|dtterm\\|eterm\\)"
+					tty-type))
+		     'dark
+		   'light))
 		((>= (apply '+ (x-color-values bg-color frame))
 		    ;; Just looking at the screen, colors whose
 		    ;; values add up to .6 of the white total
@@ -1536,7 +1546,7 @@
 		 'light)
 		(t 'dark)))
 	 (display-type
-	  (cond ((null window-system)
+	  (cond ((null (window-system frame))
 		 (if (tty-display-color-p frame) 'color 'mono))
 		((x-display-color-p frame)
 		 'color)
@@ -1633,7 +1643,7 @@
   (setq parameters (x-handle-named-frame-geometry parameters))
   (let ((visibility-spec (assq 'visibility parameters))
 	(frame-list (frame-list))
-	(frame (x-create-frame (cons '(visibility . nil) parameters)))
+	(frame (x-create-frame `((visibility . nil) . ,parameters)))
 	success)
     (unwind-protect
 	(progn
@@ -1643,6 +1653,11 @@
 	  (if (or (null frame-list) (null visibility-spec))
 	      (make-frame-visible frame)
 	    (modify-frame-parameters frame (list visibility-spec)))
+	  ;; Arrange for the kill and yank functions to set and check the clipboard.
+	  (modify-frame-parameters
+	   frame '((interprogram-cut-function . x-select-text)))
+	  (modify-frame-parameters
+	   frame '((interprogram-paste-function . x-cut-buffer-or-selection-value)))
 	  (setq success t))
       (unless success
 	(delete-frame frame)))
@@ -1671,7 +1686,7 @@
 	(when (not (equal face 'default))
 	  (face-spec-set face (face-user-default-spec face) frame)
 	  (internal-merge-in-global-face face frame)
-	  (when (and (memq window-system '(x w32 mac))
+	  (when (and (memq (window-system frame) '(x w32 mac))
 		     (or (not (boundp 'inhibit-default-face-x-resources))
 			 (not (eq face 'default))))
 	    (make-face-x-resource-internal face frame)))
@@ -1722,10 +1737,25 @@
   (let ((frame (make-terminal-frame parameters))
 	success)
     (unwind-protect
-	(progn
+	(with-selected-frame frame
 	  (tty-handle-reverse-video frame (frame-parameters frame))
 	  (frame-set-background-mode frame)
 	  (face-set-after-frame-default frame)
+	  ;; Load library for our terminal type.
+	  ;; User init file can set term-file-prefix to nil to prevent this.
+	  (unless (null term-file-prefix)
+	    (let ((term (cdr (assq 'tty-type parameters)))
+		  hyphend)
+	      (while (and term
+			  (not (load (concat term-file-prefix term) t t)))
+		;; Strip off last hyphen and what follows, then try again
+		(setq term
+		      (if (setq hyphend (string-match "[-_][^-_]+$" term))
+			  (substring term 0 hyphend)
+			nil)))))
+	  ;; Make sure the kill and yank functions do not touch the X clipboard.
+	  (modify-frame-parameters frame '((interprogram-cut-function . nil)))
+	  (modify-frame-parameters frame '((interprogram-paste-function . nil)))
 	  (setq success t))
       (unless success
 	(delete-frame frame)))
--- a/lisp/files.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/files.el	Mon Oct 25 18:17:28 2004 +0000
@@ -4588,7 +4588,7 @@
 (define-key ctl-x-map "i" 'insert-file)
 (define-key esc-map "~" 'not-modified)
 (define-key ctl-x-map "\C-d" 'list-directory)
-(define-key ctl-x-map "\C-c" 'save-buffers-kill-emacs)
+(define-key ctl-x-map "\C-c" 'server-save-buffers-kill-display)
 (define-key ctl-x-map "\C-q" 'toggle-read-only)

 (define-key ctl-x-4-map "f" 'find-file-other-window)
--- a/lisp/font-lock.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/font-lock.el	Mon Oct 25 18:17:28 2004 +0000
@@ -1941,7 +1941,7 @@
 		    "with-current-buffer" "with-electric-help"
 		    "with-local-quit" "with-no-warnings"
 		    "with-output-to-string" "with-output-to-temp-buffer"
-		    "with-selected-window" "with-syntax-table"
+		    "with-selected-window" "with-selected-frame" "with-syntax-table"
 		    "with-temp-buffer" "with-temp-file" "with-temp-message"
 		    "with-timeout" "with-timeout-handler") t)
 	     "\\>")
--- a/lisp/frame.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/frame.el	Mon Oct 25 18:17:28 2004 +0000
@@ -27,10 +27,28 @@

 ;;; Code:

-(defvar frame-creation-function nil
-  "Window-system dependent function to call to create a new frame.
-The window system startup file should set this to its frame creation
-function, which should take an alist of parameters as its argument.")
+(defvar frame-creation-function-alist
+  (list (cons nil
+	      (if (fboundp 'tty-create-frame-with-faces)
+		  'tty-create-frame-with-faces
+		(function
+		 (lambda (parameters)
+		   (error "Can't create multiple frames without a window system"))))))
+  "Alist of window-system dependent functions to call to create a new frame.
+The window system startup file should add its frame creation
+function to this list, which should take an alist of parameters
+as its argument.")
+
+(defvar window-system-default-frame-alist nil
+  "Alist of window-system dependent default frame parameters.
+These may be set in your init file, like this:
+
+    ;; Disable menubar and toolbar on the console, but enable them under X.
+    (setq window-system-default-frame-alist
+          '((x (menu-bar-lines . 1) (tool-bar-lines . 1))
+            (nil (menu-bar-lines . 0) (tool-bar-lines . 0))))
+
+Also see `default-frame-alist'.")

 ;; The initial value given here used to ask for a minibuffer.
 ;; But that's not necessary, because the default is to have one.
@@ -189,7 +207,9 @@
 (defun frame-initialize ()
   "Create an initial frame if necessary."
   ;; Are we actually running under a window system at all?
-  (if (and window-system (not noninteractive) (not (eq window-system 'pc)))
+  (if (and initial-window-system
+	   (not noninteractive)
+	   (not (eq initial-window-system 'pc)))
       (progn
 	;; Turn on special-display processing only if there's a window system.
 	(setq special-display-function 'special-display-popup-frame)
@@ -206,6 +226,9 @@
 		  (setq frame-initial-frame-alist
 			(cons '(horizontal-scroll-bars . t)
 			      frame-initial-frame-alist)))
+	      (setq frame-initial-frame-alist
+		    (cons (cons 'window-system initial-window-system)
+			  frame-initial-frame-alist))
 	      (setq default-minibuffer-frame
 		    (setq frame-initial-frame
 			  (make-frame frame-initial-frame-alist)))
@@ -218,18 +241,7 @@
 	;; At this point, we know that we have a frame open, so we
 	;; can delete the terminal frame.
 	(delete-frame terminal-frame)
-	(setq terminal-frame nil))
-
-    ;; No, we're not running a window system.  Use make-terminal-frame if
-    ;; we support that feature, otherwise arrange to cause errors.
-    (or (eq window-system 'pc)
-	(setq frame-creation-function
-	      (if (fboundp 'tty-create-frame-with-faces)
-		  'tty-create-frame-with-faces
-		(function
-		 (lambda (parameters)
-		   (error
-		    "Can't create multiple frames without a window system"))))))))
+	(setq terminal-frame nil))))

 (defvar frame-notice-user-settings t
   "Non-nil means function `frame-notice-user-settings' wasn't run yet.")
@@ -279,7 +291,7 @@
 	;; Can't modify the minibuffer parameter, so don't try.
 	(setq parms (delq (assq 'minibuffer parms) parms))
 	(modify-frame-parameters nil
-				 (if (null window-system)
+				 (if (null initial-window-system)
 				     (append initial-frame-alist
 					     default-frame-alist
 					     parms
@@ -288,7 +300,7 @@
 				   ;; default-frame-alist were already
 				   ;; applied in pc-win.el.
 				   parms))
-	(if (null window-system) ;; MS-DOS does this differently in pc-win.el
+	(if (null initial-window-system) ;; MS-DOS does this differently in pc-win.el
 	    (let ((newparms (frame-parameters))
 		  (frame (selected-frame)))
 	      (tty-handle-reverse-video frame newparms)
@@ -567,12 +579,25 @@
   (select-frame-set-input-focus (selected-frame)))

 (defun make-frame-on-display (display &optional parameters)
-  "Make a frame on display DISPLAY.
+  "Make a frame on X display DISPLAY.
 The optional second argument PARAMETERS specifies additional frame parameters."
   (interactive "sMake frame on display: ")
   (or (string-match "\\`[^:]*:[0-9]+\\(\\.[0-9]+\\)?\\'" display)
       (error "Invalid display, not HOST:SERVER or HOST:SERVER.SCREEN"))
-  (make-frame (cons (cons 'display display) parameters)))
+  (unless x-initialized
+    (setq x-display-name display)
+    (x-initialize-window-system))
+  (make-frame `((window-system . x) (display . ,display) . ,parameters)))
+
+(defun make-frame-on-tty (device type &optional parameters)
+  "Make a frame on terminal DEVICE which is of type TYPE (e.g., \"xterm\").
+The optional third argument PARAMETERS specifies additional frame parameters."
+  (interactive "fOpen frame on tty device: \nsTerminal type of %s: ")
+  (unless device
+    (error "Invalid terminal device"))
+  (unless type
+    (error "Invalid terminal type"))
+  (make-frame `((window-system . nil) (tty . ,device) (tty-type . ,type) . ,parameters)))

 (defun make-frame-command ()
   "Make a new frame, and select it if the terminal displays only one frame."
@@ -612,7 +637,12 @@
  (minibuffer . only)	The frame should contain only a minibuffer.
  (minibuffer . WINDOW)	The frame should use WINDOW as its minibuffer window.

-Before the frame is created (via `frame-creation-function'), functions on the
+ (window-system . nil)	The frame should be displayed on a terminal device.
+ (window-system . x)	The frame should be displayed in an X window.
+
+ (display-id . ID)      The frame should use the display identified by ID.
+
+Before the frame is created (via `frame-creation-function-alist'), functions on the
 hook `before-make-frame-hook' are run.  After the frame is created, functions
 on `after-make-frame-functions' are run with one arg, the newly created frame.

@@ -622,8 +652,24 @@
 instance if the frame appears under the mouse pointer and your
 setup is for focus to follow the pointer."
   (interactive)
-  (run-hooks 'before-make-frame-hook)
-  (let ((frame (funcall frame-creation-function parameters)))
+  (let* ((w (cond
+	     ((assq 'display-id parameters)
+	      (let ((type (display-live-p (cdr (assq 'display-id parameters)))))
+		(cond
+		 ((eq type t) nil)
+		 ((eq type nil) (error "Display %s does not exist" (cdr (assq 'display-id parameters))))
+		 (t type))))
+	     ((assq 'window-system parameters)
+	      (cdr (assq 'window-system parameters)))
+	     (t window-system)))
+	 (frame-creation-function (cdr (assq w frame-creation-function-alist)))
+	 frame)
+    (unless frame-creation-function
+      (error "Don't know how to create a frame on window system %s" w))
+    (run-hooks 'before-make-frame-hook)
+    (setq frame (funcall frame-creation-function parameters))
+    (modify-frame-parameters frame
+			     (cdr (assq w window-system-default-frame-alist)))
     (run-hook-with-args 'after-make-frame-functions frame)
     frame))

@@ -645,20 +691,25 @@

 (defun frames-on-display-list (&optional display)
   "Return a list of all frames on DISPLAY.
-DISPLAY is a name of a display, a string of the form HOST:SERVER.SCREEN.
+
+DISPLAY should be a display identifier (an integer), but it may
+also be a name of a display, a string of the form HOST:SERVER.SCREEN.
+
 If DISPLAY is omitted or nil, it defaults to the selected frame's display."
-  (let* ((display (or display (frame-parameter nil 'display)))
+  (let* ((display (or display (frame-display)))
 	 (func #'(lambda (frame)
-		   (equal (frame-parameter frame 'display) display))))
+		   (or (eq (frame-display frame) display)
+		       (equal (frame-parameter frame 'display) display)))))
     (filtered-frame-list func)))

 (defun framep-on-display (&optional display)
   "Return the type of frames on DISPLAY.
-DISPLAY may be a display name or a frame.  If it is a frame, its type is
-returned.
+DISPLAY may be a display id, a display name or a frame.  If it is
+a frame, its type is returned.
 If DISPLAY is omitted or nil, it defaults to the selected frame's display.
 All frames on a given display are of the same type."
-  (or (framep display)
+  (or (display-live-p display)
+      (framep display)
       (framep (car (frames-on-display-list display)))))

 (defun frame-remove-geometry-params (param-list)
@@ -696,9 +747,9 @@
     (select-frame frame)
     (raise-frame frame)
     ;; Ensure, if possible, that frame gets input focus.
-    (cond ((eq window-system 'x)
+    (cond ((eq (window-system frame) 'x)
 	   (x-focus-frame frame))
-	  ((eq window-system 'w32)
+	  ((eq (window-system frame) 'w32)
 	   (w32-focus-frame frame)))
     (cond (focus-follows-mouse
 	   (set-mouse-position (selected-frame) (1- (frame-width)) 0))))
@@ -735,6 +786,22 @@
       (iconify-frame)
     (make-frame-visible)))

+(defun suspend-frame ()
+  "Do whatever is right to suspend the current frame.
+Calls `suspend-emacs' if invoked from the controlling terminal,
+`suspend-tty' from a secondary terminal, and
+`iconify-or-deiconify-frame' from an X frame."
+  (interactive)
+  (let ((type (framep (selected-frame))))
+    (cond
+     ((eq type 'x) (iconify-or-deiconify-frame))
+     ((eq type t)
+      (if (display-controlling-tty-p)
+	  (suspend-emacs)
+	(suspend-tty)))
+     (t (suspend-emacs)))))
+
+
 (defun make-frame-names-alist ()
   (let* ((current-frame (selected-frame))
 	 (falist
@@ -768,9 +835,9 @@
     (raise-frame frame)
     (select-frame frame)
     ;; Ensure, if possible, that frame gets input focus.
-    (cond ((eq window-system 'x)
+    (cond ((eq (window-system frame) 'x)
 	   (x-focus-frame frame))
-	  ((eq window-system 'w32)
+	  ((eq (window-system frame) 'w32)
 	   (w32-focus-frame frame)))
     (when focus-follows-mouse
       (set-mouse-position frame (1- (frame-width frame)) 0))))
@@ -980,6 +1047,10 @@
     (cons vert hor)))

 ;;;; Frame/display capabilities.
+(defun selected-display ()
+  "Return the display that is now selected."
+  (frame-display (selected-frame)))
+
 (defun display-mouse-p (&optional display)
   "Return non-nil if DISPLAY has a mouse available.
 DISPLAY can be a display name, a frame, or nil (meaning the selected
@@ -1131,7 +1202,7 @@
      ((eq frame-type 'pc)
       16)
      (t
-      (tty-display-color-cells)))))
+      (tty-display-color-cells display)))))

 (defun display-visual-class (&optional display)
   "Returns the visual class of DISPLAY.
@@ -1363,6 +1434,8 @@
 (define-key ctl-x-5-map "0" 'delete-frame)
 (define-key ctl-x-5-map "o" 'other-frame)

+(substitute-key-definition 'suspend-emacs 'suspend-frame global-map)
+
 (provide 'frame)

 ;;; arch-tag: 82979c70-b8f2-4306-b2ad-ddbd6b328b56
--- a/lisp/international/mule-cmds.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/international/mule-cmds.el	Mon Oct 25 18:17:28 2004 +0000
@@ -2300,6 +2300,115 @@
 	    (pop cs)))
 	(if c (coding-system-base c)))))

+(defun set-locale-translation-file-name ()
+  "Set up the locale-translation-file-name on the current system.
+
+This needs to be done at runtime for the sake of binaries
+possibly transported to a system without X."
+  (setq locale-translation-file-name
+	(let ((files
+	       '("/usr/lib/X11/locale/locale.alias" ; e.g. X11R6.4
+		 "/usr/X11R6/lib/X11/locale/locale.alias" ; XFree86, e.g. RedHat 4.2
+		 "/usr/openwin/lib/locale/locale.alias" ; e.g. Solaris 2.6
+		 ;;
+		 ;; The following name appears after the X-related names above,
+		 ;; since the X-related names are what X actually uses.
+		 "/usr/share/locale/locale.alias" ; GNU/Linux sans X
+		 )))
+	  (while (and files (not (file-exists-p (car files))))
+	    (setq files (cdr files)))
+	  (car files))))
+
+(defun get-locale-real-name (&optional locale-name)
+  "Return the canonicalized name of locale LOCALE-NAME.
+
+LOCALE-NAME should be a string which is the name of a locale supported
+by the system.  Often it is of the form xx_XX.CODE, where xx is a
+language, XX is a country, and CODE specifies a character set and
+coding system.  For example, the locale name \"ja_JP.EUC\" might name
+a locale for Japanese in Japan using the `japanese-iso-8bit'
+coding-system.  The name may also have a modifier suffix, e.g. `@euro'
+or `@cyrillic'.
+
+If LOCALE-NAME is nil, its value is taken from the environment
+variables LC_ALL, LC_CTYPE and LANG (the first one that is set).
+On server frames, the environment of the emacsclient process is
+used.
+
+See also `set-locale-environment'."
+  (unless locale-name
+    ;; Use the first of these three environment variables
+    ;; that has a nonempty value.
+    (let ((vars '("LC_ALL" "LC_CTYPE" "LANG")))
+      (while (and vars
+		  (= 0 (length locale-name))) ; nil or empty string
+	(setq locale-name (server-getenv (pop vars))))))
+
+    (when locale-name
+      ;; Translate "swedish" into "sv_SE.ISO8859-1", and so on,
+      ;; using the translation file that many systems have.
+      (when locale-translation-file-name
+	(with-temp-buffer
+	  (insert-file-contents locale-translation-file-name)
+	  (when (re-search-forward
+		 (concat "^" (regexp-quote locale-name) ":?[ \t]+") nil t)
+	    (setq locale-name (buffer-substring (point) (line-end-position)))))))
+    locale-name)
+
+(defun get-locale-coding-system (&optional locale)
+  "Return the coding system corresponding to locale LOCALE."
+  (setq locale (or locale (get-locale-real-name nil)))
+  (when locale
+    (or (locale-name-match locale locale-preferred-coding-systems)
+	(when locale
+	  (if (string-match "\\.\\([^@]+\\)" locale)
+	      (locale-charset-to-coding-system
+	       (match-string 1 locale)))))))
+
+(defun configure-display-for-locale (&optional locale)
+  "Set up terminal for locale LOCALE.
+
+The display table, the terminal coding system and the keyboard
+coding system of the current display device are set up for the
+given locale."
+  (setq locale (or locale (get-locale-real-name nil)))
+
+  (when locale
+    (let ((language-name
+	   (locale-name-match locale locale-language-names))
+	  (charset-language-name
+	   (locale-name-match locale locale-charset-language-names))
+	  (coding-system
+	   (get-locale-coding-system locale)))
+
+      ;; Give preference to charset-language-name over language-name.
+      (if (and charset-language-name
+	       (not
+		(equal (get-language-info language-name 'charset)
+		       (get-language-info charset-language-name 'charset))))
+	  (setq language-name charset-language-name))
+
+      (when language-name
+
+	;; If default-enable-multibyte-characters is nil,
+	;; we are using single-byte characters,
+	;; so the display table and terminal coding system are irrelevant.
+	(when default-enable-multibyte-characters
+	  ;; Override default-terminal-coding-system in case the
+	  ;; display coding can not be derived from the language
+	  ;; environment.
+	  (let ((default-terminal-coding-system coding-system))
+	    (set-display-table-and-terminal-coding-system language-name)))
+
+	;; Set the `keyboard-coding-system' if appropriate (tty
+	;; only).  At least X and MS Windows can generate
+	;; multilingual input.
+	(unless window-system
+	  (let ((kcs (or coding-system
+			 (car (get-language-info language-name
+						 'coding-system)))))
+	    (if kcs (set-keyboard-coding-system kcs))))))))
+
 ;; Fixme: This ought to deal with the territory part of the locale
 ;; too, for setting things such as calendar holidays, ps-print paper
 ;; size, spelling dictionary.
@@ -2319,6 +2428,8 @@

 If LOCALE-NAME is nil, its value is taken from the environment
 variables LC_ALL, LC_CTYPE and LANG (the first one that is set).
+On server frames, the environment of the emacsclient process is
+used.

 The locale names supported by your system can typically be found in a
 directory named `/usr/share/locale' or `/usr/lib/locale'.  LOCALE-NAME
@@ -2329,43 +2440,10 @@
 `locale-preferred-coding-systems' and `locale-coding-system'."
   (interactive "sSet environment for locale: ")

-  ;; Do this at runtime for the sake of binaries possibly transported
-  ;; to a system without X.
-  (setq locale-translation-file-name
-	(let ((files
-	       '("/usr/lib/X11/locale/locale.alias" ; e.g. X11R6.4
-		 "/usr/X11R6/lib/X11/locale/locale.alias" ; XFree86, e.g. RedHat 4.2
-		 "/usr/openwin/lib/locale/locale.alias" ; e.g. Solaris 2.6
-		 ;;
-		 ;; The following name appears after the X-related names above,
-		 ;; since the X-related names are what X actually uses.
-		 "/usr/share/locale/locale.alias" ; GNU/Linux sans X
-		 )))
-	  (while (and files (not (file-exists-p (car files))))
-	    (setq files (cdr files)))
-	  (car files)))
-
-  (let ((locale locale-name))
-
-    (unless locale
-      ;; Use the first of these three environment variables
-      ;; that has a nonempty value.
-      (let ((vars '("LC_ALL" "LC_CTYPE" "LANG")))
-	(while (and vars
-		    (= 0 (length locale))) ; nil or empty string
-	  (setq locale (getenv (pop vars))))))
+  (let ((locale (get-locale-real-name locale-name)))

     (when locale

-      ;; Translate "swedish" into "sv_SE.ISO8859-1", and so on,
-      ;; using the translation file that many systems have.
-      (when locale-translation-file-name
-	(with-temp-buffer
-	  (insert-file-contents locale-translation-file-name)
-	  (when (re-search-forward
-		 (concat "^" (regexp-quote locale) ":?[ \t]+") nil t)
-	    (setq locale (buffer-substring (point) (line-end-position))))))
-
       ;; Leave the system locales alone if the caller did not specify
       ;; an explicit locale name, as their defaults are set from
       ;; LC_MESSAGES and LC_TIME, not LC_CTYPE, and the user might not
@@ -2376,16 +2454,14 @@

       (setq locale (downcase locale))

+      (configure-display-for-locale locale)
+
       (let ((language-name
 	     (locale-name-match locale locale-language-names))
 	    (charset-language-name
 	     (locale-name-match locale locale-charset-language-names))
 	    (coding-system
-	     (or (locale-name-match locale locale-preferred-coding-systems)
-		 (when locale
-		   (if (string-match "\\.\\([^@]+\\)" locale)
-		       (locale-charset-to-coding-system
-			(match-string 1 locale)))))))
+	     (get-locale-coding-system locale)))

 	;; Give preference to charset-language-name over language-name.
 	(if (and charset-language-name
@@ -2400,21 +2476,6 @@
 	  ;; to do it for both unibyte and multibyte modes.
 	  (set-language-environment language-name)

-	  ;; If default-enable-multibyte-characters is nil,
-	  ;; we are using single-byte characters,
-	  ;; so the display table and terminal coding system are irrelevant.
-	  (when default-enable-multibyte-characters
-	    (set-display-table-and-terminal-coding-system language-name))
-
-	  ;; Set the `keyboard-coding-system' if appropriate (tty
-	  ;; only).  At least X and MS Windows can generate
-	  ;; multilingual input.
-	  (unless window-system
-	    (let ((kcs (or coding-system
-			   (car (get-language-info language-name
-						   'coding-system)))))
-	      (if kcs (set-keyboard-coding-system kcs))))
-
 	  (setq locale-coding-system
 		(car (get-language-info language-name 'coding-priority))))
--- a/lisp/loadup.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/loadup.el	Mon Oct 25 18:17:28 2004 +0000
@@ -67,6 +67,8 @@
 (setq load-source-file-function 'load-with-code-conversion)
 (load "files")

+(load "startup")
+
 (load "cus-face")
 (load "faces")  ; after here, `defface' may be used.

@@ -146,7 +148,6 @@
 (message "%s" (garbage-collect))
 (load "menu-bar")
 (load "paths.el")  ;Don't get confused if someone compiled paths by mistake.
-(load "startup")
 (load "emacs-lisp/lisp")
 (load "textmodes/page")
 (load "register")
@@ -162,6 +163,7 @@
       (load "vmsproc")))
 (load "abbrev")
 (load "buff-menu")
+(load "server") ; server-getenv is used throughout the terminal initialization code
 (if (eq system-type 'vax-vms)
     (progn
       (load "vms-patch")))
@@ -189,6 +191,15 @@
       (load "emacs-lisp/float-sup")))
 (message "%s" (garbage-collect))

+;; Load auxiliary settings for X displays if we support them.
+(when (fboundp 'x-create-frame)
+  (load "mouse")
+  (load "international/fontset")
+  (load "x-dnd")
+  (load "term/x-win"))
+
+(message "%s" (garbage-collect))
+
 (load "vc-hooks")
 (load "ediff-hook")
 (message "%s" (garbage-collect))
--- a/lisp/server.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/server.el	Mon Oct 25 18:17:28 2004 +0000
@@ -8,6 +8,7 @@
 ;; Keywords: processes

 ;; Changes by peck@sun.com and by rms.
+;; Overhaul by Karoly Lorentey <lorentey@elte.hu> for multi-tty support.

 ;; This file is part of GNU Emacs.

@@ -41,7 +42,7 @@
 ;; This program transmits the file names to Emacs through
 ;; the server subprocess, and Emacs visits them and lets you edit them.

-;; Note that any number of clients may dispatch files to emacs to be edited.
+;; Note that any number of clients may dispatch files to Emacs to be edited.

 ;; When you finish editing a Server buffer, again call server-edit
 ;; to mark that buffer as done for the client and switch to the next
@@ -102,9 +103,8 @@

 (defvar server-clients nil
   "List of current server clients.
-Each element is (CLIENTID BUFFERS...) where CLIENTID is a string
-that can be given to the server process to identify a client.
-When a buffer is marked as \"done\", it is removed from this list.")
+Each element is (PROC PROPERTIES...) where PROC is a process object,
+and PROPERTIES is an association list of client properties.")

 (defvar server-buffer-clients nil
   "List of client ids for clients requesting editing of current buffer.")
@@ -161,57 +161,183 @@

 (defvar server-name "server")

-(defvar server-socket-dir
-  (format "/tmp/emacs%d" (user-uid)))
+(defvar server-socket-dir nil
+  "The directory in which to place the server socket.
+Initialized by `server-start'.")
+
+(defun server-client (proc)
+  "Return the Emacs client corresponding to PROC.
+PROC must be a process object.
+The car of the result is PROC; the cdr is an association list.
+See `server-client-get' and `server-client-set'."
+  (assq proc server-clients))
+
+(defun server-client-get (client property)
+  "Get the value of PROPERTY in CLIENT.
+CLIENT may be a process object, or a client returned by `server-client'.
+Return nil if CLIENT has no such property."
+  (or (listp client) (setq client (server-client client)))
+  (cdr (assq property (cdr client))))
+
+(defun server-client-set (client property value)
+  "Set the PROPERTY to VALUE in CLIENT, and return VALUE.
+CLIENT may be a process object, or a client returned by `server-client'."
+  (let (p proc)
+    (if (listp client)
+	(setq proc (car client))
+      (setq proc client
+	    client (server-client client)))
+    (setq p (assq property client))
+    (cond
+     (p (setcdr p value))
+     (client (setcdr client (cons (cons property value) (cdr client))))
+     (t (setq server-clients
+	      `((,proc (,property . ,value)) . ,server-clients))))
+    value))
+
+(defun server-clients-with (property value)
+  "Return a list of clients with PROPERTY set to VALUE."
+  (let (result)
+    (dolist (client server-clients result)
+      (when (equal value (server-client-get client property))
+	(setq result (cons (car client) result))))))
+
+(defun server-add-client (proc)
+  "Create a client for process PROC, if it doesn't already have one.
+New clients have no properties."
+  (unless (server-client proc)
+    (setq server-clients (cons (cons proc nil)
+			       server-clients))))
+
+;;;###autoload
+(defun server-getenv (variable &optional frame)
+  "Get the value of VARIABLE in the client environment of frame FRAME.
+VARIABLE should be a string.  Value is nil if VARIABLE is undefined in
+the environment.  Otherwise, value is a string.
+
+If FRAME is an emacsclient frame, then the variable is looked up
+in the environment of the emacsclient process; otherwise the
+function consults the environment of the Emacs process.
+
+If FRAME is nil or missing, then the selected frame is used."
+  (when (not frame) (setq frame (selected-frame)))
+  (let ((client (frame-parameter frame 'client)) env)
+    (if (null client)
+	(getenv variable)
+      (setq env (server-client-get client 'environment))
+      (if (null env)
+	  (getenv variable)
+	(cdr (assoc variable env))))))
+
+(defmacro server-with-client-environment (client vars &rest body)
+  "Evaluate BODY with environment variables VARS set to those of CLIENT.
+The environment variables are then restored to their previous values.
+
+VARS should be a list of strings."
+  (declare (indent 2))
+  (let ((oldvalues (make-symbol "oldvalues"))
+	(var (make-symbol "var"))
+	(value (make-symbol "value"))
+	(pair (make-symbol "pair")))
+    `(let (,oldvalues)
+       (dolist (,var (quote ,vars))
+	 (let ((,value (cdr (assoc ,var (server-client-get ,client 'environment)))))
+	   (setq ,oldvalues (cons (cons ,var (getenv ,var)) ,oldvalues))
+	   (setenv ,var ,value)))
+       (unwind-protect
+	   (progn ,@body)
+	 (dolist (,pair ,oldvalues)
+	   (setenv (car ,pair) (cdr ,pair)))))))
+
+(defun server-delete-client (client &optional noframe)
+  "Delete CLIENT, including its buffers, displays and frames.
+If NOFRAME is non-nil, let the frames live.  (To be used from
+`delete-frame-functions'."
+  ;; Force a new lookup of client (prevents infinite recursion).
+  (setq client (server-client
+		(if (listp client) (car client) client)))
+  (let ((proc (car client))
+	(buffers (server-client-get client 'buffers)))
+    (when client
+      (setq server-clients (delq client server-clients))
+
+      (dolist (buf buffers)
+	(when (buffer-live-p buf)
+	  (with-current-buffer buf
+	    ;; Remove PROC from the clients of each buffer.
+	    (setq server-buffer-clients (delq proc server-buffer-clients))
+	    ;; Kill the buffer if necessary.
+	    (when (and (null server-buffer-clients)
+		       (or (and server-kill-new-buffers
+				(not server-existing-buffer))
+			   (server-temp-file-p)))
+	      (kill-buffer (current-buffer))))))
+
+      ;; Delete the client's tty.
+      (let ((display-id (server-client-get client 'display)))
+	(when (eq (display-live-p display-id) t)
+	  (delete-display display-id)))
+
+      ;; Delete the client's frames.
+      (unless noframe
+	(dolist (frame (frame-list))
+	  (if (and (frame-live-p frame)
+		   (equal (car client) (frame-parameter frame 'client)))
+	      (delete-frame frame))))
+
+      ;; Delete the client's process.
+      (if (eq (process-status (car client)) 'open)
+	  (delete-process (car client)))
+
+      (server-log "Deleted" proc))))

 (defun server-log (string &optional client)
-  "If a *server* buffer exists, write STRING to it for logging purposes."
+  "If a *server* buffer exists, write STRING to it for logging purposes.
+If CLIENT is non-nil, add a description of it to the logged
+message."
   (if (get-buffer "*server*")
       (with-current-buffer "*server*"
 	(goto-char (point-max))
 	(insert (current-time-string)
-		(if client (format " %s:" client) " ")
+		(cond
+		 ((null client) " ")
+		 ((listp client) (format " %s: " (car client)))
+		 (t (format " %s: " client)))
 		string)
 	(or (bolp) (newline)))))

 (defun server-sentinel (proc msg)
-  (let ((client (assq proc server-clients)))
-    ;; Remove PROC from the list of clients.
-    (when client
-      (setq server-clients (delq client server-clients))
-      (dolist (buf (cdr client))
-	(with-current-buffer buf
-	  ;; Remove PROC from the clients of each buffer.
-	  (setq server-buffer-clients (delq proc server-buffer-clients))
-	  ;; Kill the buffer if necessary.
-	  (when (and (null server-buffer-clients)
-		     (or (and server-kill-new-buffers
-			      (not server-existing-buffer))
-			 (server-temp-file-p)))
-	    (kill-buffer (current-buffer)))))))
-  (server-log (format "Status changed to %s" (process-status proc)) proc))
+  "The process sentinel for Emacs server connections."
+  (server-log (format "Status changed to %s: %s" (process-status proc) msg) proc)
+  (server-delete-client proc))

-(defun server-select-display (display)
-  ;; If the current frame is on `display' we're all set.
-  (unless (equal (frame-parameter (selected-frame) 'display) display)
-    ;; Otherwise, look for an existing frame there and select it.
-    (dolist (frame (frame-list))
-      (when (equal (frame-parameter frame 'display) display)
-	(select-frame frame)))
-    ;; If there's no frame on that display yet, create a dummy one
-    ;; and select it.
-    (unless (equal (frame-parameter (selected-frame) 'display) display)
-      (select-frame
-       (make-frame-on-display
-	display
-	;; This frame is only there in place of an actual "current display"
-	;; setting, so we want it to be as unobtrusive as possible.  That's
-	;; what the invisibility is for.  The minibuffer setting is so that
-	;; we don't end up displaying a buffer in it (which noone would
-	;; notice).
-	'((visibility . nil) (minibuffer . only)))))))
+(defun server-handle-delete-frame (frame)
+  "Delete the client connection when the emacsclient frame is deleted."
+  (let ((proc (frame-parameter frame 'client)))
+    (when (and proc
+	       (or (window-system frame)
+		   ;; A terminal display must not yet be deleted if
+		   ;; there are other frames on it.
+		   (< 0 (let ((frame-num 0))
+			  (mapc (lambda (f)
+				  (when (eq (frame-display f)
+					    (frame-display frame))
+				    (setq frame-num (1+ frame-num))))
+				(frame-list))
+			  frame-num))))
+      (server-log (format "server-handle-delete-frame, frame %s" frame) proc)
+      (server-delete-client proc 'noframe)))) ; Let delete-frame delete the frame later.
+
+(defun server-handle-suspend-tty (display)
+  "Notify the emacsclient process to suspend itself when its tty device is suspended."
+  (dolist (proc (server-clients-with 'display display))
+    (server-log (format "server-handle-suspend-tty, display %s" display) proc)
+    (condition-case err
+	(process-send-string proc "-suspend \n")
+      (file-error (condition-case nil (server-delete-client proc) (error nil))))))

 (defun server-unquote-arg (arg)
+  "Remove &-quotation from ARG."
   (replace-regexp-in-string
    "&." (lambda (s)
 	  (case (aref s 1)
@@ -221,6 +347,19 @@
 	    (t " ")))
    arg t t))

+(defun server-quote-arg (arg)
+  "In ARG, insert a & before each &, each space, each newline, and -.
+Change spaces to underscores, too, so that the return value never
+contains a space."
+  (replace-regexp-in-string
+   "[-&\n ]" (lambda (s)
+	       (case (aref s 0)
+		 (?& "&&")
+		 (?- "&-")
+		 (?\n "&n")
+		 (?\s "&_")))
+   arg t t))
+
 (defun server-ensure-safe-dir (dir)
   "Make sure DIR is a directory with no race-condition issues.
 Creates the directory if necessary and makes sure:
@@ -241,38 +380,53 @@
 (defun server-start (&optional leave-dead)
   "Allow this Emacs process to be a server for client processes.
 This starts a server communications subprocess through which
-client \"editors\" can send your editing commands to this Emacs job.
-To use the server, set up the program `emacsclient' in the
+client \"editors\" can send your editing commands to this Emacs
+job.  To use the server, set up the program `emacsclient' in the
 Emacs distribution as your standard \"editor\".

-Prefix arg means just kill any existing server communications subprocess."
+Prefix arg LEAVE-DEAD means just kill any existing server
+communications subprocess."
   (interactive "P")
-  ;; Make sure there is a safe directory in which to place the socket.
-  (server-ensure-safe-dir server-socket-dir)
-  ;; kill it dead!
-  (if server-process
-      (condition-case () (delete-process server-process) (error nil)))
-  ;; Delete the socket files made by previous server invocations.
-  (condition-case ()
-      (delete-file (expand-file-name server-name server-socket-dir))
-    (error nil))
-  ;; If this Emacs already had a server, clear out associated status.
-  (while server-clients
-    (let ((buffer (nth 1 (car server-clients))))
-      (server-buffer-done buffer)))
-  (unless leave-dead
+  (when (or
+	 (not server-clients)
+	 (yes-or-no-p
+	  "The current server still has clients; delete them? "))
+    ;; It is safe to get the user id now.
+    (setq server-socket-dir (or server-socket-dir
+				(format "/tmp/emacs%d" (user-uid))))
+    ;; Make sure there is a safe directory in which to place the socket.
+    (server-ensure-safe-dir server-socket-dir)
+    ;; kill it dead!
     (if server-process
-	(server-log (message "Restarting server")))
-    (letf (((default-file-modes) ?\700))
-      (setq server-process
-	    (make-network-process
-	     :name "server" :family 'local :server t :noquery t
-	     :service (expand-file-name server-name server-socket-dir)
-	     :sentinel 'server-sentinel :filter 'server-process-filter
-	     ;; We must receive file names without being decoded.
-	     ;; Those are decoded by server-process-filter according
-	     ;; to file-name-coding-system.
-	     :coding 'raw-text)))))
+	(condition-case () (delete-process server-process) (error nil)))
+    ;; Delete the socket files made by previous server invocations.
+    (condition-case ()
+	(delete-file (expand-file-name server-name server-socket-dir))
+      (error nil))
+    ;; If this Emacs already had a server, clear out associated status.
+    (while server-clients
+      (server-delete-client (car server-clients)))
+    (if leave-dead
+	(progn
+	  (server-log (message "Server stopped"))
+	  (setq server-process nil))
+      (if server-process
+	  (server-log (message "Restarting server"))
+	(server-log (message "Starting server")))
+      (letf (((default-file-modes) ?\700))
+	(add-hook 'suspend-tty-functions 'server-handle-suspend-tty)
+	(add-hook 'delete-frame-functions 'server-handle-delete-frame)
+	(add-hook 'kill-buffer-query-functions 'server-kill-buffer-query-function)
+	(add-hook 'kill-emacs-query-functions 'server-kill-emacs-query-function)
+	(setq server-process
+	      (make-network-process
+	       :name "server" :family 'local :server t :noquery t
+	       :service (expand-file-name server-name server-socket-dir)
+	       :sentinel 'server-sentinel :filter 'server-process-filter
+	       ;; We must receive file names without being decoded.
+	       ;; Those are decoded by server-process-filter according
+	       ;; to file-name-coding-system.
+	       :coding 'raw-text))))))

 ;;;###autoload
 (define-minor-mode server-mode
@@ -295,98 +449,233 @@
     (when prev
       (setq string (concat prev string))
       (process-put proc 'previous-string nil)))
-  ;; If the input is multiple lines,
-  ;; process each line individually.
-  (while (string-match "\n" string)
-    (let ((request (substring string 0 (match-beginning 0)))
-	  (coding-system (and default-enable-multibyte-characters
-			      (or file-name-coding-system
-				  default-file-name-coding-system)))
-	  client nowait eval
-	  (files nil)
-	  (lineno 1)
-	  (tmp-frame nil) ; Sometimes used to embody the selected display.
-	  (columnno 0))
-      ;; Remove this line from STRING.
-      (setq string (substring string (match-end 0)))
-      (setq client (cons proc nil))
-      (while (string-match "[^ ]* " request)
-	(let ((arg (substring request (match-beginning 0) (1- (match-end 0)))))
-	  (setq request (substring request (match-end 0)))
-	  (cond
-	   ((equal "-nowait" arg) (setq nowait t))
-	   ((equal "-eval" arg) (setq eval t))
-	   ((and (equal "-display" arg) (string-match "\\([^ ]*\\) " request))
-	    (let ((display (server-unquote-arg (match-string 1 request))))
-	      (setq request (substring request (match-end 0)))
-	      (condition-case err
-		  (setq tmp-frame (server-select-display display))
-		(error (process-send-string proc (nth 1 err))
-		       (setq request "")))))
-	   ;; ARG is a line number option.
-	   ((string-match "\\`\\+[0-9]+\\'" arg)
-	    (setq lineno (string-to-int (substring arg 1))))
-	   ;; ARG is line number:column option.
-	   ((string-match "\\`+\\([0-9]+\\):\\([0-9]+\\)\\'" arg)
-	    (setq lineno (string-to-int (match-string 1 arg))
-		  columnno (string-to-int (match-string 2 arg))))
-	   (t
-	    ;; Undo the quoting that emacsclient does
-	    ;; for certain special characters.
-	    (setq arg (server-unquote-arg arg))
-	    ;; Now decode the file name if necessary.
-	    (if coding-system
-		(setq arg (decode-coding-string arg coding-system)))
-	    (if eval
-		(let ((v (eval (car (read-from-string arg)))))
-		  (when v
-		    (with-temp-buffer
-		      (let ((standard-output (current-buffer)))
-			(pp v)
-			;; Suppress the error rose when the pipe to PROC is closed.
-			(condition-case err
-			    (process-send-region proc (point-min) (point-max))
-			  (file-error nil))
-			))))
-	      ;; ARG is a file name.
-	      ;; Collapse multiple slashes to single slashes.
-	      (setq arg (command-line-normalize-file-name arg))
-	      (push (list arg lineno columnno) files))
-	    (setq lineno 1)
-	    (setq columnno 0)))))
-      (when files
-	(run-hooks 'pre-command-hook)
-	(server-visit-files files client nowait)
-	(run-hooks 'post-command-hook))
-      ;; CLIENT is now a list (CLIENTNUM BUFFERS...)
-      (if (null (cdr client))
-	  ;; This client is empty; get rid of it immediately.
-	  (progn
-	    (delete-process proc)
-	    (server-log "Close empty client" proc))
-	;; We visited some buffer for this client.
-	(or nowait (push client server-clients))
-	(unless (or isearch-mode (minibufferp))
-	  (server-switch-buffer (nth 1 client))
-	  (run-hooks 'server-switch-hook)
-	  (unless nowait
-	    (message (substitute-command-keys
-		      "When done with a buffer, type \\[server-edit]")))))
-      ;; Avoid preserving the connection after the last real frame is deleted.
-      (if tmp-frame (delete-frame tmp-frame))))
-  ;; Save for later any partial line that remains.
-  (when (> (length string) 0)
-    (process-put proc 'previous-string string)))
+  (condition-case err
+      (progn
+	(server-add-client proc)
+	;; If the input is multiple lines,
+	;; process each line individually.
+	(while (string-match "\n" string)
+	  (let ((request (substring string 0 (match-beginning 0)))
+		(coding-system (and default-enable-multibyte-characters
+				    (or file-name-coding-system
+					default-file-name-coding-system)))
+		(client (server-client proc))
+		nowait ; t if emacsclient does not want to wait for us.
+		frame ; The frame that was opened for the client (if any).
+		display ; Open the frame on this display.
+		dontkill       ; t if the client should not be killed.
+		(files nil)
+		(lineno 1)
+		(columnno 0))
+	    ;; Remove this line from STRING.
+	    (setq string (substring string (match-end 0)))
+	    (while (string-match " *[^ ]* " request)
+	      (let ((arg (substring request (match-beginning 0) (1- (match-end 0)))))
+		(setq request (substring request (match-end 0)))
+		(cond
+		 ;; -version CLIENT-VERSION:
+		 ;; Check version numbers, signal an error if there is a mismatch.
+		 ((and (equal "-version" arg)
+		       (string-match "\\([0-9.]+\\) " request))
+		  (let* ((client-version (match-string 1 request))
+			 (truncated-emacs-version
+			  (substring emacs-version 0 (length client-version))))
+		    (setq request (substring request (match-end 0)))
+		    (if (equal client-version truncated-emacs-version)
+			(progn
+			  (process-send-string proc "-good-version \n")
+			  (server-client-set client 'version client-version))
+		      (error (concat "Version mismatch: Emacs is "
+				     truncated-emacs-version
+				     ", emacsclient is " client-version)))))
+
+		 ;; -nowait:  Emacsclient won't wait for a result.
+		 ((equal "-nowait" arg) (setq nowait t))
+
+		 ;; -display DISPLAY:
+		 ;; Open X frames on the given instead of the default.
+		 ((and (equal "-display" arg) (string-match "\\([^ ]*\\) " request))
+		  (setq display (match-string 1 request)
+			request (substring request (match-end 0))))
+
+		 ;; -window-system:  Open a new X frame.
+		 ((equal "-window-system" arg)
+		  (unless (server-client-get client 'version)
+		    (error "Protocol error; make sure to use the correct version of emacsclient"))
+		  (setq frame (make-frame-on-display
+			       (or display
+				   (frame-parameter nil 'display)
+				   (getenv "DISPLAY")
+				   (error "Please specify display"))
+			       (list (cons 'client proc))))
+		  ;; XXX We need to ensure the client parameter is
+		  ;; really set because Emacs forgets initialization
+		  ;; parameters for X frames at the moment.
+		  (modify-frame-parameters frame (list (cons 'client proc)))
+		  (select-frame frame)
+		  (server-client-set client 'frame frame)
+		  (server-client-set client 'display (frame-display frame))
+		  (setq dontkill t))
+
+		 ;; -resume:  Resume a suspended tty frame.
+		 ((equal "-resume" arg)
+		  (let ((display-id (server-client-get client 'display)))
+		    (setq dontkill t)
+		    (when (eq (display-live-p display-id) t)
+		      (resume-tty display-id))))
+
+		 ;; -suspend:  Suspend the client's frame.  (In case we
+		 ;; get out of sync, and a C-z sends a SIGTSTP to
+		 ;; emacsclient.)
+		 ((equal "-suspend" arg)
+		  (let ((display-id (server-client-get client 'display)))
+		    (setq dontkill t)
+		    (when (eq (display-live-p display-id) t)
+		      (suspend-tty display-id))))
+
+		 ;; -ignore COMMENT:  Noop; useful for debugging emacsclient.
+		 ;; (The given comment appears in the server log.)
+		 ((and (equal "-ignore" arg) (string-match "\\([^ ]*\\) " request))
+		  (setq dontkill t
+			request (substring request (match-end 0))))
+
+		 ;; -tty DEVICE-NAME TYPE:  Open a new tty frame at the client.
+		 ((and (equal "-tty" arg) (string-match "\\([^ ]*\\) \\([^ ]*\\) " request))
+		  (let ((tty (server-unquote-arg (match-string 1 request)))
+			(type (server-unquote-arg (match-string 2 request))))
+		    (setq request (substring request (match-end 0)))
+		    (unless (server-client-get client 'version)
+		      (error "Protocol error; make sure you use the correct version of emacsclient"))
+		    ;; Set up client's environment for tgetent(3)
+		    ;; according to ncurses(3).
+		    (server-with-client-environment proc
+			("BAUDRATE" "COLUMNS" "ESCDELAY" "HOME" "LINES"
+			 "NCURSES_ASSUMED_COLORS" "NCURSES_NO_PADDING"
+			 "NCURSES_NO_SETBUF" "TERM" "TERMCAP" "TERMINFO"
+			 "TERMINFO_DIRS" "TERMPATH")
+		      (setq frame (make-frame-on-tty tty type
+						     `((client . ,proc)))))
+		    (select-frame frame)
+		    (server-client-set client 'frame frame)
+		    (server-client-set client 'tty (display-name frame))
+		    (server-client-set client 'display (frame-display frame))
+		    ;; Set up display for the remote locale.
+		    (configure-display-for-locale)
+		    ;; Reply with our pid.
+		    (process-send-string proc (concat "-emacs-pid " (number-to-string (emacs-pid)) "\n"))
+		    (setq dontkill t)))
+
+		 ;; -position LINE:  Go to the given line in the next file.
+		 ((and (equal "-position" arg) (string-match "\\(\\+[0-9]+\\) " request))
+		  (setq request (substring request (match-end 0))
+			lineno (string-to-int (substring (match-string 1 request) 1))))
+
+		 ;; -position LINE:COLUMN:  Set point to the given position in the next file.
+		 ((and (equal "-position" arg) (string-match "\\+\\([0-9]+\\):\\([0-9]+\\) " request))
+		  (setq request (substring request (match-end 0))
+			lineno (string-to-int (match-string 1 request))
+			columnno (string-to-int (match-string 2 request))))
+
+		 ;; -file FILENAME:  Load the given file.
+		 ((and (equal "-file" arg) (string-match "\\([^ ]+\\) " request))
+		  (let ((file (server-unquote-arg (match-string 1 request))))
+		    (setq request (substring request (match-end 0)))
+		    (if coding-system
+			(setq file (decode-coding-string file coding-system)))
+		    (setq file (command-line-normalize-file-name file))
+		    (push (list file lineno columnno) files))
+		  (setq lineno 1
+			columnno 0))
+
+		 ;; -eval EXPR:  Evaluate a Lisp expression.
+		 ((and (equal "-eval" arg) (string-match "\\([^ ]+\\) " request))
+		  (let ((expr (server-unquote-arg (match-string 1 request))))
+		    (setq request (substring request (match-end 0)))
+		    (if coding-system
+			(setq expr (decode-coding-string expr coding-system)))
+		    (let ((v (eval (car (read-from-string expr)))))
+		      (when (and (not frame) v)
+			(with-temp-buffer
+			  (let ((standard-output (current-buffer)))
+			    (pp v)
+			    (process-send-string proc "-print ")
+			    (process-send-string
+			     proc (server-quote-arg
+				   (buffer-substring-no-properties (point-min)
+								   (point-max))))
+			    (process-send-string proc "\n")))))
+		    (setq lineno 1
+			  columnno 0)))
+
+		 ;; -env NAME VALUE:  An environment variable.
+		 ((and (equal "-env" arg) (string-match "\\([^ ]+\\) \\([^ ]+\\) " request))
+		  (let ((name (server-unquote-arg (match-string 1 request)))
+			(value (server-unquote-arg (match-string 2 request))))
+		    (when coding-system
+			(setq name (decode-coding-string name coding-system))
+			(setq value (decode-coding-string value coding-system)))
+		    (setq request (substring request (match-end 0)))
+		    (server-client-set
+		     client 'environment
+		     (cons (cons name value)
+			   (server-client-get client 'environment)))))
+
+		 ;; Unknown command.
+		 (t (error "Unknown command: %s" arg)))))
+
+	    (let (buffers)
+	      (when files
+		(run-hooks 'pre-command-hook)
+		(setq buffers (server-visit-files files client nowait))
+		(run-hooks 'post-command-hook))
+
+	      ;; Delete the client if necessary.
+	      (cond
+	       (nowait
+		;; Client requested nowait; return immediately.
+		(server-log "Close nowait client" proc)
+		(server-delete-client proc))
+	       ((and (not dontkill) (null buffers))
+		;; This client is empty; get rid of it immediately.
+		(server-log "Close empty client" proc)
+		(server-delete-client proc)))
+	      (cond
+	       ((or isearch-mode (minibufferp))
+		nil)
+	       ((and frame (null buffers))
+		(message (substitute-command-keys
+			  "When done with this frame, type \\[delete-frame]")))
+	       ((not (null buffers))
+		(server-switch-buffer (car buffers))
+		(run-hooks 'server-switch-hook)
+		(unless nowait
+		  (message (substitute-command-keys
+			    "When done with a buffer, type \\[server-edit]"))))))))
+
+	;; Save for later any partial line that remains.
+	(when (> (length string) 0)
+	  (process-put proc 'previous-string string)))
+    ;; condition-case
+    (error (ignore-errors
+	     (process-send-string
+	      proc (concat "-error " (server-quote-arg (error-message-string err))))
+	     (setq string "")
+	     (server-log (error-message-string err) proc)
+	     (delete-process proc)))))

 (defun server-goto-line-column (file-line-col)
+  "Move point to the position indicated in FILE-LINE-COL.
+FILE-LINE-COL should be a three-element list as described in
+`server-visit-files'."
   (goto-line (nth 1 file-line-col))
   (let ((column-number (nth 2 file-line-col)))
     (if (> column-number 0)
 	(move-to-column (1- column-number)))))

 (defun server-visit-files (files client &optional nowait)
-  "Find FILES and return the list CLIENT with the buffers nconc'd.
+  "Find FILES and return a list of buffers created.
 FILES is an alist whose elements are (FILENAME LINENUMBER COLUMNNUMBER).
+CLIENT is the client that requested this operation.
 NOWAIT non-nil means this client is not waiting for the results,
 so don't mark these buffers specially, just visit them normally."
   ;; Bind last-nonmenu-event to force use of keyboard, not mouse, for queries.
@@ -409,8 +698,7 @@
 			   (revert-buffer t nil)))
 		      (t
 		       (if (y-or-n-p
-			    (concat "File no longer exists: "
-				    filen
+			    (concat "File no longer exists: " filen
 				    ", write buffer to file? "))
 			   (write-file filen))))
 		(setq server-existing-buffer t)
@@ -423,7 +711,11 @@
 	  (add-hook 'kill-buffer-hook 'server-kill-buffer nil t)
 	  (push (car client) server-buffer-clients))
 	(push (current-buffer) client-record)))
-    (nconc client client-record)))
+    (unless nowait
+      (server-client-set
+       client 'buffers
+       (nconc (server-client-get client 'buffers) client-record)))
+    client-record))

 (defun server-buffer-done (buffer &optional for-killing)
   "Mark BUFFER as \"done\" for its client(s).
@@ -433,27 +725,24 @@
 a temp file).
 FOR-KILLING if non-nil indicates that we are called from `kill-buffer'."
   (let ((next-buffer nil)
-	(killed nil)
-	(old-clients server-clients))
-    (while old-clients
-      (let ((client (car old-clients)))
+	(killed nil))
+    (dolist (client server-clients)
+      (let ((buffers (server-client-get client 'buffers)))
 	(or next-buffer
-	    (setq next-buffer (nth 1 (memq buffer client))))
-	(delq buffer client)
-	;; Delete all dead buffers from CLIENT.
-	(let ((tail client))
-	  (while tail
-	    (and (bufferp (car tail))
-		 (null (buffer-name (car tail)))
-		 (delq (car tail) client))
-	    (setq tail (cdr tail))))
-	;; If client now has no pending buffers,
-	;; tell it that it is done, and forget it entirely.
-	(unless (cdr client)
-	  (delete-process (car client))
-	  (server-log "Close" (car client))
-	  (setq server-clients (delq client server-clients))))
-      (setq old-clients (cdr old-clients)))
+	    (setq next-buffer (nth 1 (memq buffer buffers))))
+	(when buffers			; Ignore bufferless clients.
+	  (setq buffers (delq buffer buffers))
+	  ;; Delete all dead buffers from CLIENT.
+	  (dolist (b buffers)
+	    (and (bufferp b)
+		 (not (buffer-live-p b))
+		 (setq buffers (delq b buffers))))
+	  (server-client-set client 'buffers buffers)
+	  ;; If client now has no pending buffers,
+	  ;; tell it that it is done, and forget it entirely.
+	  (unless buffers
+	    (server-log "Close" client)
+	    (server-delete-client client)))))
     (if (and (bufferp buffer) (buffer-name buffer))
 	;; We may or may not kill this buffer;
 	;; if we do, do not call server-buffer-done recursively
@@ -518,30 +807,32 @@
 ;; but I think that is dangerous--the client would proceed
 ;; using whatever is on disk in that file. -- rms.
 (defun server-kill-buffer-query-function ()
+  "Ask before killing a server buffer."
   (or (not server-buffer-clients)
+      (let ((res t))
+	(dolist (proc server-buffer-clients res)
+	  (let ((client (server-client proc)))
+	    (when (and client (eq (process-status proc) 'open))
+	      (setq res nil)))))
       (yes-or-no-p (format "Buffer `%s' still has clients; kill it? "
 			   (buffer-name (current-buffer))))))

-(add-hook 'kill-buffer-query-functions
- 	  'server-kill-buffer-query-function)
-
 (defun server-kill-emacs-query-function ()
-  (let (live-client
-	(tail server-clients))
-    ;; See if any clients have any buffers that are still alive.
-    (while tail
-      (if (memq t (mapcar 'stringp (mapcar 'buffer-name (cdr (car tail)))))
-	  (setq live-client t))
-      (setq tail (cdr tail)))
-    (or (not live-client)
-	(yes-or-no-p "Server buffers still have clients; exit anyway? "))))
-
-(add-hook 'kill-emacs-query-functions 'server-kill-emacs-query-function)
+  "Ask before exiting Emacs it has are live clients."
+  (or (not server-clients)
+      (let (live-client)
+	(dolist (client server-clients live-client)
+	  (if (memq t (mapcar 'buffer-live-p (server-client-get
+					      client 'buffers)))
+	      (setq live-client t))))
+      (yes-or-no-p "This Emacs session has clients; exit anyway? ")))

 (defvar server-kill-buffer-running nil
   "Non-nil while `server-kill-buffer' or `server-buffer-done' is running.")

 (defun server-kill-buffer ()
+  "Remove the current buffer from its clients' buffer list.
+Designed to be added to `kill-buffer-hook'."
   ;; Prevent infinite recursion if user has made server-done-hook
   ;; call kill-buffer.
   (or server-kill-buffer-running
@@ -573,18 +864,26 @@

 (defun server-switch-buffer (&optional next-buffer killed-one)
   "Switch to another buffer, preferably one that has a client.
-Arg NEXT-BUFFER is a suggestion; if it is a live buffer, use it."
-  ;; KILLED-ONE is t in a recursive call
-  ;; if we have already killed one temp-file server buffer.
-  ;; This means we should avoid the final "switch to some other buffer"
-  ;; since we've already effectively done that.
+Arg NEXT-BUFFER is a suggestion; if it is a live buffer, use it.
+
+KILLED-ONE is t in a recursive call if we have already killed one
+temp-file server buffer.  This means we should avoid the final
+\"switch to some other buffer\" since we've already effectively
+done that."
   (if (null next-buffer)
-      (if server-clients
-	  (server-switch-buffer (nth 1 (car server-clients)) killed-one)
-	(unless (or killed-one (window-dedicated-p (selected-window)))
-	  (switch-to-buffer (other-buffer))
+      (progn
+	(let ((rest server-clients))
+	  (while (and rest (not next-buffer))
+	    (let ((client (car rest)))
+	      ;; Only look at frameless clients.
+	      (when (not (server-client-get client 'frame))
+		(setq next-buffer (car (server-client-get client 'buffers))))
+	      (setq rest (cdr rest)))))
+	(and next-buffer (server-switch-buffer next-buffer killed-one))
+	(unless (or next-buffer killed-one (window-dedicated-p (selected-window)))
+	  ;; (switch-to-buffer (other-buffer))
 	  (message "No server buffers remain to edit")))
-    (if (not (buffer-name next-buffer))
+    (if (not (buffer-live-p next-buffer))
 	;; If NEXT-BUFFER is a dead buffer, remove the server records for it
 	;; and try the next surviving server buffer.
 	(apply 'server-switch-buffer (server-buffer-done next-buffer))
@@ -624,10 +923,26 @@
 	      ;; a minibuffer/dedicated-window (if there's no other).
 	      (error (pop-to-buffer next-buffer)))))))))

+(defun server-save-buffers-kill-display (&optional arg)
+  "Offer to save each buffer, then kill the current connection.
+If the current frame has no client, kill Emacs itself.
+
+With prefix arg, silently save all file-visiting buffers, then kill."
+  (interactive "P")
+  (let ((proc (frame-parameter (selected-frame) 'client)))
+    (if (and proc)
+	(progn
+	  (save-some-buffers arg t)
+	  (server-delete-client proc))
+      (save-buffers-kill-emacs))))
+
 (global-set-key "\C-x#" 'server-edit)

 (defun server-unload-hook ()
+  "Unload the server library."
   (server-start t)
+  (remove-hook 'suspend-tty-functions 'server-handle-suspend-tty)
+  (remove-hook 'delete-frame-functions 'server-handle-delete-frame)
   (remove-hook 'kill-buffer-query-functions 'server-kill-buffer-query-function)
   (remove-hook 'kill-emacs-query-functions 'server-kill-emacs-query-function)
   (remove-hook 'kill-buffer-hook 'server-kill-buffer))
--- a/lisp/simple.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/simple.el	Mon Oct 25 18:17:28 2004 +0000
@@ -2066,6 +2066,8 @@
 The second, optional, argument PUSH, has the same meaning as the
 similar argument to `x-set-cut-buffer', which see.")

+(make-variable-frame-local 'interprogram-cut-function)
+
 (defvar interprogram-paste-function nil
   "Function to call to get text cut from other programs.

@@ -2086,6 +2088,8 @@
 difficult to tell whether Emacs or some other program provided the
 current string, it is probably good enough to return nil if the string
 is equal (according to `string=') to the last text Emacs provided.")
+
+(make-variable-frame-local 'interprogram-paste-function)
--- a/lisp/startup.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/startup.el	Mon Oct 25 18:17:28 2004 +0000
@@ -36,6 +36,13 @@
 (defvar command-line-processed nil
   "Non-nil once command line has been processed.")

+(defvar window-system initial-window-system
+  "Name of window system the selected frame is displaying through.
+The value is a symbol--for instance, `x' for X windows.
+The value is nil if the selected frame is on a text-only-terminal.")
+
+(make-variable-frame-local 'window-system)
+
 (defgroup initialization nil
   "Emacs start-up procedure"
   :group 'internal)
@@ -414,37 +421,19 @@
 	;; for instance due to a dense colormap.
 	(when (or frame-initial-frame
 		  ;; If frame-initial-frame has no meaning, do this anyway.
-		  (not (and window-system
+		  (not (and initial-window-system
 			    (not noninteractive)
-			    (not (eq window-system 'pc)))))
+			    (not (eq initial-window-system 'pc)))))
 	  ;; Modify the initial frame based on what .emacs puts into
 	  ;; ...-frame-alist.
 	  (if (fboundp 'frame-notice-user-settings)
 	      (frame-notice-user-settings))
+	  ;; Set the faces for the initial background mode even if
+	  ;; frame-notice-user-settings didn't (such as on a tty).
+	  ;; frame-set-background-mode is idempotent, so it won't
+	  ;; cause any harm if it's already been done.
 	  (if (fboundp 'frame-set-background-mode)
-	      ;; Set the faces for the initial background mode even if
-	      ;; frame-notice-user-settings didn't (such as on a tty).
-	      ;; frame-set-background-mode is idempotent, so it won't
-	      ;; cause any harm if it's already been done.
-	      (let ((frame-background-mode frame-background-mode)
-		    (frame (selected-frame))
-		    term)
-		(when (and (null window-system)
-			   ;; Don't override a possibly customized value.
-			   (null frame-background-mode)
-			   ;; Don't override user specifications.
-			   (null (frame-parameter frame 'reverse))
-			   (let ((bg (frame-parameter frame 'background-color)))
-			     (or (null bg)
-				 (member bg '(unspecified "unspecified-bg")))))
-		  (setq term (getenv "TERM"))
-		  ;; Some files in lisp/term do a better job with the
-		  ;; background mode, but we leave this here anyway, in
-		  ;; case they remove those files.
-		  (if (string-match "^\\(xterm\\|rxvt\\|dtterm\\|eterm\\)"
-				    term)
-		      (setq frame-background-mode 'light)))
-		(frame-set-background-mode (selected-frame)))))
+	      (frame-set-background-mode (selected-frame))))

 	;; Now we know the user's default font, so add it to the menu.
 	(if (fboundp 'font-menu-add-default)
@@ -485,6 +474,20 @@
 (defvar tool-bar-originally-present nil
   "Non-nil if tool-bars are present before user and site init files are read.")

+(defvar handle-args-function-alist '((nil . tty-handle-args))
+  "Functions for processing window-system dependent command-line arguments.
+Window system startup files should add their own function to this
+alist, which should parse the command line arguments.  Those
+pertaining to the window system should be processed and removed
+from the returned command line.")
+
+(defvar window-system-initialization-alist '((nil . ignore))
+  "Alist of window-system initialization functions.
+Window-system startup files should add their own initialization
+function to this list.  The function should take no arguments,
+and initialize the window system environment to prepare for
+opening the first frame (e.g. open a connection to the server).")
+
 ;; Handle the X-like command-line arguments "-fg", "-bg", "-name", etc.
 (defun tty-handle-args (args)
   (let (rest)
@@ -602,16 +605,22 @@
     (setq eol-mnemonic-dos  "(DOS)"
           eol-mnemonic-mac  "(Mac)")))

-  ;; Read window system's init file if using a window system.
+  ;; Make sure window system's init file was loaded in loadup.el if using a window system.
   (condition-case error
-      (if (and window-system (not noninteractive))
-	  (load (concat term-file-prefix
-			(symbol-name window-system)
-			"-win")
-		;; Every window system should have a startup file;
-		;; barf if we can't find it.
-		nil t))
-    ;; If we can't read it, print the error message and exit.
+    (unless noninteractive
+      (if (and initial-window-system
+	       (not (featurep
+		     (intern (concat (symbol-name initial-window-system) "-win")))))
+	  (error "Unsupported window system `%s'" initial-window-system))
+      ;; Process window-system specific command line parameters.
+      (setq command-line-args
+	    (funcall (or (cdr (assq initial-window-system handle-args-function-alist))
+			 (error "Unsupported window system `%s'" initial-window-system))
+		     command-line-args))
+      ;; Initialize the window system. (Open connection, etc.)
+      (funcall (or (cdr (assq initial-window-system window-system-initialization-alist))
+		   (error "Unsupported window system `%s'" initial-window-system))))
+    ;; If there was an error, print the error message and exit.
     (error
      (princ
       (if (eq (car error) 'error)
@@ -627,13 +636,11 @@
                              (cdr error) ", "))))
       'external-debugging-output)
      (terpri 'external-debugging-output)
-     (setq window-system nil)
+     (setq initial-window-system nil)
      (kill-emacs)))

-  ;; Windowed displays do this inside their *-win.el.
-  (unless (or (display-graphic-p) noninteractive)
-    (setq command-line-args (tty-handle-args command-line-args)))
-
+  ;; Locale initialization.
+  (set-locale-translation-file-name)
   (set-locale-environment nil)

   ;; Convert the arguments to Emacs internal representation.
@@ -716,7 +723,7 @@
   ;; If frame was created with a menu bar, set menu-bar-mode on.
   (unless (or noninteractive
 	      emacs-quick-startup
-              (and (memq window-system '(x w32))
+              (and (memq initial-window-system '(x w32))
                    (<= (frame-parameter nil 'menu-bar-lines) 0)))
     (menu-bar-mode 1))

@@ -727,11 +734,11 @@
               (<= (frame-parameter nil 'tool-bar-lines) 0))
     (tool-bar-mode 1))

-  ;; Can't do this init in defcustom because window-system isn't set.
+  ;; Can't do this init in defcustom because initial-window-system isn't set.
   (unless (or noninteractive
 	      emacs-quick-startup
               (eq system-type 'ms-dos)
-              (not (memq window-system '(x w32))))
+              (not (memq initial-window-system '(x w32))))
     (setq-default blink-cursor t)
     (blink-cursor-mode 1))

@@ -739,13 +746,13 @@
     ;; DOS/Windows systems have a PC-type keyboard which has both
     ;; <delete> and <backspace> keys.
     (when (or (memq system-type '(ms-dos windows-nt))
-	      (and (memq window-system '(x))
+	      (and (memq initial-window-system '(x))
 		   (fboundp 'x-backspace-delete-keys-p)
 		   (x-backspace-delete-keys-p))
 	      ;; If the terminal Emacs is running on has erase char
 	      ;; set to ^H, use the Backspace key for deleting
 	      ;; backward and, and the Delete key for deleting forward.
-	      (and (null window-system)
+	      (and (null initial-window-system)
 		   (eq tty-erase-char 8)))
       (setq-default normal-erase-is-backspace t)
       (normal-erase-is-backspace-mode 1)))
@@ -759,11 +766,10 @@

   ;; Register default TTY colors for the case the terminal hasn't a
   ;; terminal init file.
-  (unless (memq window-system '(x w32))
-    ;; We do this regardles of whether the terminal supports colors
-    ;; or not, since they can switch that support on or off in
-    ;; mid-session by setting the tty-color-mode frame parameter.
-    (tty-register-default-colors))
+  ;; We do this regardles of whether the terminal supports colors
+  ;; or not, since they can switch that support on or off in
+  ;; mid-session by setting the tty-color-mode frame parameter.
+  (tty-register-default-colors)

   ;; Record whether the tool-bar is present before the user and site
   ;; init files are processed.  frame-notice-user-settings uses this
@@ -962,7 +968,7 @@
   ;; Load library for our terminal type.
   ;; User init file can set term-file-prefix to nil to prevent this.
   (unless (or noninteractive
-              window-system
+              initial-window-system
               (null term-file-prefix))
     (let ((term (getenv "TERM"))
           hyphend)
--- a/lisp/subr.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/subr.el	Mon Oct 25 18:17:28 2004 +0000
@@ -1761,6 +1761,18 @@
        (if (window-live-p save-selected-window-window)
 	   (select-window save-selected-window-window 'norecord)))))

+(defmacro with-selected-frame (frame &rest body)
+  "Execute the forms in BODY with FRAME as the selected frame.
+The value returned is the value of the last form in BODY.
+See also `with-temp-buffer'."
+  (declare (indent 1) (debug t))
+  `(let ((save-selected-frame (selected-frame)))
+     (unwind-protect
+	 (progn (select-frame ,frame)
+		,@body)
+       (if (frame-live-p save-selected-frame)
+	   (select-frame save-selected-frame)))))
+
 (defmacro with-temp-file (file &rest body)
   "Create a new buffer, evaluate BODY there, and write the buffer to FILE.
 The value returned is the value of the last form in BODY.
--- a/lisp/talk.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/talk.el	Mon Oct 25 18:17:28 2004 +0000
@@ -45,17 +45,44 @@
   ;; Add the new buffers to all talk frames.
   (talk-update-buffers))

-(defun talk-add-display (display)
-  (let* ((elt (assoc display talk-display-alist))
-	 (name (concat "*talk-" display "*"))
-	 buffer frame)
-    (if (not (and elt (frame-live-p (setq frame (nth 1 elt)))))
-	(setq frame (make-frame-on-display display (list (cons 'name name)))))
+;;;###autoload
+(defun talk ()
+  "Connect to the Emacs talk group from the current X display or tty frame."
+  (interactive)
+  (let ((type (frame-live-p (selected-frame)))
+	(display (frame-display (selected-frame))))
+    (cond
+     ((eq type t)
+      (talk-add-display (selected-frame)))
+     ((eq type 'x)
+      (talk-add-display (frame-display (selected-frame))))
+     (t
+      (error "Unknown frame type"))))
+  (talk-update-buffers))
+
+(defun talk-add-display (frame)
+  (let* ((display (if (frame-live-p frame)
+		      (frame-display frame)
+		    frame))
+	 (elt (assoc display talk-display-alist))
+	 (name (concat "*talk-" (display-name display) "*"))
+	 buffer)
+    (unless (frame-live-p frame)
+      (setq frame (make-frame-on-display display (list (cons 'name name)))))
+    (if (and elt (frame-live-p (nth 1 elt)))
+	(setq frame (nth 1 elt)))
     (if (not (and elt (buffer-name (get-buffer (setq buffer (nth 2 elt))))))
 	(setq buffer (get-buffer-create name)))
+    (add-to-list 'delete-frame-functions 'talk-handle-delete-frame)
     (setq talk-display-alist
 	  (cons (list display frame buffer) (delq elt talk-display-alist)))))

+(defun talk-handle-delete-frame (frame)
+  (dolist (d talk-display-alist)
+    (when (eq (nth 1 d) frame)
+      (setq talk-display-alist (delq d talk-display-alist))
+      (talk-update-buffers))))
+
 (defun talk-disconnect ()
   "Disconnect this display from the Emacs talk group."
   (interactive)
--- a/lisp/term/rxvt.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/term/rxvt.el	Mon Oct 25 18:17:28 2004 +0000
@@ -26,6 +26,8 @@

 ;;; Code:

+(eval-when-compile (require 'server))
+
 ;; Set up function-key-map entries that termcap and terminfo don't know.
 (let ((map (make-sparse-keymap)))
   (define-key map "\e[A" [up])
@@ -148,7 +150,7 @@
 ;; intelligent way than the default guesswork in startup.el.
 (defun rxvt-set-background-mode ()
   "Set background mode as appropriate for the default rxvt colors."
-  (let ((fgbg (getenv "COLORFGBG"))
+  (let ((fgbg (server-getenv "COLORFGBG"))
 	bg rgb)
     (setq frame-background-mode 'light)	; default
     (when (and fgbg
--- a/lisp/term/x-win.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/term/x-win.el	Mon Oct 25 18:17:28 2004 +0000
@@ -24,10 +24,16 @@

 ;;; Commentary:

-;; X-win.el:  this file is loaded from ../lisp/startup.el when it recognizes
-;; that X windows are to be used.  Command line switches are parsed and those
-;; pertaining to X are processed and removed from the command line.  The
-;; X display is opened and hooks are set for popping up the initial window.
+;; X-win.el: this file defines functions to initialize the X window
+;; system and process X-specific command line parameters before
+;; creating the first X frame.
+
+;; Note that contrary to previous Emacs versions, the act of loading
+;; this file should not have the side effect of initializing the
+;; window system or processing command line arguments (this file is
+;; now loaded in loadup.el).  See the variables
+;; `handle-args-function-alist' and
+;; `window-system-initialization-alist' for more details.

 ;; startup.el will then examine startup files, and eventually call the hooks
 ;; which create the first window(s).
@@ -66,7 +72,7 @@
 ;; An alist of X options and the function which handles them.  See
 ;; ../startup.el.

-(if (not (eq window-system 'x))
+(if (not (fboundp 'x-create-frame))
     (error "%s: Loading x-win.el but not compiled for X" (invocation-name)))

 (require 'frame)
@@ -78,6 +84,8 @@
 (require 'fontset)
 (require 'x-dnd)

+(eval-when-compile (require 'server))
+
 (defvar x-invocation-args)

 (defvar x-command-line-resources nil)
@@ -1160,9 +1168,6 @@

 ;;;; Function keys

-(substitute-key-definition 'suspend-emacs 'iconify-or-deiconify-frame
-			   global-map)
-
 ;; Map certain keypad keys into ASCII characters
 ;; that people usually expect.
 (define-key function-key-map [backspace] [127])
@@ -2238,7 +2243,7 @@
     (if text
 	(remove-text-properties 0 (length text) '(foreign-selection nil) text))
     text))
-
+
 ;;; Return the value of the current X selection.
 ;;; Consult the selection, and the cut buffer.  Treat empty strings
 ;;; as if they were unset.
@@ -2329,134 +2334,6 @@
     (or clip-text primary-text cut-text)
     ))

-
-;;; Do the actual X Windows setup here; the above code just defines
-;;; functions and variables that we use now.
-
-(setq command-line-args (x-handle-args command-line-args))
-
-;;; Make sure we have a valid resource name.
-(or (stringp x-resource-name)
-    (let (i)
-      (setq x-resource-name (invocation-name))
-
-      ;; Change any . or * characters in x-resource-name to hyphens,
-      ;; so as not to choke when we use it in X resource queries.
-      (while (setq i (string-match "[.*]" x-resource-name))
-	(aset x-resource-name i ?-))))
-
-(x-open-connection (or x-display-name
-		       (setq x-display-name (getenv "DISPLAY")))
-		   x-command-line-resources
-		   ;; Exit Emacs with fatal error if this fails.
-		   t)
-
-(setq frame-creation-function 'x-create-frame-with-faces)
-
-(setq x-cut-buffer-max (min (- (/ (x-server-max-request-size) 2) 100)
-			    x-cut-buffer-max))
-
-;; Setup the default fontset.
-(setup-default-fontset)
-
-;; Create the standard fontset.
-(create-fontset-from-fontset-spec standard-fontset-spec t)
-
-;; Create fontset specified in X resources "Fontset-N" (N is 0, 1, ...).
-(create-fontset-from-x-resource)
-
-;; Try to create a fontset from a font specification which comes
-;; from initial-frame-alist, default-frame-alist, or X resource.
-;; A font specification in command line argument (i.e. -fn XXXX)
-;; should be already in default-frame-alist as a `font'
-;; parameter.  However, any font specifications in site-start
-;; library, user's init file (.emacs), and default.el are not
-;; yet handled here.
-
-(let ((font (or (cdr (assq 'font initial-frame-alist))
-		(cdr (assq 'font default-frame-alist))
-		(x-get-resource "font" "Font")))
-      xlfd-fields resolved-name)
-  (if (and font
-	   (not (query-fontset font))
-	   (setq resolved-name (x-resolve-font-name font))
-	   (setq xlfd-fields (x-decompose-font-name font)))
-      (if (string= "fontset" (aref xlfd-fields xlfd-regexp-registry-subnum))
-	  (new-fontset font (x-complement-fontset-spec xlfd-fields nil))
-	;; Create a fontset from FONT.  The fontset name is
-	;; generated from FONT.
-	(create-fontset-from-ascii-font font resolved-name "startup"))))
-
-;; Apply a geometry resource to the initial frame.  Put it at the end
-;; of the alist, so that anything specified on the command line takes
-;; precedence.
-(let* ((res-geometry (x-get-resource "geometry" "Geometry"))
-       parsed)
-  (if res-geometry
-      (progn
-	(setq parsed (x-parse-geometry res-geometry))
-	;; If the resource specifies a position,
-	;; call the position and size "user-specified".
-	(if (or (assq 'top parsed) (assq 'left parsed))
-	    (setq parsed (cons '(user-position . t)
-			       (cons '(user-size . t) parsed))))
-	;; All geometry parms apply to the initial frame.
-	(setq initial-frame-alist (append initial-frame-alist parsed))
-	;; The size parms apply to all frames.
-	(if (assq 'height parsed)
-	    (setq default-frame-alist
-		  (cons (cons 'height (cdr (assq 'height parsed)))
-			default-frame-alist)))
-	(if (assq 'width parsed)
-	    (setq default-frame-alist
-		  (cons (cons 'width (cdr (assq 'width parsed)))
-			default-frame-alist))))))
-
-;; Check the reverseVideo resource.
-(let ((case-fold-search t))
-  (let ((rv (x-get-resource "reverseVideo" "ReverseVideo")))
-    (if (and rv
-	     (string-match "^\\(true\\|yes\\|on\\)$" rv))
-	(setq default-frame-alist
-	      (cons '(reverse . t) default-frame-alist)))))
-
-;; Set x-selection-timeout, measured in milliseconds.
-(let ((res-selection-timeout
-       (x-get-resource "selectionTimeout" "SelectionTimeout")))
-  (setq x-selection-timeout 20000)
-  (if res-selection-timeout
-      (setq x-selection-timeout (string-to-number res-selection-timeout))))
-
-(defun x-win-suspend-error ()
-  (error "Suspending an Emacs running under X makes no sense"))
-(add-hook 'suspend-hook 'x-win-suspend-error)
-
-;;; Arrange for the kill and yank functions to set and check the clipboard.
-(setq interprogram-cut-function 'x-select-text)
-(setq interprogram-paste-function 'x-cut-buffer-or-selection-value)
-
-;;; Turn off window-splitting optimization; X is usually fast enough
-;;; that this is only annoying.
-(setq split-window-keep-point t)
-
-;; Don't show the frame name; that's redundant with X.
-(setq-default mode-line-frame-identification "  ")
-
-;; Motif direct handling of f10 wasn't working right,
-;; So temporarily we've turned it off in lwlib-Xm.c
-;; and turned the Emacs f10 back on.
-;; ;; Motif normally handles f10 itself, so don't try to handle it a second time.
-;; (if (featurep 'motif)
-;;     (global-set-key [f10] 'ignore))
-
-;; Turn on support for mouse wheels.
-(mouse-wheel-mode 1)
-
-
-;; Enable CLIPBOARD copy/paste through menu bar commands.
-(menu-bar-enable-clipboard)
-
-;; Override Paste so it looks at CLIPBOARD first.
 (defun x-clipboard-yank ()
   "Insert the clipboard contents, or the last stretch of killed text."
   (interactive)
@@ -2469,9 +2346,140 @@
 	(kill-new clipboard-text))
     (yank)))

-(define-key menu-bar-edit-menu [paste]
-  (cons "Paste" (cons "Paste text from clipboard or kill ring"
-		      'x-clipboard-yank)))
+
+;;; Window system initialization.
+
+(defun x-win-suspend-error ()
+  (error "Suspending an Emacs running under X makes no sense"))
+
+(defvar x-initialized nil
+  "Non-nil if the X window system has been initialized.")
+
+(defun x-initialize-window-system ()
+  "Initialize Emacs for X frames and open the first connection to an X server."
+  ;; Make sure we have a valid resource name.
+  (or (stringp x-resource-name)
+      (let (i)
+	(setq x-resource-name (invocation-name))
+
+	;; Change any . or * characters in x-resource-name to hyphens,
+	;; so as not to choke when we use it in X resource queries.
+	(while (setq i (string-match "[.*]" x-resource-name))
+	  (aset x-resource-name i ?-))))
+
+  (x-open-connection (or x-display-name
+			 (setq x-display-name (server-getenv "DISPLAY")))
+		     x-command-line-resources
+		     ;; Exit Emacs with fatal error if this fails and we
+		     ;; are the initial display.
+		     (eq initial-window-system 'x))
+
+  (setq x-cut-buffer-max (min (- (/ (x-server-max-request-size) 2) 100)
+			      x-cut-buffer-max))
+
+  ;; Setup the default fontset.
+  (setup-default-fontset)
+
+  ;; Create the standard fontset.
+  (create-fontset-from-fontset-spec standard-fontset-spec t)
+
+  ;; Create fontset specified in X resources "Fontset-N" (N is 0, 1, ...).
+  (create-fontset-from-x-resource)
+
+  ;; Try to create a fontset from a font specification which comes
+  ;; from initial-frame-alist, default-frame-alist, or X resource.
+  ;; A font specification in command line argument (i.e. -fn XXXX)
+  ;; should be already in default-frame-alist as a `font'
+  ;; parameter.  However, any font specifications in site-start
+  ;; library, user's init file (.emacs), and default.el are not
+  ;; yet handled here.
+
+  (let ((font (or (cdr (assq 'font initial-frame-alist))
+		  (cdr (assq 'font default-frame-alist))
+		  (x-get-resource "font" "Font")))
+	xlfd-fields resolved-name)
+    (if (and font
+	     (not (query-fontset font))
+	     (setq resolved-name (x-resolve-font-name font))
+	     (setq xlfd-fields (x-decompose-font-name font)))
+	(if (string= "fontset" (aref xlfd-fields xlfd-regexp-registry-subnum))
+	    (new-fontset font (x-complement-fontset-spec xlfd-fields nil))
+	  ;; Create a fontset from FONT.  The fontset name is
+	  ;; generated from FONT.
+	  (create-fontset-from-ascii-font font resolved-name "startup"))))
+
+  ;; Apply a geometry resource to the initial frame.  Put it at the end
+  ;; of the alist, so that anything specified on the command line takes
+  ;; precedence.
+  (let* ((res-geometry (x-get-resource "geometry" "Geometry"))
+	 parsed)
+    (if res-geometry
+	(progn
+	  (setq parsed (x-parse-geometry res-geometry))
+	  ;; If the resource specifies a position,
+	  ;; call the position and size "user-specified".
+	  (if (or (assq 'top parsed) (assq 'left parsed))
+	      (setq parsed (cons '(user-position . t)
+				 (cons '(user-size . t) parsed))))
+	  ;; All geometry parms apply to the initial frame.
+	  (setq initial-frame-alist (append initial-frame-alist parsed))
+	  ;; The size parms apply to all frames.
+	  (if (assq 'height parsed)
+	      (setq default-frame-alist
+		    (cons (cons 'height (cdr (assq 'height parsed)))
+			  default-frame-alist)))
+	  (if (assq 'width parsed)
+	      (setq default-frame-alist
+		    (cons (cons 'width (cdr (assq 'width parsed)))
+			  default-frame-alist))))))
+
+  ;; Check the reverseVideo resource.
+  (let ((case-fold-search t))
+    (let ((rv (x-get-resource "reverseVideo" "ReverseVideo")))
+      (if (and rv
+	       (string-match "^\\(true\\|yes\\|on\\)$" rv))
+	  (setq default-frame-alist
+		(cons '(reverse . t) default-frame-alist)))))
+
+  ;; Set x-selection-timeout, measured in milliseconds.
+  (let ((res-selection-timeout
+	 (x-get-resource "selectionTimeout" "SelectionTimeout")))
+    (setq x-selection-timeout 20000)
+    (if res-selection-timeout
+	(setq x-selection-timeout (string-to-number res-selection-timeout))))
+
+  ;; Don't let Emacs suspend under X.
+  (add-hook 'suspend-hook 'x-win-suspend-error)
+
+  ;; Turn off window-splitting optimization; X is usually fast enough
+  ;; that this is only annoying.
+  (setq split-window-keep-point t)
+
+  ;; Motif direct handling of f10 wasn't working right,
+  ;; So temporarily we've turned it off in lwlib-Xm.c
+  ;; and turned the Emacs f10 back on.
+  ;; ;; Motif normally handles f10 itself, so don't try to handle it a second time.
+  ;; (if (featurep 'motif)
+  ;;     (global-set-key [f10] 'ignore))
+
+  ;; Turn on support for mouse wheels.
+  (mouse-wheel-mode 1)
+
+  ;; Enable CLIPBOARD copy/paste through menu bar commands.
+  (menu-bar-enable-clipboard)
+
+  ;; Override Paste so it looks at CLIPBOARD first.
+  (define-key menu-bar-edit-menu [paste]
+    (cons "Paste" (cons "Paste text from clipboard or kill ring"
+			'x-clipboard-yank)))
+
+  (setq x-initialized t))
+
+(add-to-list 'handle-args-function-alist '(x . x-handle-args))
+(add-to-list 'frame-creation-function-alist '(x . x-create-frame-with-faces))
+(add-to-list 'window-system-initialization-alist '(x . x-initialize-window-system))
+
+(provide 'x-win)

 ;; Initiate drag and drop
 (add-hook 'after-make-frame-functions 'x-dnd-init-frame)
--- a/lisp/term/xterm.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/term/xterm.el	Mon Oct 25 18:17:28 2004 +0000
@@ -26,6 +26,8 @@

 ;;; Code:

+(eval-when-compile (require 'server))
+
 (let ((map (make-sparse-keymap)))
   (define-key map "\e[A" [up])
   (define-key map "\e[B" [down])
@@ -133,7 +135,7 @@
 `xterm-standard-colors', which see, while the rest are computed assuming
 either the 88- or 256-color standard color scheme supported by latest
 versions of xterm."
-  (let* ((ncolors (display-color-cells))
+  (let* ((ncolors (display-color-cells (selected-frame)))
 	 (colors xterm-standard-colors)
 	 (color (car colors)))
     (if (> ncolors 0)
@@ -218,7 +220,7 @@
 ;; intelligent way than the default guesswork in startup.el.
 (defun xterm-rxvt-set-background-mode ()
   "Set background mode as appropriate for the default rxvt colors."
-  (let ((fgbg (getenv "COLORFGBG"))
+  (let ((fgbg (server-getenv "COLORFGBG"))
 	bg rgb)
     (setq frame-background-mode 'light)	; default
     (when (and fgbg
@@ -240,8 +242,8 @@
 (xterm-register-default-colors)
 ;; If this xterm is actually a disguised rxvt, be more intelligent about
 ;; determining the background mode.
-(and (getenv "COLORTERM")
-     (string-match "\\`rxvt" (getenv "COLORTERM"))
+(and (server-getenv "COLORTERM")
+     (string-match "\\`rxvt" (server-getenv "COLORTERM"))
      (xterm-rxvt-set-background-mode))
 ;; This recomputes all the default faces given the colors we've just set up.
 (tty-set-up-initial-frame-faces)
--- a/lisp/vc-cvs.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/vc-cvs.el	Mon Oct 25 18:17:28 2004 +0000
@@ -5,7 +5,7 @@
 ;; Author:      FSF (see vc.el for full credits)
 ;; Maintainer:  Andre Spiegel <spiegel@gnu.org>

-;; $Id: vc-cvs.el,v 1.67 2004/01/20 17:41:18 uid65624 Exp $
+;; $Id$

 ;; This file is part of GNU Emacs.
--- a/lisp/version.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/version.el	Mon Oct 25 18:17:28 2004 +0000
@@ -55,8 +55,8 @@
   (interactive "P")
   (let ((version-string
          (format (if (not (interactive-p))
-		     "GNU Emacs %s (%s%s%s)\n of %s on %s"
-		   "GNU Emacs %s (%s%s%s) of %s on %s")
+		     "GNU Emacs %s (%s%s%s%s)\n of %s on %s"
+		   "GNU Emacs %s (%s%s%s%s) of %s on %s")
                  emacs-version
 		 system-configuration
 		 (cond ((featurep 'motif)
@@ -70,6 +70,7 @@
 		     (format ", %s scroll bars"
 			     (capitalize (symbol-name x-toolkit-scroll-bars)))
 		   "")
+		 (if (featurep 'multi-tty) ", multi-tty" "")
 		 (format-time-string "%Y-%m-%d" emacs-build-time)
                  emacs-build-system)))
     (if here
--- a/lisp/x-dnd.el	Mon Oct 25 02:03:47 2004 +0000
+++ b/lisp/x-dnd.el	Mon Oct 25 18:17:28 2004 +0000
@@ -145,8 +145,9 @@

 (defun x-dnd-init-frame (&optional frame)
   "Setup drag and drop for FRAME (i.e. create appropriate properties)."
-  (x-dnd-init-xdnd-for-frame frame)
-  (x-dnd-init-motif-for-frame frame))
+  (when (eq 'x (window-system frame))
+    (x-dnd-init-xdnd-for-frame frame)
+    (x-dnd-init-motif-for-frame frame)))

 (defun x-dnd-get-state-cons-for-frame (frame-or-window)
   "Return the entry in x-dnd-current-state for a frame or window."
--- a/lispref/elisp-covers.texi	Mon Oct 25 02:03:47 2004 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,252 +0,0 @@
-\input texinfo    @c -*-texinfo-*-
-@comment %**start of header
-@setfilename covers.info
-@settitle GNU Emacs Lisp Reference Manual
-@comment %**end of header
-
-@titlepage
-@c ================ Volume 1 ================
-@w{ }
-@sp 2
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 1}
-@sp 2
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-@page
-@c ================ Volume 2 ================
-@w{ }
-@sp 5
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 2}
-@sp 2
-@center by Bil Lewis,
-@center Dan LaLiberte, and
-@center the GNU Manual Group
-
-@page
-@c ================ Volume 1 with baseline skip 16pt ================
-
-@tex
-\global\baselineskip = 16pt
-@end tex
-
-16 pts baseline skip:
-
-@w{ }
-@sp 2
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 1}
-@sp 2
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-@page
-@c ================ Volume 1 with baseline skip 18pt ================
-
-@tex
-\global\baselineskip = 18pt
-@end tex
-
-18 pts baseline skip, with 15pts  between sections
-
-@w{ }
-@sp 2
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@tex
-\global\baselineskip = 15pt
-@end tex
-
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 1}
-@sp 2
-@center by Bil Lewis,
-@center Dan LaLiberte, and
-@center the GNU Manual Group
-
-@page
-@c ================ Volume 1 with more baseline skip 24 pts ================
-
-@tex
-\global\baselineskip = 24pt
-@end tex
-
-24 pts baseline skip:
-
-@w{ }
-@sp 2
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 1}
-@sp 2
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-@page
-@c ================ Volume 2 with more baseline skip 18 pts ================
-
-@tex
-\global\baselineskip = 18pt
-@end tex
-
-18 pts baseline skip:
-
-@w{ }
-@sp 5
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 2}
-@sp 2
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-@page
-@c ================ Volume 2 with more baseline skip 24 pts ================
-
-@tex
-\global\baselineskip = 24pt
-@end tex
-
-24 pts baseline skip:
-
-@w{ }
-@sp 5
-@center @titlefont{The}
-@sp 1
-@center @titlefont{GNU}
-@sp 1
-@center @titlefont{Emacs Lisp}
-@sp 1
-@center @titlefont{Reference}
-@sp 1
-@center @titlefont{Manual}
-@sp 2
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 2
-@center @titlefont{Volume 2}
-@sp 2
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-
-@page
-@c ================  Spine 1 ================
-
-@w{@titlefont{The GNU Emacs Lisp Reference Manual --- Vol. 1}}
-@sp 4
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 4
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-@sp 4
-@author The GNU Emacs Lisp Reference Manual --- Vol. 1
-@sp 3
-@author FSF
-
-@author
-
-@page
-@c ================  Spine 2 ================
-
-@w{@titlefont{The GNU Emacs Lisp Reference Manual --- Vol. 2}}
-@sp 4
-@center GNU Emacs Version 19
-@center for Unix Users
-@center Edition 2.3, June 1994
-@sp 4
-@center by Bil Lewis, Dan LaLiberte,
-@center and the GNU Manual Group
-
-
-@sp 4
-@author The GNU Emacs Lisp Reference Manual --- Vol. 2
-@sp 3
-@author FSF
-
-@end titlepage
-@bye
-
-@ignore
-   arch-tag: 02d65d63-3b64-49bc-a5c0-bfd5eabb6c98
-@end ignore
--- a/mac/makefile.MPW	Mon Oct 25 02:03:47 2004 +0000
+++ b/mac/makefile.MPW	Mon Oct 25 18:17:28 2004 +0000
@@ -1017,6 +1017,7 @@
 	{Lisp}international:codepage.elc �
 	{Lisp}abbrev.elc �
 	{Lisp}buff-menu.elc �
+	{Lisp}server.elc �
 	{Lisp}byte-run.elc �
 	{Lisp}cus-start.el �
 	{Lisp}custom.elc �
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/nt/.arch-inventory	Mon Oct 25 18:17:28 2004 +0000
@@ -0,0 +1,3 @@
+source ^subdirs\.el$
+
+# arch-tag: 01b87183-9d94-4b6b-93cb-fece25c4eec9
--- a/src/.arch-inventory	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/.arch-inventory	Mon Oct 25 18:17:28 2004 +0000
@@ -2,7 +2,7 @@
 source ^\.(gdbinit|dbxinit)$

 # Auto-generated files, which ignore
-precious ^(config\.stamp|config\.h|epaths\.h)$
+precious ^(config\.stamp|config\.h|epaths\.h|TAGS-LISP)$

 backup ^(stamp-oldxmenu|prefix-args|temacs|emacs|emacs-[0-9.]*)$
--- a/src/.gdbinit	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/.gdbinit	Mon Oct 25 18:17:28 2004 +0000
@@ -463,7 +463,7 @@

 show environment DISPLAY
 show environment TERM
-set args -geometry 80x40+0+0
+#set args -geometry 80x40+0+0

 # Don't let abort actually run, as it will make
 # stdio stop working and therefore the `pr' command above as well.
--- a/src/Makefile.in	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/Makefile.in	Mon Oct 25 18:17:28 2004 +0000
@@ -699,6 +699,7 @@
 lisp= \
 	${lispsource}abbrev.elc \
 	${lispsource}buff-menu.elc \
+	${lispsource}server.elc \
 	${lispsource}button.elc \
 	${lispsource}emacs-lisp/byte-run.elc \
 	${lispsource}cus-face.elc \
@@ -791,6 +792,7 @@
 shortlisp= \
 	../lisp/abbrev.elc \
 	../lisp/buff-menu.elc \
+	../lisp/server.elc \
 	../lisp/button.elc \
 	../lisp/emacs-lisp/byte-run.elc \
 	../lisp/cus-face.elc \
@@ -884,7 +886,9 @@
   ${dotdot}/lisp/w32-fns.elc ${dotdot}/lisp/dos-w32.elc \
   ${dotdot}/lisp/disp-table.elc ${dotdot}/lisp/dos-vars.elc \
   ${dotdot}/lisp/international/ccl.elc \
-  ${dotdot}/lisp/international/codepage.elc
+  ${dotdot}/lisp/international/codepage.elc \
+  ${dotdot}/lisp/mouse.elc ${dotdot}/lisp/international/fontset.elc \
+  ${dotdot}/lisp/x-dnd.elc ${dotdot}/lisp/term/x-win.elc

 /* Construct full set of libraries to be linked.
    Note that SunOS needs -lm to come before -lc; otherwise, you get
@@ -930,7 +934,7 @@
    for the first time, this prevents any variation between configurations
    in the contents of the DOC file.
    Likewise for ${SOME_MACHINE_LISP}.  */
-${etc}DOC: ${libsrc}make-docfile${EXEEXT} ${obj} ${shortlisp} ${SOME_MACHINE_LISP}
+${etc}DOC: ${libsrc}make-docfile ${obj} ${shortlisp} ${SOME_MACHINE_LISP}
 	-rm -f ${etc}DOC
 	${libsrc}make-docfile -d ${srcdir} ${SOME_MACHINE_OBJECTS} ${obj} > ${etc}DOC
 	${libsrc}make-docfile -a ${etc}DOC -d ${srcdir} ${SOME_MACHINE_LISP} ${shortlisp}
@@ -1052,7 +1056,7 @@
    keyboard.h dispextern.h $(config_h)
 callproc.o: callproc.c epaths.h buffer.h commands.h $(config_h) \
 	process.h systty.h syssignal.h charset.h coding.h ccl.h msdos.h \
-        composite.h w32.h
+        composite.h
 casefiddle.o: casefiddle.c syntax.h commands.h buffer.h composite.h \
 	charset.h keymap.h $(config_h)
 casetab.o: casetab.c buffer.h $(config_h)
@@ -1061,8 +1065,8 @@
 charset.o: charset.c charset.h buffer.h coding.h composite.h disptab.h \
 	$(config_h)
 coding.o: coding.c coding.h ccl.h buffer.h charset.h intervals.h composite.h \
-	window.h dispextern.h $(config_h)
-cm.o: cm.c cm.h termhooks.h $(config_h)
+	window.h dispextern.h frame.h termhooks.h $(config_h)
+cm.o: cm.c frame.h cm.h termhooks.h termchar.h $(config_h)
 cmds.o: cmds.c syntax.h buffer.h charset.h commands.h window.h $(config_h) \
 	msdos.h dispextern.h keyboard.h keymap.h
 pre-crt0.o: pre-crt0.c
@@ -1070,7 +1074,7 @@
 	CRT0_COMPILE ${srcdir}/ecrt0.c
 dired.o: dired.c commands.h buffer.h $(config_h) charset.h coding.h regex.h \
    systime.h
-dispnew.o: dispnew.c  systty.h systime.h commands.h process.h frame.h \
+dispnew.o: dispnew.c systime.h commands.h process.h frame.h \
    window.h buffer.h dispextern.h termchar.h termopts.h termhooks.h cm.h \
    disptab.h indent.h intervals.h \
    xterm.h blockinput.h atimer.h charset.h msdos.h composite.h keyboard.h \
@@ -1085,15 +1089,15 @@
    termhooks.h buffer.h atimer.h systime.h $(INTERVAL_SRC) $(config_h) \
    window.h dispextern.h keyboard.h keymap.h
 fileio.o: fileio.c window.h buffer.h systime.h $(INTERVAL_SRC) charset.h \
-   coding.h msdos.h dispextern.h $(config_h)
+   coding.h ccl.h msdos.h dispextern.h $(config_h)
 filelock.o: filelock.c buffer.h charset.h coding.h systime.h epaths.h $(config_h)
 filemode.o: filemode.c  $(config_h)
 frame.o: frame.c xterm.h window.h frame.h termhooks.h commands.h keyboard.h \
    blockinput.h atimer.h systime.h buffer.h charset.h fontset.h \
-   msdos.h dosfns.h dispextern.h w32term.h macterm.h $(config_h)
-fringe.o: fringe.c dispextern.h frame.h window.h buffer.h $(config_h)
+   msdos.h dosfns.h dispextern.h w32term.h macterm.h termchar.h $(config_h)
+fringe.o: fringe.c dispextern.h frame.h window.h buffer.h termhooks.h $(config_h)
 fontset.o: dispextern.h fontset.h fontset.c ccl.h buffer.h charset.h frame.h \
-   keyboard.h $(config_h)
+   keyboard.h termhooks.h $(config_h)
 getloadavg.o: getloadavg.c $(config_h)
 image.o: image.c frame.h window.h dispextern.h blockinput.h atimer.h \
    systime.h xterm.h w32term.h w32gui.h macterm.h macgui.h $(config_h)
@@ -1104,7 +1108,7 @@
    dispextern.h atimer.h systime.h region-cache.h $(config_h)
 keyboard.o: keyboard.c termchar.h termhooks.h termopts.h buffer.h charset.h \
    commands.h frame.h window.h macros.h disptab.h keyboard.h syssignal.h \
-   systty.h systime.h dispextern.h syntax.h $(INTERVAL_SRC) blockinput.h \
+   systime.h dispextern.h syntax.h $(INTERVAL_SRC) blockinput.h \
    atimer.h xterm.h puresize.h msdos.h keymap.h w32term.h macterm.h $(config_h)
 keymap.o: keymap.c buffer.h commands.h keyboard.h termhooks.h blockinput.h \
    atimer.h systime.h puresize.h charset.h intervals.h $(config_h)
@@ -1118,7 +1122,8 @@
 marker.o: marker.c buffer.h charset.h $(config_h)
 md5.o: md5.c md5.h $(config_h)
 minibuf.o: minibuf.c syntax.h dispextern.h frame.h window.h keyboard.h \
-   buffer.h commands.h charset.h msdos.h $(INTERVAL_SRC) keymap.h $(config_h)
+   buffer.h commands.h charset.h msdos.h $(INTERVAL_SRC) keymap.h \
+   termhooks.h $(config_h)
 mktime.o: mktime.c $(config_h)
 msdos.o: msdos.c msdos.h dosfns.h systime.h termhooks.h dispextern.h frame.h \
    termopts.h termchar.h charset.h coding.h ccl.h disptab.h window.h \
@@ -1130,7 +1135,7 @@
 regex.o: regex.c syntax.h buffer.h $(config_h) regex.h category.h charset.h
 region-cache.o: region-cache.c buffer.h region-cache.h $(config_h)
 scroll.o: scroll.c termchar.h dispextern.h frame.h msdos.h keyboard.h \
-   $(config_h)
+   termhooks.h $(config_h)
 search.o: search.c regex.h commands.h buffer.h region-cache.h syntax.h \
    blockinput.h atimer.h systime.h category.h charset.h composite.h \
    $(INTERVAL_SRC) $(config_h)
@@ -1139,7 +1144,7 @@
    composite.h keymap.h regex.h $(INTERVAL_SRC) $(config_h)
 sysdep.o: sysdep.c syssignal.h systty.h systime.h syswait.h blockinput.h \
    process.h dispextern.h termhooks.h termchar.h termopts.h \
-   frame.h atimer.h window.h msdos.h dosfns.h keyboard.h  $(config_h)
+   frame.h atimer.h window.h msdos.h dosfns.h keyboard.h cm.h $(config_h)
 term.o: term.c termchar.h termhooks.h termopts.h $(config_h) cm.h frame.h \
    disptab.h dispextern.h keyboard.h charset.h coding.h ccl.h msdos.h \
    window.h keymap.h
@@ -1156,7 +1161,7 @@
 widget.o: widget.c xterm.h frame.h dispextern.h widgetprv.h \
    $(srcdir)/../lwlib/lwlib.h $(config_h)
 window.o: window.c indent.h commands.h frame.h window.h buffer.h termchar.h \
-   termhooks.h disptab.h keyboard.h dispextern.h msdos.h composite.h \
+   disptab.h keyboard.h dispextern.h msdos.h composite.h \
    keymap.h blockinput.h $(INTERVAL_SRC) xterm.h w32term.h macterm.h $(config_h)
 xdisp.o: xdisp.c macros.h commands.h process.h indent.h buffer.h dispextern.h coding.h \
    termchar.h frame.h window.h disptab.h termhooks.h charset.h $(config_h) \
@@ -1164,10 +1169,11 @@
    msdos.h composite.h fontset.h blockinput.h atimer.h systime.h keymap.h
 xfaces.o: xfaces.c dispextern.h frame.h xterm.h buffer.h blockinput.h \
    window.h charset.h msdos.h dosfns.h composite.h atimer.h systime.h \
-   keyboard.h fontset.h w32term.h macterm.h $(INTERVAL_SRC) $(config_h)
+   keyboard.h fontset.h w32term.h macterm.h $(INTERVAL_SRC) termchar.h \
+   termhooks.h $(config_h)
 xfns.o: xfns.c buffer.h frame.h window.h keyboard.h xterm.h dispextern.h \
    $(srcdir)/../lwlib/lwlib.h blockinput.h atimer.h systime.h epaths.h \
-   charset.h gtkutil.h $(config_h)
+   charset.h gtkutil.h termchar.h termhooks.h $(config_h)
 xmenu.o: xmenu.c xterm.h termhooks.h window.h dispextern.h frame.h buffer.h \
    keyboard.h $(srcdir)/../lwlib/lwlib.h blockinput.h atimer.h systime.h \
    gtkutil.h msdos.h coding.h $(config_h)
@@ -1176,7 +1182,7 @@
   keyboard.h gnu.h charset.h ccl.h fontset.h composite.h \
   coding.h process.h gtkutil.h $(config_h)
 xselect.o: xselect.c process.h dispextern.h frame.h xterm.h blockinput.h \
-  buffer.h atimer.h systime.h $(config_h)
+  buffer.h atimer.h systime.h termhooks.h $(config_h)
 xrdb.o: xrdb.c $(config_h) epaths.h
 xsmfns.o: xsmfns.c $(config_h) systime.h sysselect.h termhooks.h xterm.h \
   lisp.h termopts.h
@@ -1201,7 +1207,8 @@
  keymap.h frame.h window.h dispextern.h $(INTERVAL_SRC) coding.h md5.h \
  blockinput.h xterm.h
 print.o: print.c process.h frame.h window.h buffer.h keyboard.h charset.h \
-   $(config_h) dispextern.h termchar.h $(INTERVAL_SRC) msdos.h composite.h
+   $(config_h) dispextern.h termchar.h $(INTERVAL_SRC) msdos.h composite.h \
+   termchar.h
 lread.o: lread.c commands.h keyboard.h buffer.h epaths.h charset.h \
  $(config_h) $(INTERVAL_SRC) termhooks.h coding.h msdos.h

@@ -1216,7 +1223,7 @@
    OTHER_FILES and OBJECTS_MACHINE
    select which of these should be compiled.  */

-sunfns.o: sunfns.c buffer.h window.h dispextern.h $(config_h)
+sunfns.o: sunfns.c buffer.h window.h dispextern.h termhooks.h $(config_h)

 #ifdef HAVE_CARBON
 abbrev.o buffer.o callint.o cmds.o dispnew.o editfns.o fileio.o frame.o \
--- a/src/alloc.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/alloc.c	Mon Oct 25 18:17:28 2004 +0000
@@ -260,6 +260,7 @@

 static void mark_buffer P_ ((Lisp_Object));
 extern void mark_kboards P_ ((void));
+extern void mark_ttys P_ ((void));
 extern void mark_backtrace P_ ((void));
 static void gc_sweep P_ ((void));
 static void mark_glyph_matrix P_ ((struct glyph_matrix *));
@@ -4463,6 +4464,7 @@
       mark_object (bind->old_value);
     }
   mark_kboards ();
+  mark_ttys ();

 #ifdef USE_GTK
   {
--- a/src/cm.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/cm.c	Mon Oct 25 18:17:28 2004 +0000
@@ -22,8 +22,13 @@

 #include <config.h>
 #include <stdio.h>
+
+#include "lisp.h"
+#include "frame.h"
 #include "cm.h"
 #include "termhooks.h"
+#include "termchar.h"
+

 /* For now, don't try to include termcap.h.  On some systems,
    configure finds a non-standard termcap.h that the main build
@@ -52,13 +57,16 @@
   return c;
 }

+/* The terminal to use for low-level output. */
+struct tty_display_info *current_tty;
+
 int
 cmputc (c)
      char c;
 {
-  if (termscript)
-    fputc (c & 0177, termscript);
-  putchar (c & 0177);
+  if (current_tty->termscript)
+    putc (c & 0177, current_tty->termscript);
+  putc (c & 0177, current_tty->output);
   return c;
 }

@@ -71,9 +79,9 @@
  */

 static
-at (row, col) {
-    curY = row;
-    curX = col;
+at (tty, row, col) {
+  curY (tty) = row;
+  curX (tty)  = col;
 }

 /*
@@ -81,8 +89,8 @@
  */

 static
-addcol (n) {
-    curX += n;
+addcol (tty, n) {
+  curX (tty) += n;

     /*
      * If cursor hit edge of screen, what happened?
@@ -92,21 +100,21 @@
      * of the last line.
      */

-    if (curX == Wcm.cm_cols) {
+  if (curX (tty) == tty->Wcm->cm_cols) {
 	/*
 	 * Well, if magicwrap, still there, past the edge of the
 	 * screen (!).  If autowrap, on the col 0 of the next line.
 	 * Otherwise on last column.
 	 */

-	if (Wcm.cm_magicwrap)
+	if (tty->Wcm->cm_magicwrap)
 	    ;			/* "limbo" */
-	else if (Wcm.cm_autowrap) {
-	    curX = 0;
-	    curY++;		/* Beware end of screen! */
+	else if (tty->Wcm->cm_autowrap) {
+          curX (tty) = 0;
+          curY (tty) ++;		/* Beware end of screen! */
 	}
 	else
-	    curX--;
+          curX (tty)--;
     }
 }
 #endif
@@ -122,20 +130,20 @@
  * after we reach the last column; this takes us to a known state.
  */
 void
-cmcheckmagic ()
+cmcheckmagic (struct tty_display_info *tty)
 {
-  if (curX == FrameCols)
+  if (curX (tty) == FrameCols (tty))
     {
-      if (!MagicWrap || curY >= FrameRows - 1)
+      if (!MagicWrap (tty) || curY (tty) >= FrameRows (tty) - 1)
 	abort ();
-      if (termscript)
-	putc ('\r', termscript);
-      putchar ('\r');
-      if (termscript)
-	putc ('\n', termscript);
-      putchar ('\n');
-      curX = 0;
-      curY++;
+      if (tty->termscript)
+	putc ('\r', tty->termscript);
+      putc ('\r', tty->output);
+      if (tty->termscript)
+	putc ('\n', tty->termscript);
+      putc ('\n', tty->output);
+      curX (tty) = 0;
+      curY (tty)++;
     }
 }

@@ -147,21 +155,21 @@
  */

 void
-cmcostinit ()
+cmcostinit (struct tty_display_info *tty)
 {
     char *p;

 #define	COST(x,e)	(x ? (cost = 0, tputs (x, 1, e), cost) : BIG)
 #define CMCOST(x,e)	((x == 0) ? BIG : (p = tgoto(x, 0, 0), COST(p ,e)))

-    Wcm.cc_up =		COST (Wcm.cm_up, evalcost);
-    Wcm.cc_down =	COST (Wcm.cm_down, evalcost);
-    Wcm.cc_left =	COST (Wcm.cm_left, evalcost);
-    Wcm.cc_right =	COST (Wcm.cm_right, evalcost);
-    Wcm.cc_home =	COST (Wcm.cm_home, evalcost);
-    Wcm.cc_cr =		COST (Wcm.cm_cr, evalcost);
-    Wcm.cc_ll =		COST (Wcm.cm_ll, evalcost);
-    Wcm.cc_tab =	Wcm.cm_tabwidth ? COST (Wcm.cm_tab, evalcost) : BIG;
+    tty->Wcm->cc_up =	 COST (tty->Wcm->cm_up, evalcost);
+    tty->Wcm->cc_down =	 COST (tty->Wcm->cm_down, evalcost);
+    tty->Wcm->cc_left =	 COST (tty->Wcm->cm_left, evalcost);
+    tty->Wcm->cc_right = COST (tty->Wcm->cm_right, evalcost);
+    tty->Wcm->cc_home =	 COST (tty->Wcm->cm_home, evalcost);
+    tty->Wcm->cc_cr =	 COST (tty->Wcm->cm_cr, evalcost);
+    tty->Wcm->cc_ll =	 COST (tty->Wcm->cm_ll, evalcost);
+    tty->Wcm->cc_tab =	 tty->Wcm->cm_tabwidth ? COST (tty->Wcm->cm_tab, evalcost) : BIG;

     /*
      * These last three are actually minimum costs.  When (if) they are
@@ -172,9 +180,9 @@
      * cursor motion seem to take straight numeric values.  --ACT)
      */

-    Wcm.cc_abs =  CMCOST (Wcm.cm_abs, evalcost);
-    Wcm.cc_habs = CMCOST (Wcm.cm_habs, evalcost);
-    Wcm.cc_vabs = CMCOST (Wcm.cm_vabs, evalcost);
+    tty->Wcm->cc_abs =  CMCOST (tty->Wcm->cm_abs, evalcost);
+    tty->Wcm->cc_habs = CMCOST (tty->Wcm->cm_habs, evalcost);
+    tty->Wcm->cc_vabs = CMCOST (tty->Wcm->cm_vabs, evalcost);

 #undef CMCOST
 #undef COST
@@ -187,8 +195,8 @@
  */

 static int
-calccost (srcy, srcx, dsty, dstx, doit)
-     int srcy, srcx, dsty, dstx, doit;
+calccost (struct tty_display_info *tty,
+          int srcy, int srcx, int dsty, int dstx, int doit)
 {
     register int    deltay,
                     deltax,
@@ -205,16 +213,16 @@
        don't believe the cursor position: give up here
        and force use of absolute positioning.  */

-    if (curX == Wcm.cm_cols)
+    if (curX (tty) == tty->Wcm->cm_cols)
       goto fail;

     totalcost = 0;
     if ((deltay = dsty - srcy) == 0)
 	goto x;
     if (deltay < 0)
-	p = Wcm.cm_up, c = Wcm.cc_up, deltay = -deltay;
+	p = tty->Wcm->cm_up, c = tty->Wcm->cc_up, deltay = -deltay;
     else
-	p = Wcm.cm_down, c = Wcm.cc_down;
+	p = tty->Wcm->cm_down, c = tty->Wcm->cc_down;
     if (c == BIG) {		/* caint get thar from here */
 	if (doit)
 	    printf ("OOPS");
@@ -223,16 +231,16 @@
     totalcost = c * deltay;
     if (doit)
 	while (--deltay >= 0)
-	    tputs (p, 1, cmputc);
+          emacs_tputs (tty, p, 1, cmputc);
 x:
     if ((deltax = dstx - srcx) == 0)
 	goto done;
     if (deltax < 0) {
-	p = Wcm.cm_left, c = Wcm.cc_left, deltax = -deltax;
+	p = tty->Wcm->cm_left, c = tty->Wcm->cc_left, deltax = -deltax;
 	goto dodelta;		/* skip all the tab junk */
     }
     /* Tabs (the toughie) */
-    if (Wcm.cc_tab >= BIG || !Wcm.cm_usetabs)
+    if (tty->Wcm->cc_tab >= BIG || !tty->Wcm->cm_usetabs)
 	goto olddelta;		/* forget it! */

     /*
@@ -243,12 +251,12 @@
      * we will put into tabx (for ntabs) and tab2x (for n2tabs)).
      */

-    ntabs = (deltax + srcx % Wcm.cm_tabwidth) / Wcm.cm_tabwidth;
+    ntabs = (deltax + srcx % tty->Wcm->cm_tabwidth) / tty->Wcm->cm_tabwidth;
     n2tabs = ntabs + 1;
-    tabx = (srcx / Wcm.cm_tabwidth + ntabs) * Wcm.cm_tabwidth;
-    tab2x = tabx + Wcm.cm_tabwidth;
+    tabx = (srcx / tty->Wcm->cm_tabwidth + ntabs) * tty->Wcm->cm_tabwidth;
+    tab2x = tabx + tty->Wcm->cm_tabwidth;

-    if (tab2x >= Wcm.cm_cols)	/* too far (past edge) */
+    if (tab2x >= tty->Wcm->cm_cols)	/* too far (past edge) */
 	n2tabs = 0;

     /*
@@ -256,12 +264,12 @@
      * for using n2tabs, then pick the minimum.
      */

-		   /* cost for ntabs     +    cost for right motion */
-    tabcost = ntabs ? ntabs * Wcm.cc_tab + (dstx - tabx) * Wcm.cc_right
+		   /* cost for ntabs           +    cost for right motion */
+    tabcost = ntabs ? ntabs * tty->Wcm->cc_tab + (dstx - tabx) * tty->Wcm->cc_right
 		    : BIG;

-		   /* cost for n2tabs    +    cost for left motion */
-    c = n2tabs  ?    n2tabs * Wcm.cc_tab + (tab2x - dstx) * Wcm.cc_left
+		   /* cost for n2tabs          +    cost for left motion */
+    c = n2tabs  ?    n2tabs * tty->Wcm->cc_tab + (tab2x - dstx) * tty->Wcm->cc_left
 		: BIG;

     if (c < tabcost)		/* then cheaper to overshoot & back up */
@@ -274,11 +282,11 @@
      * See if tabcost is less than just moving right
      */

-    if (tabcost < (deltax * Wcm.cc_right)) {
+    if (tabcost < (deltax * tty->Wcm->cc_right)) {
 	totalcost += tabcost;	/* use the tabs */
 	if (doit)
 	    while (--ntabs >= 0)
-		tputs (Wcm.cm_tab, 1, cmputc);
+              emacs_tputs (tty, tty->Wcm->cm_tab, 1, cmputc);
 	srcx = tabx;
     }

@@ -291,9 +299,9 @@
 	goto done;
 olddelta:
     if (deltax > 0)
-	p = Wcm.cm_right, c = Wcm.cc_right;
+	p = tty->Wcm->cm_right, c = tty->Wcm->cc_right;
     else
-	p = Wcm.cm_left, c = Wcm.cc_left, deltax = -deltax;
+	p = tty->Wcm->cm_left, c = tty->Wcm->cc_left, deltax = -deltax;

 dodelta:
     if (c == BIG) {		/* caint get thar from here */
@@ -305,7 +313,7 @@
     totalcost += c * deltax;
     if (doit)
 	while (--deltax >= 0)
-	    tputs (p, 1, cmputc);
+          emacs_tputs (tty, p, 1, cmputc);
 done:
     return totalcost;
 }
@@ -323,7 +331,8 @@
 #define	USECR	3

 void
-cmgoto (row, col)
+cmgoto (tty, row, col)
+     struct tty_display_info *tty;
      int row, col;
 {
     int     homecost,
@@ -336,47 +345,47 @@
            *dcm;

   /* First the degenerate case */
-  if (row == curY && col == curX) /* already there */
+    if (row == curY (tty) && col == curX (tty)) /* already there */
     return;

-  if (curY >= 0 && curX >= 0)
+    if (curY (tty) >= 0 && curX (tty) >= 0)
     {
       /* We may have quick ways to go to the upper-left, bottom-left,
        * start-of-line, or start-of-next-line.  Or it might be best to
        * start where we are.  Examine the options, and pick the cheapest.
        */

-      relcost = calccost (curY, curX, row, col, 0);
+      relcost = calccost (tty, curY (tty), curX (tty), row, col, 0);
       use = USEREL;
-      if ((homecost = Wcm.cc_home) < BIG)
-	  homecost += calccost (0, 0, row, col, 0);
+      if ((homecost = tty->Wcm->cc_home) < BIG)
+          homecost += calccost (tty, 0, 0, row, col, 0);
       if (homecost < relcost)
-	  relcost = homecost, use = USEHOME;
-      if ((llcost = Wcm.cc_ll) < BIG)
-	  llcost += calccost (Wcm.cm_rows - 1, 0, row, col, 0);
+          relcost = homecost, use = USEHOME;
+      if ((llcost = tty->Wcm->cc_ll) < BIG)
+          llcost += calccost (tty, tty->Wcm->cm_rows - 1, 0, row, col, 0);
       if (llcost < relcost)
-	  relcost = llcost, use = USELL;
-      if ((crcost = Wcm.cc_cr) < BIG) {
-	  if (Wcm.cm_autolf)
-	      if (curY + 1 >= Wcm.cm_rows)
-		  crcost = BIG;
+          relcost = llcost, use = USELL;
+      if ((crcost = tty->Wcm->cc_cr) < BIG) {
+	  if (tty->Wcm->cm_autolf)
+            if (curY (tty) + 1 >= tty->Wcm->cm_rows)
+                crcost = BIG;
 	      else
-		  crcost += calccost (curY + 1, 0, row, col, 0);
+                crcost += calccost (tty, curY (tty) + 1, 0, row, col, 0);
 	  else
-	      crcost += calccost (curY, 0, row, col, 0);
+            crcost += calccost (tty, curY (tty), 0, row, col, 0);
       }
       if (crcost < relcost)
 	  relcost = crcost, use = USECR;
-      directcost = Wcm.cc_abs, dcm = Wcm.cm_abs;
-      if (row == curY && Wcm.cc_habs < BIG)
-	  directcost = Wcm.cc_habs, dcm = Wcm.cm_habs;
-      else if (col == curX && Wcm.cc_vabs < BIG)
-	  directcost = Wcm.cc_vabs, dcm = Wcm.cm_vabs;
+      directcost = tty->Wcm->cc_abs, dcm = tty->Wcm->cm_abs;
+      if (row == curY (tty) && tty->Wcm->cc_habs < BIG)
+	  directcost = tty->Wcm->cc_habs, dcm = tty->Wcm->cm_habs;
+      else if (col == curX (tty) && tty->Wcm->cc_vabs < BIG)
+	  directcost = tty->Wcm->cc_vabs, dcm = tty->Wcm->cm_vabs;
     }
   else
     {
       directcost = 0, relcost = 100000;
-      dcm = Wcm.cm_abs;
+      dcm = tty->Wcm->cm_abs;
     }

   /*
@@ -387,13 +396,14 @@
     {
       /* compute REAL direct cost */
       cost = 0;
-      p = dcm == Wcm.cm_habs ? tgoto (dcm, row, col) :
-			       tgoto (dcm, col, row);
-      tputs (p, 1, evalcost);
+      p = (dcm == tty->Wcm->cm_habs
+           ? tgoto (dcm, row, col)
+           : tgoto (dcm, col, row));
+      emacs_tputs (tty, p, 1, evalcost);
       if (cost <= relcost)
 	{	/* really is cheaper */
-	  tputs (p, 1, cmputc);
-	  curY = row, curX = col;
+	  emacs_tputs (tty, p, 1, cmputc);
+	  curY (tty) = row, curX (tty) = col;
 	  return;
 	}
     }
@@ -401,25 +411,25 @@
   switch (use)
     {
     case USEHOME:
-      tputs (Wcm.cm_home, 1, cmputc);
-      curY = 0, curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_home, 1, cmputc);
+      curY (tty) = 0, curX (tty) = 0;
       break;

     case USELL:
-      tputs (Wcm.cm_ll, 1, cmputc);
-      curY = Wcm.cm_rows - 1, curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_ll, 1, cmputc);
+      curY (tty) = tty->Wcm->cm_rows - 1, curX (tty) = 0;
       break;

     case USECR:
-      tputs (Wcm.cm_cr, 1, cmputc);
-      if (Wcm.cm_autolf)
-	curY++;
-      curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_cr, 1, cmputc);
+      if (tty->Wcm->cm_autolf)
+	curY (tty)++;
+      curX (tty) = 0;
       break;
     }

-  (void) calccost (curY, curX, row, col, 1);
-  curY = row, curX = col;
+  (void) calccost (tty, curY (tty), curX (tty), row, col, 1);
+  curY (tty) = row, curX (tty) = col;
 }

 /* Clear out all terminal info.
@@ -427,9 +437,9 @@
  */

 void
-Wcm_clear ()
+Wcm_clear (struct tty_display_info *tty)
 {
-  bzero (&Wcm, sizeof Wcm);
+  bzero (tty->Wcm, sizeof (struct cm));
   UP = 0;
   BC = 0;
 }
@@ -442,21 +452,21 @@
  */

 int
-Wcm_init ()
+Wcm_init (struct tty_display_info *tty)
 {
 #if 0
-  if (Wcm.cm_abs && !Wcm.cm_ds)
+  if (tty->Wcm->cm_abs && !tty->Wcm->cm_ds)
     return 0;
 #endif
-  if (Wcm.cm_abs)
+  if (tty->Wcm->cm_abs)
     return 0;
   /* Require up and left, and, if no absolute, down and right */
-  if (!Wcm.cm_up || !Wcm.cm_left)
+  if (!tty->Wcm->cm_up || !tty->Wcm->cm_left)
     return - 1;
-  if (!Wcm.cm_abs && (!Wcm.cm_down || !Wcm.cm_right))
+  if (!tty->Wcm->cm_abs && (!tty->Wcm->cm_down || !tty->Wcm->cm_right))
     return - 1;
   /* Check that we know the size of the screen.... */
-  if (Wcm.cm_rows <= 0 || Wcm.cm_cols <= 0)
+  if (tty->Wcm->cm_rows <= 0 || tty->Wcm->cm_cols <= 0)
     return - 2;
   return 0;
 }
--- a/src/cm.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/cm.h	Mon Oct 25 18:17:28 2004 +0000
@@ -98,76 +98,78 @@
     int cc_vabs;
   };

-extern struct cm Wcm;		/* Terminal capabilities */
 extern char PC;			/* Pad character */

 /* Shorthand */
 #ifndef NoCMShortHand
-#define curY		Wcm.cm_curY
-#define curX		Wcm.cm_curX
-#define Up		Wcm.cm_up
-#define Down		Wcm.cm_down
-#define Left		Wcm.cm_left
-#define Right		Wcm.cm_right
-#define Tab		Wcm.cm_tab
-#define BackTab		Wcm.cm_backtab
-#define TabWidth	Wcm.cm_tabwidth
-#define CR		Wcm.cm_cr
-#define Home		Wcm.cm_home
-#define LastLine	Wcm.cm_ll
-#define AbsPosition	Wcm.cm_abs
-#define ColPosition	Wcm.cm_habs
-#define RowPosition	Wcm.cm_vabs
-#define MultiUp		Wcm.cm_multiup
-#define MultiDown	Wcm.cm_multidown
-#define MultiLeft	Wcm.cm_multileft
-#define MultiRight	Wcm.cm_multiright
-#define AutoWrap	Wcm.cm_autowrap
-#define MagicWrap	Wcm.cm_magicwrap
-#define UseTabs		Wcm.cm_usetabs
-#define FrameRows	Wcm.cm_rows
-#define FrameCols	Wcm.cm_cols
+#define curY(tty)		(tty)->Wcm->cm_curY
+#define curX(tty)		(tty)->Wcm->cm_curX
+#define Up(tty)			(tty)->Wcm->cm_up
+#define Down(tty)		(tty)->Wcm->cm_down
+#define Left(tty)		(tty)->Wcm->cm_left
+#define Right(tty)		(tty)->Wcm->cm_right
+#define Tab(tty)		(tty)->Wcm->cm_tab
+#define BackTab(tty)		(tty)->Wcm->cm_backtab
+#define TabWidth(tty)		(tty)->Wcm->cm_tabwidth
+#define CR(tty)			(tty)->Wcm->cm_cr
+#define Home(tty)		(tty)->Wcm->cm_home
+#define LastLine(tty)		(tty)->Wcm->cm_ll
+#define AbsPosition(tty)	(tty)->Wcm->cm_abs
+#define ColPosition(tty)	(tty)->Wcm->cm_habs
+#define RowPosition(tty)	(tty)->Wcm->cm_vabs
+#define MultiUp(tty)		(tty)->Wcm->cm_multiup
+#define MultiDown(tty)		(tty)->Wcm->cm_multidown
+#define MultiLeft(tty)		(tty)->Wcm->cm_multileft
+#define MultiRight(tty)		(tty)->Wcm->cm_multiright
+#define AutoWrap(tty)		(tty)->Wcm->cm_autowrap
+#define MagicWrap(tty)		(tty)->Wcm->cm_magicwrap
+#define UseTabs(tty)		(tty)->Wcm->cm_usetabs
+#define FrameRows(tty)		(tty)->Wcm->cm_rows
+#define FrameCols(tty)		(tty)->Wcm->cm_cols

-#define UpCost		Wcm.cc_up
-#define DownCost	Wcm.cc_down
-#define LeftCost	Wcm.cc_left
-#define RightCost	Wcm.cc_right
-#define HomeCost	Wcm.cc_home
-#define CRCost		Wcm.cc_cr
-#define LastLineCost	Wcm.cc_ll
-#define TabCost		Wcm.cc_tab
-#define BackTabCost	Wcm.cc_backtab
-#define AbsPositionCost	Wcm.cc_abs
-#define ColPositionCost	Wcm.cc_habs
-#define RowPositionCost	Wcm.cc_vabs
-#define MultiUpCost	Wcm.cc_multiup
-#define MultiDownCost	Wcm.cc_multidown
-#define MultiLeftCost	Wcm.cc_multileft
-#define MultiRightCost	Wcm.cc_multiright
+#define UpCost(tty)		(tty)->Wcm->cc_up
+#define DownCost(tty)		(tty)->Wcm->cc_down
+#define LeftCost(tty)		(tty)->Wcm->cc_left
+#define RightCost(tty)		(tty)->Wcm->cc_right
+#define HomeCost(tty)		(tty)->Wcm->cc_home
+#define CRCost(tty)		(tty)->Wcm->cc_cr
+#define LastLineCost(tty)	(tty)->Wcm->cc_ll
+#define TabCost(tty)		(tty)->Wcm->cc_tab
+#define BackTabCost(tty)	(tty)->Wcm->cc_backtab
+#define AbsPositionCost(tty)	(tty)->Wcm->cc_abs
+#define ColPositionCost(tty)	(tty)->Wcm->cc_habs
+#define RowPositionCost(tty)	(tty)->Wcm->cc_vabs
+#define MultiUpCost(tty)	(tty)->Wcm->cc_multiup
+#define MultiDownCost(tty)	(tty)->Wcm->cc_multidown
+#define MultiLeftCost(tty)	(tty)->Wcm->cc_multileft
+#define MultiRightCost(tty)	(tty)->Wcm->cc_multiright
 #endif

-#define cmat(row,col)	(curY = (row), curX = (col))
-#define cmplus(n)					\
-  {							\
-    if ((curX += (n)) >= FrameCols && !MagicWrap)	\
-      {							\
-	if (Wcm.cm_losewrap) losecursor ();		\
-	else if (AutoWrap) curX = 0, curY++;		\
-	else curX--;					\
-      }							\
+#define cmat(tty,row,col)	(curY(tty) = (row), curX(tty) = (col))
+#define cmplus(tty,n)					            \
+  {                                                                 \
+    if ((curX (tty) += (n)) >= FrameCols (tty) && !MagicWrap (tty)) \
+      {                                                             \
+	if ((tty)->Wcm->cm_losewrap) losecursor (tty);              \
+	else if (AutoWrap (tty)) curX (tty) = 0, curY (tty)++;      \
+	else curX (tty)--;                                          \
+      }                                                             \
   }

-#define losecursor()	(curX = -1, curY = -1)
+#define losecursor(tty)	 (curX(tty) = -1, curY(tty) = -1)

 extern int cost;
 extern int evalcost ();

-extern void cmcheckmagic ();
-extern int cmputc ();
-extern void cmcostinit ();
-extern void cmgoto ();
-extern void Wcm_clear ();
-extern int Wcm_init ();
+#define emacs_tputs(tty, str, affcnt, putc) (current_tty = (tty), tputs (str, affcnt, putc))
+
+extern struct tty_display_info *current_tty;
+extern void cmcheckmagic P_ ((struct tty_display_info *));
+extern int cmputc P_ ((int));
+extern void cmcostinit P_ ((struct tty_display_info *));
+extern void cmgoto P_ ((struct tty_display_info *, int, int));
+extern void Wcm_clear P_ ((struct tty_display_info *));
+extern int Wcm_init P_ ((struct tty_display_info *));

 /* arch-tag: acc1535a-7136-49d6-b22d-9bc85702251b
    (do not change this comment) */
--- a/src/coding.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/coding.c	Mon Oct 25 18:17:28 2004 +0000
@@ -346,6 +346,8 @@
 #include "coding.h"
 #include "window.h"
 #include "intervals.h"
+#include "frame.h"
+#include "termhooks.h"

 #else  /* not emacs */

@@ -428,16 +430,10 @@
 /* Flag to make buffer-file-coding-system inherit from process-coding.  */
 int inherit_process_coding_system;

-/* Coding system to be used to encode text for terminal display.  */
-struct coding_system terminal_coding;
-
 /* Coding system to be used to encode text for terminal display when
    terminal coding system is nil.  */
 struct coding_system safe_terminal_coding;

-/* Coding system of what is sent from terminal keyboard.  */
-struct coding_system keyboard_coding;
-
 /* Default coding system to be used to write a file.  */
 struct coding_system default_buffer_file_coding;

@@ -7214,16 +7210,17 @@
      (coding_system)
      Lisp_Object coding_system;
 {
+  struct coding_system *terminal_coding = FRAME_TERMINAL_CODING (SELECTED_FRAME ());
   CHECK_SYMBOL (coding_system);
-  setup_coding_system (Fcheck_coding_system (coding_system), &terminal_coding);
+  setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
   /* We had better not send unsafe characters to terminal.  */
-  terminal_coding.mode |= CODING_MODE_INHIBIT_UNENCODABLE_CHAR;
+  terminal_coding->mode |= CODING_MODE_INHIBIT_UNENCODABLE_CHAR;
   /* Character composition should be disabled.  */
-  terminal_coding.composing = COMPOSITION_DISABLED;
+  terminal_coding->composing = COMPOSITION_DISABLED;
   /* Error notification should be suppressed.  */
-  terminal_coding.suppress_error = 1;
-  terminal_coding.src_multibyte = 1;
-  terminal_coding.dst_multibyte = 0;
+  terminal_coding->suppress_error = 1;
+  terminal_coding->src_multibyte = 1;
+  terminal_coding->dst_multibyte = 0;
   return Qnil;
 }

@@ -7250,7 +7247,7 @@
        doc: /* Return coding system specified for terminal output.  */)
      ()
 {
-  return terminal_coding.symbol;
+  return FRAME_TERMINAL_CODING (SELECTED_FRAME ())->symbol;
 }

 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
@@ -7260,9 +7257,10 @@
      Lisp_Object coding_system;
 {
   CHECK_SYMBOL (coding_system);
-  setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
+  setup_coding_system (Fcheck_coding_system (coding_system),
+                       FRAME_KEYBOARD_CODING (SELECTED_FRAME ()));
   /* Character composition should be disabled.  */
-  keyboard_coding.composing = COMPOSITION_DISABLED;
+  FRAME_KEYBOARD_CODING (SELECTED_FRAME ())->composing = COMPOSITION_DISABLED;
   return Qnil;
 }

@@ -7271,7 +7269,7 @@
        doc: /* Return coding system specified for decoding keyboard input.  */)
      ()
 {
-  return keyboard_coding.symbol;
+  return FRAME_KEYBOARD_CODING (SELECTED_FRAME ())->symbol;
 }


@@ -7518,8 +7516,6 @@
   iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
   iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;

-  setup_coding_system (Qnil, &keyboard_coding);
-  setup_coding_system (Qnil, &terminal_coding);
   setup_coding_system (Qnil, &safe_terminal_coding);
   setup_coding_system (Qnil, &default_buffer_file_coding);
--- a/src/coding.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/coding.h	Mon Oct 25 18:17:28 2004 +0000
@@ -688,20 +688,10 @@
    the subprocess output.  */
 extern int inherit_process_coding_system;

-/* Coding-system to be used for encoding terminal output.  This
-   structure contains information of a coding-system specified by the
-   function `set-terminal-coding-system'.  */
-extern struct coding_system terminal_coding;
-
 /* Coding system to be used to encode text for terminal display when
    terminal coding system is nil.  */
 extern struct coding_system safe_terminal_coding;

-/* Coding-system of what is sent from terminal keyboard.  This
-   structure contains information of a coding-system specified by the
-   function `set-keyboard-coding-system'.  */
-extern struct coding_system keyboard_coding;
-
 /* Default coding system to be used to write a file.  */
 extern struct coding_system default_buffer_file_coding;
--- a/src/config.in	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/config.in	Mon Oct 25 18:17:28 2004 +0000
@@ -869,6 +869,12 @@
 #define HAVE_MOUSE
 #endif

+/* Multi-tty support relies on MULTI_KBOARD.  It seems safe to turn it
+   on unconditionally. */
+#ifndef MULTI_KBOARD
+#define MULTI_KBOARD
+#endif
+
 /* Define USER_FULL_NAME to return a string
    that is the user's full name.
    It can assume that the variable `pw'
--- a/src/dispextern.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/dispextern.h	Mon Oct 25 18:17:28 2004 +0000
@@ -991,10 +991,6 @@

 extern struct glyph space_glyph;

-/* Frame being updated by update_window/update_frame.  */
-
-extern struct frame *updating_frame;
-
 /* Window being updated by update_window.  This is non-null as long as
    update_window has not finished, and null otherwise.  It's role is
    analogous to updating_frame.  */
@@ -1304,7 +1300,7 @@
 	DESCENT = FONT->descent
 	HEIGHT = FONT_HEIGHT (FONT)
 	F_DESCENT = (FRAME_FONT (F)->descent
-		     - F->output_data.x->baseline_offset)
+		     - F->device->output_data.x->baseline_offset)
 	F_HEIGHT = FRAME_LINE_HEIGHT (F)
 */

@@ -2082,16 +2078,16 @@
 /* Call produce_glyphs or produce_glyphs_hook, if set.  Shortcut to
    avoid the function call overhead.  */

-#define PRODUCE_GLYPHS(IT) 			\
-     do {					\
-       extern int inhibit_free_realized_faces;	\
-       if (rif != NULL)				\
-	 rif->produce_glyphs ((IT));		\
-       else					\
-	 produce_glyphs ((IT));			\
-       if ((IT)->glyph_row != NULL)		\
-	 inhibit_free_realized_faces = 1;	\
-     } while (0)
+#define PRODUCE_GLYPHS(IT)                              \
+  do {                                                  \
+    extern int inhibit_free_realized_faces;             \
+    if (FRAME_RIF ((IT)->f) != NULL)                    \
+      FRAME_RIF ((IT)->f)->produce_glyphs ((IT));       \
+    else                                                \
+      produce_glyphs ((IT));                            \
+    if ((IT)->glyph_row != NULL)                        \
+      inhibit_free_realized_faces = 1;                  \
+  } while (0)

 /* Bit-flags indicating what operation move_it_to should perform.  */

@@ -2265,10 +2261,6 @@
 #endif /* HAVE_WINDOW_SYSTEM */
 };

-/* The current interface for window-based redisplay.  */
-
-extern struct redisplay_interface *rif;
-

 /***********************************************************************
 				Images
@@ -2689,11 +2681,11 @@

 /* Defined in sysdep.c */

-void get_frame_size P_ ((int *, int *));
+void get_tty_size P_ ((int, int *, int *));
 void request_sigio P_ ((void));
 void unrequest_sigio P_ ((void));
-int tabs_safe_p P_ ((void));
-void init_baud_rate P_ ((void));
+int tabs_safe_p P_ ((int));
+void init_baud_rate P_ ((int));
 void init_sigio P_ ((int));

 /* Defined in xfaces.c */
@@ -2829,8 +2821,8 @@
 void prepare_desired_row P_ ((struct glyph_row *));
 int line_hash_code P_ ((struct glyph_row *));
 void set_window_update_flags P_ ((struct window *, int));
-void write_glyphs P_ ((struct glyph *, int));
-void insert_glyphs P_ ((struct glyph *, int));
+void write_glyphs P_ ((struct frame *, struct glyph *, int));
+void insert_glyphs P_ ((struct frame *, struct glyph *, int));
 void redraw_frame P_ ((struct frame *));
 void redraw_garbaged_frames P_ ((void));
 int scroll_cost P_ ((struct frame *, int, int, int));
@@ -2849,30 +2841,38 @@

 /* Defined in term.c */

-extern void ring_bell P_ ((void));
-extern void set_terminal_modes P_ ((void));
-extern void reset_terminal_modes P_ ((void));
+extern void ring_bell P_ ((struct frame *));
 extern void update_begin P_ ((struct frame *));
 extern void update_end P_ ((struct frame *));
-extern void set_terminal_window P_ ((int));
-extern void set_scroll_region P_ ((int, int));
-extern void turn_off_insert P_ ((void));
-extern void turn_off_highlight P_ ((void));
-extern void background_highlight P_ ((void));
-extern void clear_frame P_ ((void));
-extern void clear_end_of_line P_ ((int));
-extern void clear_end_of_line_raw P_ ((int));
-extern void delete_glyphs P_ ((int));
-extern void ins_del_lines P_ ((int, int));
+extern void set_terminal_window P_ ((struct frame *, int));
+extern void set_scroll_region P_ ((struct frame *, int, int));
+extern void turn_off_insert P_ ((struct tty_display_info *));
+extern void turn_off_highlight P_ ((struct tty_display_info *));
+extern void background_highlight P_ ((struct tty_display_info *));
+extern void clear_frame P_ ((struct frame *));
+extern void clear_end_of_line P_ ((struct frame *, int));
+extern void clear_end_of_line_raw P_ ((struct frame *, int));
+extern void tty_clear_end_of_line P_ ((struct frame *, int));
+extern void delete_glyphs P_ ((struct frame *, int));
+extern void ins_del_lines P_ ((struct frame *, int, int));
 extern int string_cost P_ ((char *));
 extern int per_line_cost P_ ((char *));
 extern void calculate_costs P_ ((struct frame *));
 extern void set_tty_color_mode P_ ((struct frame *, Lisp_Object));
-extern void tty_setup_colors P_ ((int));
-extern void term_init P_ ((char *));
+extern void tty_setup_colors P_ ((struct tty_display_info *, int));
+extern struct display *get_display P_ ((Lisp_Object display));
+extern struct display *get_named_tty_display P_ ((char *));
+EXFUN (Fdisplay_tty_type, 1);
+extern struct display *init_initial_display P_ ((void));
+extern struct display *term_init P_ ((char *, char *, int));
+extern void delete_tty P_ ((struct display *));
 extern void fatal P_ ((/* char *, ... */));
-void cursor_to P_ ((int, int));
-extern int tty_capable_p P_ ((struct frame *, unsigned, unsigned long, unsigned long));
+extern void cursor_to P_ ((struct frame *, int, int));
+extern int tty_capable_p P_ ((struct tty_display_info *, unsigned, unsigned long, unsigned long));
+extern void tty_set_terminal_modes P_ ((struct display *));
+extern void tty_reset_terminal_modes P_ ((struct display *));
+extern void create_tty_output P_ ((struct frame *));
+

 /* Defined in scroll.c */
--- a/src/dispnew.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/dispnew.c	Mon Oct 25 18:17:28 2004 +0000
@@ -31,7 +31,6 @@
 #include "lisp.h"
 #include "termchar.h"
 #include "termopts.h"
-#include "termhooks.h"
 /* cm.h must come after dispextern.h on Windows.  */
 #include "dispextern.h"
 #include "cm.h"
@@ -39,6 +38,7 @@
 #include "charset.h"
 #include "keyboard.h"
 #include "frame.h"
+#include "termhooks.h"
 #include "window.h"
 #include "commands.h"
 #include "disptab.h"
@@ -214,9 +214,9 @@
 EMACS_INT baud_rate;

 /* Either nil or a symbol naming the window system under which Emacs
-   is running.  */
-
-Lisp_Object Vwindow_system;
+   creates the first frame.  */
+
+Lisp_Object Vinitial_window_system;

 /* Version number of X windows: 10, 11 or nil.  */

@@ -258,14 +258,6 @@

 struct frame *last_nonminibuf_frame;

-/* Stdio stream being used for copy of all output.  */
-
-FILE *termscript;
-
-/* Structure for info on cursor positioning.  */
-
-struct cm Wcm;
-
 /* 1 means SIGWINCH happened when not safe.  */

 int delayed_size_change;
@@ -304,11 +296,6 @@

 static struct frame *frame_matrix_frame;

-/* Current interface for window-based redisplay.  Set from init_xterm.
-   A null value means we are not using window-based redisplay.  */
-
-struct redisplay_interface *rif;
-
 /* Non-zero means that fonts have been loaded since the last glyph
    matrix adjustments.  Redisplay must stop, and glyph matrices must
    be adjusted when this flag becomes non-zero during display.  The
@@ -1397,7 +1384,7 @@
 	{
 	  int c = glyph->u.ch;
 	  int face_id = glyph->face_id;
-	  if (must_write_spaces)
+	  if (FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
 	    c -= SPACEGLYPH;
 	  hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + c;
 	  hash = (((hash << 4) + (hash >> 24)) & 0x0fffffff) + face_id;
@@ -1429,7 +1416,7 @@
   int glyph_table_len = GLYPH_TABLE_LENGTH;

   /* Ignore trailing and leading spaces if we can.  */
-  if (!must_write_spaces)
+  if (!FRAME_MUST_WRITE_SPACES (SELECTED_FRAME ())) /* XXX Is SELECTED_FRAME OK here? */
     {
       /* Skip from the end over trailing spaces.  */
       while (end > beg && CHAR_GLYPH_SPACE_P (*(end - 1)))
@@ -1645,8 +1632,10 @@
 #if GLYPH_DEBUG


-/* Flush standard output.  This is sometimes useful to call from
-   the debugger.  */
+/* Flush standard output.  This is sometimes useful to call from the debugger.
+   XXX Maybe this should be changed to flush the current terminal instead of
+   stdout.
+*/

 void
 flush_stdout ()
@@ -3319,12 +3308,15 @@
     return Qnil;

   update_begin (f);
+#ifdef MSDOS
   if (FRAME_MSDOS_P (f))
-    set_terminal_modes ();
-  clear_frame ();
+    set_terminal_modes (FRAME_DISPLAY (f));
+#endif
+  clear_frame (f);
   clear_current_matrices (f);
   update_end (f);
-  fflush (stdout);
+  if (FRAME_TERMCAP_P (f))
+    fflush (FRAME_TTY (f)->output);
   windows_or_buffers_changed++;
   /* Mark all windows as inaccurate, so that every window will have
      its redisplay done.  */
@@ -3465,7 +3457,7 @@

   /* If we can't insert glyphs, we can use this method only
      at the end of a line.  */
-  if (!char_ins_del_ok)
+  if (!FRAME_CHAR_INS_DEL_OK (f))
     if (PT != ZV && FETCH_BYTE (PT_BYTE) != '\n')
       return 0;

@@ -3615,24 +3607,24 @@
   updated_row = glyph_row;
   updated_area = TEXT_AREA;
   update_begin (f);
-  if (rif)
+  if (FRAME_RIF (f))
     {
-      rif->update_window_begin_hook (w);
+      FRAME_RIF (f)->update_window_begin_hook (w);

       if (glyphs == end - n
 	  /* In front of a space added by append_space.  */
 	  || (glyphs == end - n - 1
 	      && (end - n)->charpos <= 0))
-	rif->write_glyphs (glyphs, n);
+	FRAME_RIF (f)->write_glyphs (glyphs, n);
       else
-	rif->insert_glyphs (glyphs, n);
+	FRAME_RIF (f)->insert_glyphs (glyphs, n);
     }
   else
     {
       if (glyphs == end - n)
-	write_glyphs (glyphs, n);
+	write_glyphs (f, glyphs, n);
       else
-	insert_glyphs (glyphs, n);
+	insert_glyphs (f, glyphs, n);
     }

   w->cursor.hpos += n;
@@ -3645,8 +3637,8 @@
      a frame matrix is used, cursor_to expects frame coordinates,
      and the X and Y parameters are not used.  */
   if (window_redisplay_p)
-    rif->cursor_to (w->cursor.vpos, w->cursor.hpos,
-		    w->cursor.y, w->cursor.x);
+    FRAME_RIF (f)->cursor_to (w->cursor.vpos, w->cursor.hpos,
+                              w->cursor.y, w->cursor.x);
   else
     {
       int x, y;
@@ -3655,18 +3647,19 @@
 	      ? XFASTINT (w->left_margin_cols)
 	      : 0));
       y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
-      cursor_to (y, x);
+      cursor_to (f, y, x);
     }

 #ifdef HAVE_WINDOW_SYSTEM
   update_window_fringes (w, 0);
 #endif

-  if (rif)
-    rif->update_window_end_hook (w, 1, 0);
+  if (FRAME_RIF (f))
+    FRAME_RIF (f)->update_window_end_hook (w, 1, 0);
   update_end (f);
   updated_row = NULL;
-  fflush (stdout);
+  if (FRAME_TERMCAP_P (f))
+    fflush (FRAME_TTY (f)->output);

   TRACE ((stderr, "direct output for insert\n"));
   mark_window_display_accurate (it.window, 1);
@@ -3744,8 +3737,8 @@
 	   && w->cursor.hpos < w->desired_matrix->matrix_w);

   if (FRAME_WINDOW_P (f))
-    rif->cursor_to (w->cursor.vpos, w->cursor.hpos,
-		    w->cursor.y, w->cursor.x);
+    FRAME_RIF (f)->cursor_to (w->cursor.vpos, w->cursor.hpos,
+                              w->cursor.y, w->cursor.x);
   else
     {
       int x, y;
@@ -3754,10 +3747,11 @@
 	      ? XFASTINT (w->left_margin_cols)
 	      : 0));
       y = WINDOW_TO_FRAME_VPOS (w, w->cursor.vpos);
-      cursor_to (y, x);
+      cursor_to (f, y, x);
     }

-  fflush (stdout);
+  if (FRAME_TERMCAP_P (f))
+    fflush (FRAME_TTY (f)->output);
   redisplay_performed_directly_p = 1;
   return 1;
 }
@@ -3830,14 +3824,14 @@
       update_end (f);

       /* This flush is a performance bottleneck under X,
-	 and it doesn't seem to be necessary anyway (in general).
+ 	 and it doesn't seem to be necessary anyway (in general).
          It is necessary when resizing the window with the mouse, or
-	 at least the fringes are not redrawn in a timely manner.  ++kfs */
+ 	 at least the fringes are not redrawn in a timely manner.  ++kfs */
       if (f->force_flush_display_p)
-	{
-	  rif->flush_display (f);
-	  f->force_flush_display_p = 0;
-	}
+ 	{
+     	  FRAME_RIF (f)->flush_display (f);
+ 	  f->force_flush_display_p = 0;
+ 	}
     }
   else
     {
@@ -3853,9 +3847,12 @@
       paused_p = update_frame_1 (f, force_p, inhibit_hairy_id_p);
       update_end (f);

-      if (termscript)
-	fflush (termscript);
-      fflush (stdout);
+      if (FRAME_TERMCAP_P (f))
+        {
+          if (FRAME_TTY (f)->termscript)
+            fflush (FRAME_TTY (f)->termscript);
+          fflush (FRAME_TTY (f)->output);
+        }

       /* Check window matrices for lost pointers.  */
 #if GLYPH_DEBUG
@@ -3938,7 +3935,8 @@
      int yb;
 {
   int i;
-
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
   /* If rows overlapping others have been changed, the rows being
      overlapped have to be redrawn.  This won't draw lines that have
      already been drawn in update_window_line because overlapped_p in
@@ -3961,10 +3959,12 @@
 	    {
 	      updated_row = row;
 	      updated_area = area;
-	      rif->cursor_to (i, 0, row->y, area == TEXT_AREA ? row->x : 0);
+	      FRAME_RIF (f)->cursor_to (i, 0, row->y,
+                                        area == TEXT_AREA ? row->x : 0);
 	      if (row->used[area])
-		rif->write_glyphs (row->glyphs[area], row->used[area]);
-	      rif->clear_end_of_line (-1);
+		FRAME_RIF (f)->write_glyphs (row->glyphs[area],
+                                             row->used[area]);
+	      FRAME_RIF (f)->clear_end_of_line (-1);
 	    }

 	  row->overlapped_p = 0;
@@ -3986,7 +3986,8 @@
 {
   int i, bottom_y;
   struct glyph_row *row;
-
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
+
   for (i = 0; i < w->current_matrix->nrows; ++i)
     {
       row = w->current_matrix->rows + i;
@@ -4066,6 +4067,7 @@
 #if GLYPH_DEBUG
   struct frame *f = XFRAME (WINDOW_FRAME (w));
 #endif
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));

   /* Check that W's frame doesn't have glyph matrices.  */
   xassert (FRAME_WINDOW_P (f));
@@ -4239,6 +4241,7 @@
      int area, vpos;
 {
   struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));

   /* Let functions in xterm.c know what area subsequent X positions
      will be relative to.  */
@@ -4264,6 +4267,7 @@
 {
   struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
   struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
   int changed_p = 0;

   /* Let functions in xterm.c know what area subsequent X positions
@@ -4485,6 +4489,7 @@
 {
   struct glyph_row *current_row = MATRIX_ROW (w->current_matrix, vpos);
   struct glyph_row *desired_row = MATRIX_ROW (w->desired_matrix, vpos);
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
   int changed_p = 0;

   /* Set the row being updated.  This is important to let xterm.c
@@ -4553,6 +4558,7 @@
      struct window *w;
 {
   struct frame *f = XFRAME (w->frame);
+  struct redisplay_interface *rif = FRAME_RIF (f);
   int cx, cy, vpos, hpos;

   /* Not intended for frame matrix updates.  */
@@ -4776,6 +4782,7 @@
   int i, j, first_old, first_new, last_old, last_new;
   int nruns, nbytes, n, run_idx;
   struct row_entry *entry;
+  struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));

   /* Skip over rows equal at the start.  */
   for (i = header_line_p ? 1 : 0; i < current_matrix->nrows - 1; ++i)
@@ -5100,7 +5107,7 @@
     }

   /* If we cannot insert/delete lines, it's no use trying it.  */
-  if (!line_ins_del_ok)
+  if (!FRAME_LINE_INS_DEL_OK (f))
     inhibit_id_p = 1;

   /* See if any of the desired lines are enabled; don't compute for
@@ -5128,18 +5135,18 @@
 		 Also flush out if likely to have more than 1k buffered
 		 otherwise.   I'm told that some telnet connections get
 		 really screwed by more than 1k output at once.  */
-	      int outq = PENDING_OUTPUT_COUNT (stdout);
+	      int outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f)->output);
 	      if (outq > 900
 		  || (outq > 20 && ((i - 1) % preempt_count == 0)))
 		{
-		  fflush (stdout);
+		  fflush (FRAME_TTY (f)->output);
 		  if (preempt_count == 1)
 		    {
 #ifdef EMACS_OUTQSIZE
 		      if (EMACS_OUTQSIZE (0, &outq) < 0)
 			/* Probably not a tty.  Ignore the error and reset
 			   the outq count.  */
-			outq = PENDING_OUTPUT_COUNT (stdout);
+			outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f->output));
 #endif
 		      outq *= 10;
 		      if (baud_rate <= outq && baud_rate > 0)
@@ -5227,7 +5234,7 @@
 		}
 	    }

-	  cursor_to (row, col);
+	  cursor_to (f, row, col);
 	}
       else
 	{
@@ -5249,7 +5256,7 @@
 		x += XFASTINT (w->left_margin_cols);

 	      /* x = max (min (x, FRAME_TOTAL_COLS (f) - 1), 0); */
-	      cursor_to (y, x);
+	      cursor_to (f, y, x);
 	    }
 	}
     }
@@ -5318,21 +5325,23 @@
     }

   /* If changed lines are few, don't allow preemption, don't scroll.  */
-  if ((!scroll_region_ok && changed_lines < baud_rate / 2400)
+  if ((!FRAME_SCROLL_REGION_OK (frame)
+       && changed_lines < baud_rate / 2400)
       || unchanged_at_bottom == FRAME_LINES (frame))
     return 1;

   window_size = (FRAME_LINES (frame) - unchanged_at_top
 		 - unchanged_at_bottom);

-  if (scroll_region_ok)
+  if (FRAME_SCROLL_REGION_OK (frame))
     free_at_end_vpos -= unchanged_at_bottom;
-  else if (memory_below_frame)
+  else if (FRAME_MEMORY_BELOW_FRAME (frame))
     free_at_end_vpos = -1;

   /* If large window, fast terminal and few lines in common between
      current frame and desired frame, don't bother with i/d calc.  */
-  if (!scroll_region_ok && window_size >= 18 && baud_rate > 2400
+  if (!FRAME_SCROLL_REGION_OK (frame)
+      && window_size >= 18 && baud_rate > 2400
       && (window_size >=
 	  10 * scrolling_max_lines_saved (unchanged_at_top,
 					  FRAME_LINES (frame) - unchanged_at_bottom,
@@ -5412,7 +5421,7 @@
   struct glyph_row *current_row = MATRIX_ROW (current_matrix, vpos);
   struct glyph_row *desired_row = MATRIX_ROW (desired_matrix, vpos);
   int must_write_whole_line_p;
-  int write_spaces_p = must_write_spaces;
+  int write_spaces_p = FRAME_MUST_WRITE_SPACES (f);
   int colored_spaces_p = (FACE_FROM_ID (f, DEFAULT_FACE_ID)->background
 			  != FACE_TTY_DEFAULT_BG_COLOR);

@@ -5463,8 +5472,8 @@
       /* Write the contents of the desired line.  */
       if (nlen)
 	{
-          cursor_to (vpos, 0);
-	  write_glyphs (nbody, nlen);
+          cursor_to (f, vpos, 0);
+	  write_glyphs (f, nbody, nlen);
 	}

       /* Don't call clear_end_of_line if we already wrote the whole
@@ -5472,13 +5481,13 @@
 	 case but in the line below.  */
       if (nlen < FRAME_TOTAL_COLS (f))
 	{
-	  cursor_to (vpos, nlen);
-          clear_end_of_line (FRAME_TOTAL_COLS (f));
+	  cursor_to (f, vpos, nlen);
+          clear_end_of_line (f, FRAME_TOTAL_COLS (f));
 	}
       else
 	/* Make sure we are in the right row, otherwise cursor movement
 	   with cmgoto might use `ch' in the wrong row.  */
-	cursor_to (vpos, 0);
+	cursor_to (f, vpos, 0);

       make_current (desired_matrix, current_matrix, vpos);
       return;
@@ -5491,7 +5500,7 @@
       nlen--;

   /* If there's no i/d char, quickly do the best we can without it.  */
-  if (!char_ins_del_ok)
+  if (!FRAME_CHAR_INS_DEL_OK (f))
     {
       int i, j;

@@ -5510,8 +5519,8 @@
 		++j;

 	      /* Output this run of non-matching chars.  */
-	      cursor_to (vpos, i);
-	      write_glyphs (nbody + i, j - i);
+	      cursor_to (f, vpos, i);
+	      write_glyphs (f, nbody + i, j - i);
 	      i = j - 1;

 	      /* Now find the next non-match.  */
@@ -5521,8 +5530,8 @@
       /* Clear the rest of the line, or the non-clear part of it.  */
       if (olen > nlen)
 	{
-	  cursor_to (vpos, nlen);
-	  clear_end_of_line (olen);
+	  cursor_to (f, vpos, nlen);
+	  clear_end_of_line (f, olen);
 	}

       /* Make current row = desired row.  */
@@ -5544,8 +5553,8 @@

       if (nlen > nsp)
 	{
-	  cursor_to (vpos, nsp);
-	  write_glyphs (nbody + nsp, nlen - nsp);
+	  cursor_to (f, vpos, nsp);
+	  write_glyphs (f, nbody + nsp, nlen - nsp);
 	}

       /* Exchange contents between current_frame and new_frame.  */
@@ -5594,7 +5603,8 @@

   tem = (nlen - nsp) - (olen - osp);
   if (endmatch && tem
-      && (!char_ins_del_ok || endmatch <= char_ins_del_cost (f)[tem]))
+      && (!FRAME_CHAR_INS_DEL_OK (f)
+          || endmatch <= char_ins_del_cost (f)[tem]))
     endmatch = 0;

   /* nsp - osp is the distance to insert or delete.
@@ -5603,7 +5613,7 @@
      Is it worth it?  */

   if (nsp != osp
-      && (!char_ins_del_ok
+      && (!FRAME_CHAR_INS_DEL_OK (f)
 	  || begmatch + endmatch <= char_ins_del_cost (f)[nsp - osp]))
     {
       begmatch = 0;
@@ -5616,8 +5626,8 @@

   if (osp > nsp)
     {
-      cursor_to (vpos, nsp);
-      delete_glyphs (osp - nsp);
+      cursor_to (f, vpos, nsp);
+      delete_glyphs (f, osp - nsp);
     }
   else if (nsp > osp)
     {
@@ -5626,12 +5636,12 @@
 	 must delete first to avoid losing data in the insert */
       if (endmatch && nlen < olen + nsp - osp)
 	{
-	  cursor_to (vpos, nlen - endmatch + osp - nsp);
-	  delete_glyphs (olen + nsp - osp - nlen);
+	  cursor_to (f, vpos, nlen - endmatch + osp - nsp);
+	  delete_glyphs (f, olen + nsp - osp - nlen);
 	  olen = nlen - (nsp - osp);
 	}
-      cursor_to (vpos, osp);
-      insert_glyphs (0, nsp - osp);
+      cursor_to (f, vpos, osp);
+      insert_glyphs (f, 0, nsp - osp);
     }
   olen += nsp - osp;

@@ -5652,8 +5662,8 @@
 	     unnecessary cursor movement.  */
 	  if (nlen - tem > 0)
 	    {
-	      cursor_to (vpos, nsp + begmatch);
-	      write_glyphs (nbody + nsp + begmatch, nlen - tem);
+	      cursor_to (f, vpos, nsp + begmatch);
+	      write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
 	    }
 	}
       else if (nlen > olen)
@@ -5668,27 +5678,27 @@
 	  int out = olen - tem;	/* Columns to be overwritten originally.  */
 	  int del;

-	  cursor_to (vpos, nsp + begmatch);
+	  cursor_to (f, vpos, nsp + begmatch);

 	  /* Calculate columns we can actually overwrite.  */
 	  while (CHAR_GLYPH_PADDING_P (nbody[nsp + begmatch + out]))
 	    out--;
-	  write_glyphs (nbody + nsp + begmatch, out);
+	  write_glyphs (f, nbody + nsp + begmatch, out);

 	  /* If we left columns to be overwritten, we must delete them.  */
 	  del = olen - tem - out;
 	  if (del > 0)
-	    delete_glyphs (del);
+	    delete_glyphs (f, del);

 	  /* At last, we insert columns not yet written out.  */
-	  insert_glyphs (nbody + nsp + begmatch + out, nlen - olen + del);
+	  insert_glyphs (f, nbody + nsp + begmatch + out, nlen - olen + del);
 	  olen = nlen;
 	}
       else if (olen > nlen)
 	{
-	  cursor_to (vpos, nsp + begmatch);
-	  write_glyphs (nbody + nsp + begmatch, nlen - tem);
-	  delete_glyphs (olen - nlen);
+	  cursor_to (f, vpos, nsp + begmatch);
+	  write_glyphs (f, nbody + nsp + begmatch, nlen - tem);
+	  delete_glyphs (f, olen - nlen);
 	  olen = nlen;
 	}
     }
@@ -5697,8 +5707,8 @@
   /* If any unerased characters remain after the new line, erase them.  */
   if (olen > nlen)
     {
-      cursor_to (vpos, nlen);
-      clear_end_of_line (olen);
+      cursor_to (f, vpos, nlen);
+      clear_end_of_line (f, olen);
     }

   /* Exchange contents between current_frame and new_frame.  */
@@ -5994,28 +6004,31 @@
 #endif
   int old_errno = errno;

-  get_frame_size (&width, &height);
-
-  /* The frame size change obviously applies to a termcap-controlled
-     frame.  Find such a frame in the list, and assume it's the only
-     one (since the redisplay code always writes to stdout, not a
-     FILE * specified in the frame structure).  Record the new size,
-     but don't reallocate the data structures now.  Let that be done
-     later outside of the signal handler.  */
-
-  {
-    Lisp_Object tail, frame;
-
-    FOR_EACH_FRAME (tail, frame)
-      {
-	if (FRAME_TERMCAP_P (XFRAME (frame)))
-	  {
-	    change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
-	    break;
-	  }
-      }
+  struct tty_display_info *tty;
+
+  /* The frame size change obviously applies to a single
+     termcap-controlled terminal, but we can't decide which.
+     Therefore, we resize the frames corresponding to each tty.
+  */
+  for (tty = tty_list; tty; tty = tty->next) {
+
+    if (! tty->term_initted)
+      continue;
+
+    get_tty_size (fileno (tty->input), &width, &height);
+
+    {
+      Lisp_Object tail, frame;
+
+      FOR_EACH_FRAME (tail, frame)
+        if (FRAME_TERMCAP_P (XFRAME (frame)) && FRAME_TTY (XFRAME (frame)) == tty)
+          /* Record the new sizes, but don't reallocate the data
+             structures now.  Let that be done later outside of the
+             signal handler.  */
+          change_frame_size (XFRAME (frame), height, width, 0, 1, 0);
+    }
   }
-
+
   signal (SIGWINCH, window_change_signal);
   errno = old_errno;
 }
@@ -6070,10 +6083,11 @@
 {
   Lisp_Object tail, frame;

-  if (! FRAME_WINDOW_P (f))
+  if (FRAME_MSDOS_P (f))
     {
-      /* When using termcap, or on MS-DOS, all frames use
-	 the same screen, so a change in size affects all frames.  */
+      /* On MS-DOS, all frames use the same screen, so a change in
+         size affects all frames.  Termcap now supports multiple
+         ttys. */
       FOR_EACH_FRAME (tail, frame)
 	if (! FRAME_WINDOW_P (XFRAME (frame)))
 	  change_frame_size_1 (XFRAME (frame), newheight, newwidth,
@@ -6153,7 +6167,7 @@
 			   newheight - FRAME_TOP_MARGIN (f), 0);

       if (FRAME_TERMCAP_P (f) && !pretend)
-	FrameRows = newheight;
+	FrameRows (FRAME_TTY (f)) = newheight;
     }

   if (new_frame_total_cols != FRAME_TOTAL_COLS (f))
@@ -6163,7 +6177,7 @@
 	set_window_width (FRAME_MINIBUF_WINDOW (f), new_frame_total_cols, 0);

       if (FRAME_TERMCAP_P (f) && !pretend)
-	FrameCols = newwidth;
+	FrameCols (FRAME_TTY (f)) = newwidth;

       if (WINDOWP (f->tool_bar_window))
 	XSETFASTINT (XWINDOW (f->tool_bar_window)->total_cols, newwidth);
@@ -6213,14 +6227,22 @@
      (file)
      Lisp_Object file;
 {
-  if (termscript != 0) fclose (termscript);
-  termscript = 0;
+  struct tty_display_info *tty;
+
+  if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
+    error ("Current frame is not on a tty device");
+
+  tty = CURTTY ();
+
+  if (tty->termscript != 0)
+    fclose (tty->termscript);
+  tty->termscript = 0;

   if (! NILP (file))
     {
       file = Fexpand_file_name (file, Qnil);
-      termscript = fopen (SDATA (file), "w");
-      if (termscript == 0)
+      tty->termscript = fopen (SDATA (file), "w");
+      if (tty->termscript == 0)
 	report_file_error ("Opening termscript", Fcons (file, Qnil));
     }
   return Qnil;
@@ -6234,16 +6256,23 @@
      (string)
      Lisp_Object string;
 {
+  struct tty_display_info *tty;
+
   /* ??? Perhaps we should do something special for multibyte strings here.  */
   CHECK_STRING (string);
-  fwrite (SDATA (string), 1, SBYTES (string), stdout);
-  fflush (stdout);
-  if (termscript)
+
+  if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
+    error ("Current frame is not on a tty device");
+
+  tty = CURTTY ();
+
+  if (tty->termscript)
     {
-      fwrite (SDATA (string), 1, SBYTES (string),
-	      termscript);
-      fflush (termscript);
+      fwrite (SDATA (string), 1, SBYTES (string), tty->termscript);
+      fflush (tty->termscript);
     }
+  fwrite (SDATA (string), 1, SBYTES (string), tty->output);
+  fflush (tty->output);
   return Qnil;
 }

@@ -6260,8 +6289,7 @@
       if (noninteractive)
 	putchar (07);
       else
-	ring_bell ();
-      fflush (stdout);
+	ring_bell (XFRAME (selected_frame));
     }
   else
     bitch_at_user ();
@@ -6277,8 +6305,7 @@
   else if (!INTERACTIVE)  /* Stop executing a keyboard macro.  */
     error ("Keyboard macro terminated by a command ringing the bell");
   else
-    ring_bell ();
-  fflush (stdout);
+    ring_bell (XFRAME (selected_frame));
 }


@@ -6522,8 +6549,6 @@
 			    Initialization
 ***********************************************************************/

-char *terminal_type;
-
 /* Initialization done when Emacs fork is started, before doing stty.
    Determine terminal type and set terminal_driver.  Then invoke its
    decoding routine to set up variables in the terminal package.  */
@@ -6531,6 +6556,8 @@
 void
 init_display ()
 {
+  char *terminal_type;
+
 #ifdef HAVE_X_WINDOWS
   extern int display_arg;
 #endif
@@ -6540,14 +6567,23 @@
   SET_CHAR_GLYPH_FROM_GLYPH (space_glyph, ' ');
   space_glyph.charpos = -1;

-  meta_key = 0;
   inverse_video = 0;
   cursor_in_echo_area = 0;
   terminal_type = (char *) 0;

   /* Now is the time to initialize this; it's used by init_sys_modes
      during startup.  */
-  Vwindow_system = Qnil;
+  Vinitial_window_system = Qnil;
+
+  /* SIGWINCH needs to be handled no matter what display we start
+     with.  Otherwise newly opened tty frames will not resize
+     automatically. */
+#ifdef SIGWINCH
+#ifndef CANNOT_DUMP
+  if (initialized)
+#endif /* CANNOT_DUMP */
+    signal (SIGWINCH, window_change_signal);
+#endif /* SIGWINCH */

   /* If the user wants to use a window system, we shouldn't bother
      initializing the terminal.  This is especially important when the
@@ -6576,7 +6612,7 @@
 #endif
      )
     {
-      Vwindow_system = intern ("x");
+      Vinitial_window_system = intern ("x");
 #ifdef HAVE_X11
       Vwindow_system_version = make_number (11);
 #else
@@ -6596,7 +6632,7 @@
 #ifdef HAVE_NTGUI
   if (!inhibit_window_system)
     {
-      Vwindow_system = intern ("w32");
+      Vinitial_window_system = intern ("w32");
       Vwindow_system_version = make_number (1);
       adjust_frame_glyphs_initially ();
       return;
@@ -6606,7 +6642,7 @@
 #ifdef MAC_OS
   if (!inhibit_window_system)
     {
-      Vwindow_system = intern ("mac");
+      Vinitial_window_system = intern ("mac");
       Vwindow_system_version = make_number (1);
       adjust_frame_glyphs_initially ();
       return;
@@ -6652,8 +6688,37 @@
   }
 #endif /* VMS */

-  term_init (terminal_type);
-
+  {
+    struct display *d;
+    struct frame *f = XFRAME (selected_frame);
+
+    /* Open a display on the controlling tty. */
+    d = term_init (0, terminal_type, 1); /* Errors are fatal. */
+
+    /* Convert the initial frame to use the new display. */
+    if (f->output_method != output_initial)
+      abort ();
+    f->output_method = d->type;
+    f->display = d;
+#ifdef MULTI_KBOARD
+    f->kboard = d->display_info.tty->kboard;
+#endif
+
+    d->reference_count++;
+    d->display_info.tty->top_frame = selected_frame;
+    change_frame_size (XFRAME (selected_frame), FrameRows (d->display_info.tty), FrameCols (d->display_info.tty), 0, 0, 1);
+
+    /* Delete the initial display. */
+    if (--initial_display->reference_count == 0
+        && initial_display->delete_display_hook)
+      (*initial_display->delete_display_hook) (initial_display);
+
+    /* Update frame parameters to reflect the new type. */
+    Fmodify_frame_parameters
+      (selected_frame, Fcons (Fcons (Qtty_type,
+                                     Fdisplay_tty_type (selected_frame)), Qnil));
+  }
+
   {
     struct frame *sf = SELECTED_FRAME ();
     int width = FRAME_TOTAL_COLS (sf);
@@ -6670,13 +6735,6 @@
   adjust_frame_glyphs_initially ();
   calculate_costs (XFRAME (selected_frame));

-#ifdef SIGWINCH
-#ifndef CANNOT_DUMP
-  if (initialized)
-#endif /* CANNOT_DUMP */
-    signal (SIGWINCH, window_change_signal);
-#endif /* SIGWINCH */
-
   /* Set up faces of the initial terminal frame of a dumped Emacs.  */
   if (initialized
       && !noninteractive
@@ -6687,7 +6745,7 @@
 	 and internal_terminal_init.  */
       && (strcmp (terminal_type, "internal") != 0 || inhibit_window_system)
 #endif
-      && NILP (Vwindow_system))
+      && NILP (Vinitial_window_system))
     {
       /* For the initial frame, we don't have any way of knowing what
 	 are the foreground and background colors of the terminal.  */
@@ -6799,8 +6857,8 @@
 Emacs's frame display when you reenter Emacs.
 It is up to you to set this variable if your terminal can do that.  */);

-  DEFVAR_LISP ("window-system", &Vwindow_system,
-	       doc: /* Name of window system that Emacs is displaying through.
+  DEFVAR_LISP ("initial-window-system", &Vinitial_window_system,
+	       doc: /* Name of the window system that Emacs uses for the first frame.
 The value is a symbol--for instance, `x' for X windows.
 The value is nil if Emacs is using a text-only terminal.  */);

@@ -6836,7 +6894,7 @@
   if (noninteractive)
 #endif
     {
-      Vwindow_system = Qnil;
+      Vinitial_window_system = Qnil;
       Vwindow_system_version = Qnil;
     }
 }
--- a/src/emacs.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/emacs.c	Mon Oct 25 18:17:28 2004 +0000
@@ -54,6 +54,7 @@
 #include "blockinput.h"
 #include "syssignal.h"
 #include "process.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "keyboard.h"
 #include "keymap.h"
@@ -208,7 +209,7 @@


 #ifdef HAVE_WINDOW_SYSTEM
-extern Lisp_Object Vwindow_system;
+extern Lisp_Object Vinitial_window_system;
 #endif /* HAVE_WINDOW_SYSTEM */

 extern Lisp_Object Vauto_save_list_file_name;
@@ -1633,13 +1634,7 @@
 #endif  /* end #ifdef HAVE_NTGUI */
     }

-  if (!noninteractive)
-    {
-#ifdef VMS
-      init_vms_input ();/* init_display calls get_frame_size, that needs this.  */
-#endif /* VMS */
-      init_display ();	/* Determine terminal type.  init_sys_modes uses results.  */
-    }
+  init_process (); /* init_display uses add_keyboard_wait_descriptor. */
 #ifndef MAC_OS8
   /* Called before init_window_once for Mac OS Classic.  */
   init_keyboard ();	/* This too must precede init_sys_modes.  */
@@ -1647,7 +1642,13 @@
 #ifdef VMS
   init_vmsproc ();	/* And this too.  */
 #endif /* VMS */
-  init_sys_modes ();	/* Init system terminal modes (RAW or CBREAK, etc.).  */
+  if (!noninteractive)
+    {
+#ifdef VMS
+      init_vms_input ();/* init_display calls get_tty_size, that needs this.  */
+#endif /* VMS */
+      init_display ();	/* Determine terminal type.  Calls init_sys_modes.  */
+    }
   init_fns ();
   init_xdisp ();
 #ifdef HAVE_WINDOW_SYSTEM
@@ -1660,7 +1661,6 @@
 #ifdef VMS
   init_vmsfns ();
 #endif /* VMS */
-  init_process ();
 #ifdef HAVE_SOUND
   init_sound ();
 #endif
@@ -1983,9 +1983,9 @@

   bcopy (new, argv, sizeof (char *) * argc);

-  free (options);
-  free (new);
-  free (priority);
+  xfree (options);
+  xfree (new);
+  xfree (priority);
 }

 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
@@ -2067,15 +2067,14 @@
     if (EMACS_GET_TTY_PGRP (0, &tpgrp) != -1
 	&& tpgrp == pgrp)
       {
-	fflush (stdout);
-	reset_sys_modes ();
+	reset_all_sys_modes ();
 	if (sig && sig != SIGTERM)
 	  fprintf (stderr, "Fatal error (%d)", sig);
       }
   }
 #else
   fflush (stdout);
-  reset_sys_modes ();
+  reset_all_sys_modes ();
 #endif

   stuff_buffered_input (stuff);
@@ -2094,9 +2093,9 @@
 #if 0 /* This triggers a bug in XCloseDisplay and is not needed.  */
 #ifdef HAVE_X_WINDOWS
   /* It's not safe to call intern here.  Maybe we are crashing.  */
-  if (!noninteractive && SYMBOLP (Vwindow_system)
-      && SCHARS (SYMBOL_NAME (Vwindow_system)) == 1
-      && SREF (SYMBOL_NAME (Vwindow_system), 0) == 'x'
+  if (!noninteractive && SYMBOLP (Vinitial_window_system)
+      && SCHARS (SYMBOL_NAME (Vinitial_window_system)) == 1
+      && SREF (SYMBOL_NAME (Vinitial_window_system), 0) == 'x'
       && ! no_x)
     Fx_close_current_connection ();
 #endif /* HAVE_X_WINDOWS */
--- a/src/fileio.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/fileio.c	Mon Oct 25 18:17:28 2004 +0000
@@ -78,6 +78,8 @@
 #include "charset.h"
 #include "coding.h"
 #include "window.h"
+#include "frame.h"
+#include "dispextern.h"

 #ifdef WINDOWSNT
 #define NOMINMAX 1
@@ -5686,7 +5688,7 @@
   int i, nbytes;
   struct gcpro gcpro1;

-  ring_bell ();
+  ring_bell (XFRAME (selected_frame));

   args[0] = build_string ("Auto-saving %s: %s");
   args[1] = current_buffer->name;
--- a/src/fontset.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/fontset.c	Mon Oct 25 18:17:28 2004 +0000
@@ -46,6 +46,7 @@
 #ifdef MAC_OS
 #include "macterm.h"
 #endif
+#include "termhooks.h"

 #ifdef FONTSET_DEBUG
 #undef xassert
@@ -1310,7 +1311,7 @@
       STORE_XCHAR2B (&char2b, c1, c2);
     else
       STORE_XCHAR2B (&char2b, 0, c1);
-    rif->encode_char (c, &char2b, fontp, NULL);
+    FRAME_RIF (f)->encode_char (c, &char2b, fontp, NULL);
     code = (XCHAR2B_BYTE1 (&char2b) << 8) | XCHAR2B_BYTE2 (&char2b);
   }
   return Fcons (build_string (face->font_name), make_number (code));
--- a/src/frame.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/frame.c	Mon Oct 25 18:17:28 2004 +0000
@@ -42,6 +42,7 @@
 #include "fontset.h"
 #endif
 #include "blockinput.h"
+#include "termchar.h"
 #include "termhooks.h"
 #include "dispextern.h"
 #include "window.h"
@@ -75,6 +76,8 @@

 Lisp_Object Qx_frame_parameter;
 Lisp_Object Qx_resource_name;
+Lisp_Object Qdisplay_id;
+Lisp_Object Qdisplay_live_p;

 /* Frame parameters (set or reported).  */

@@ -106,12 +109,13 @@
 Lisp_Object Qleft_fringe, Qright_fringe;
 Lisp_Object Qbuffer_predicate, Qbuffer_list;
 Lisp_Object Qtty_color_mode;
+Lisp_Object Qtty, Qtty_type;
+Lisp_Object Qwindow_system;

 Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth;

 Lisp_Object Qface_set_after_frame_default;

-
 Lisp_Object Vterminal_frame;
 Lisp_Object Vdefault_frame_alist;
 Lisp_Object Vdefault_frame_scroll_bars;
@@ -121,8 +125,8 @@

 static void
 set_menu_bar_lines_1 (window, n)
-  Lisp_Object window;
-  int n;
+     Lisp_Object window;
+     int n;
 {
   struct window *w = XWINDOW (window);

@@ -180,8 +184,6 @@
 Lisp_Object Vemacs_iconified;
 Lisp_Object Vframe_list;

-struct x_output tty_display;
-
 extern Lisp_Object Vminibuffer_list;
 extern Lisp_Object get_minibuffer ();
 extern Lisp_Object Fhandle_switch_frame ();
@@ -203,6 +205,7 @@
     return Qnil;
   switch (XFRAME (object)->output_method)
     {
+    case output_initial: /* The initial frame is like a termcap frame. */
     case output_termcap:
       return Qt;
     case output_x_window:
@@ -233,6 +236,30 @@
 	  : Qnil);
 }

+DEFUN ("window-system", Fwindow_system, Swindow_system, 0, 1, 0,
+       doc: /* The name of the window system that FRAME is displaying through.
+The value is a symbol---for instance, 'x' for X windows.
+The value is nil if Emacs is using a text-only terminal.
+
+FRAME defaults to the currently selected frame.  */)
+  (frame)
+     Lisp_Object frame;
+{
+  Lisp_Object type;
+  if (NILP (frame))
+    frame = selected_frame;
+
+  type = Fframep (frame);
+
+  if (NILP (type))
+    wrong_type_argument (Qframep, frame);
+
+  if (EQ (type, Qt))
+    return Qnil;
+  else
+    return type;
+}
+
 struct frame *
 make_frame (mini_p)
      int mini_p;
@@ -474,18 +501,19 @@
 }
 #endif /* HAVE_WINDOW_SYSTEM */

-/* Construct a frame that refers to the terminal (stdin and stdout).  */
+/* Construct a frame that refers to a terminal.  */

 static int terminal_frame_count;

 struct frame *
-make_terminal_frame ()
+make_initial_frame (void)
 {
-  register struct frame *f;
+  struct frame *f;
+  struct display *display;
   Lisp_Object frame;
-  char name[20];

 #ifdef MULTI_KBOARD
+  /* Create the initial keyboard. */
   if (!initial_kboard)
     {
       initial_kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
@@ -499,6 +527,45 @@
   if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
     Vframe_list = Qnil;

+  display = init_initial_display ();
+
+  f = make_frame (1);
+  XSETFRAME (frame, f);
+
+  Vframe_list = Fcons (frame, Vframe_list);
+
+  terminal_frame_count = 1;
+  f->name = build_string ("F1");
+
+  f->visible = 1;
+  f->async_visible = 1;
+
+  f->output_method = display->type;
+  f->display = display;
+  f->display->reference_count++;
+  f->output_data.nothing = 0;
+
+  FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
+  FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
+
+  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
+  FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
+
+#ifdef MULTI_KBOARD
+  f->kboard = initial_kboard;
+#endif
+
+  return f;
+}
+
+
+struct frame *
+make_terminal_frame (struct display *display)
+{
+  register struct frame *f;
+  Lisp_Object frame;
+  char name[20];
+
   f = make_frame (1);

   XSETFRAME (frame, f);
@@ -537,12 +604,35 @@
 #else
 #ifdef WINDOWSNT
   f->output_method = output_termcap;
-  f->output_data.x = &tty_display;
+  f->output_data.x = &tty_display; /* XXX ??? */
 #else
 #ifdef MAC_OS8
   make_mac_terminal_frame (f);
 #else
-  f->output_data.x = &tty_display;
+  {
+    f->output_method = output_termcap;
+    f->display = display;
+    f->display->reference_count++;
+    create_tty_output (f);
+
+    FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
+    FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
+
+    FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
+    FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
+
+#ifdef MULTI_KBOARD
+    f->kboard = FRAME_TTY (f)->kboard;
+#endif
+
+    /* Set the top frame to the newly created frame. */
+    if (FRAME_TTY (f)->top_frame
+        && FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
+      XFRAME (FRAME_TTY (f)->top_frame)->async_visible = 2; /* obscured */
+
+    FRAME_TTY (f)->top_frame = frame;
+  }
+
 #ifdef CANNOT_DUMP
   FRAME_FOREGROUND_PIXEL(f) = FACE_TTY_DEFAULT_FG_COLOR;
   FRAME_BACKGROUND_PIXEL(f) = FACE_TTY_DEFAULT_BG_COLOR;
@@ -559,16 +649,26 @@

 DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
        1, 1, 0,
-       doc: /* Create an additional terminal frame.
-You can create multiple frames on a text-only terminal in this way.
-Only the selected terminal frame is actually displayed.
+       doc: /* Create an additional terminal frame, possibly on another terminal.
 This function takes one argument, an alist specifying frame parameters.
-In practice, generally you don't need to specify any parameters.
-Note that changing the size of one terminal frame automatically affects all.  */)
+
+You can create multiple frames on a single text-only terminal, but
+only one of them (the selected terminal frame) is actually displayed.
+
+In practice, generally you don't need to specify any parameters,
+except when you want to create a new frame on another terminal.
+In that case, the `tty' parameter specifies the device file to open,
+and the `tty-type' parameter specifies the terminal type.  Example:
+
+   (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
+
+Note that changing the size of one terminal frame automatically
+affects all frames on the same terminal device.  */)
      (parms)
      Lisp_Object parms;
 {
   struct frame *f;
+  struct display *d = NULL;
   Lisp_Object frame, tem;
   struct frame *sf = SELECTED_FRAME ();

@@ -582,20 +682,89 @@
   if (sf->output_method != output_mac)
     error ("Not running on a Macintosh screen; cannot make a new Macintosh frame");
 #else
+#if 0                           /* This should work now! */
   if (sf->output_method != output_termcap)
     error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
 #endif
+#endif
 #endif /* not MSDOS */
-
-  f = make_terminal_frame ();
-
-  change_frame_size (f, FRAME_LINES (sf),
-		     FRAME_COLS (sf), 0, 0, 0);
+
+  {
+    Lisp_Object display_device;
+
+    display_device = Fassq (Qdisplay_id, parms);
+    if (!NILP (display_device))
+      {
+        display_device = XCDR (display_device);
+        CHECK_NUMBER (display_device);
+        d = get_display (XINT (display_device));
+        if (!d)
+          wrong_type_argument (Qdisplay_live_p, display_device);
+      }
+  }
+
+  if (!d)
+    {
+      Lisp_Object tty, tty_type;
+      char *name = 0, *type = 0;
+
+      tty = Fassq (Qtty, parms);
+      if (EQ (tty, Qnil))
+        tty = Fassq (Qtty, XFRAME (selected_frame)->param_alist);
+      if (EQ (tty, Qnil) && FRAME_TERMCAP_P (XFRAME (selected_frame))
+          && FRAME_TTY (XFRAME (selected_frame))->name)
+        tty = build_string (FRAME_TTY (XFRAME (selected_frame))->name);
+      if (EQ (tty, Qnil))
+        tty = Fassq (Qtty, Vdefault_frame_alist);
+      if (! EQ (tty, Qnil) && ! STRINGP (tty))
+        tty = XCDR (tty);
+      if (EQ (tty, Qnil) || !STRINGP (tty))
+        tty = Qnil;
+
+      tty_type = Fassq (Qtty_type, parms);
+      if (EQ (tty_type, Qnil))
+        tty_type = Fassq (Qtty, XFRAME (selected_frame)->param_alist);
+      if (EQ (tty_type, Qnil) && FRAME_TERMCAP_P (XFRAME (selected_frame))
+          && FRAME_TTY (XFRAME (selected_frame))->type)
+        tty_type = build_string (FRAME_TTY (XFRAME (selected_frame))->type);
+      if (EQ (tty_type, Qnil))
+        tty_type = Fassq (Qtty_type, Vdefault_frame_alist);
+      if (! EQ (tty_type, Qnil) && ! STRINGP (tty_type))
+        tty_type = XCDR (tty_type);
+      if (EQ (tty_type, Qnil) || !STRINGP (tty_type))
+        tty_type = Qnil;
+
+      if (! EQ (tty, Qnil))
+        {
+          name = (char *) alloca (SBYTES (tty) + 1);
+          strncpy (name, SDATA (tty), SBYTES (tty));
+          name[SBYTES (tty)] = 0;
+        }
+
+      if (! EQ (tty_type, Qnil))
+        {
+          type = (char *) alloca (SBYTES (tty_type) + 1);
+          strncpy (type, SDATA (tty_type), SBYTES (tty_type));
+          type[SBYTES (tty_type)] = 0;
+        }
+
+      d = term_init (name, type, 0); /* Errors are not fatal. */
+    }
+
+  f = make_terminal_frame (d);
+
+  {
+    int width, height;
+    get_tty_size (fileno (FRAME_TTY (f)->input), &width, &height);
+    change_frame_size (f, height, width, 0, 0, 0);
+  }
+
   adjust_glyphs (f);
   calculate_costs (f);
   XSETFRAME (frame, f);
   Fmodify_frame_parameters (frame, Vdefault_frame_alist);
   Fmodify_frame_parameters (frame, parms);
+  Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qnil), Qnil));

   /* Make the frame face alist be frame-specific, so that each
      frame could change its face definitions independently.  */
@@ -694,6 +863,15 @@
   if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
     resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);

+  if (FRAME_TERMCAP_P (XFRAME (selected_frame))
+      && FRAME_TERMCAP_P (XFRAME (frame))
+      && FRAME_TTY (XFRAME (selected_frame)) == FRAME_TTY (XFRAME (frame)))
+    {
+      XFRAME (selected_frame)->async_visible = 2; /* obscured */
+      XFRAME (frame)->async_visible = 1;
+      FRAME_TTY (XFRAME (frame))->top_frame = frame;
+    }
+
   selected_frame = frame;
   if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
     last_nonminibuf_frame = XFRAME (selected_frame);
@@ -887,6 +1065,31 @@
   return XFRAME (frame)->selected_window = window;
 }

+
+DEFUN ("frame-display", Fframe_display, Sframe_display, 0, 1, 0,
+       doc: /* Return the display device that FRAME is displayed on.
+If FRAME is nil, the selected frame is used.
+
+The display device is represented by its integer identifier.  */)
+  (frame)
+     Lisp_Object frame;
+{
+  struct display *d;
+
+  if (NILP (frame))
+    frame = selected_frame;
+
+  CHECK_LIVE_FRAME (frame);
+
+  d = get_display (frame);
+
+  if (!d)
+    return Qnil;
+  else
+    return make_number (d->id);
+}
+
+
 DEFUN ("frame-list", Fframe_list, Sframe_list,
        0, 0, 0,
        doc: /* Return a list of all frames.  */)
@@ -933,7 +1136,10 @@
 	f = XCAR (tail);

 	if (passed
-	    && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+	    && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
+                 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+                || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
+                    && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame)))))
 	  {
 	    /* Decide whether this frame is eligible to be returned.  */

@@ -1010,7 +1216,10 @@
       if (EQ (frame, f) && !NILP (prev))
 	return prev;

-      if (FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+      if ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
+           && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+          || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
+              && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame))))
 	{
 	  /* Decide whether this frame is eligible to be returned,
 	     according to minibuf.  */
@@ -1222,6 +1431,10 @@
       Frun_hook_with_args (2, args);
     }

+  /* The hook may sometimes (indirectly) cause the frame to be deleted.  */
+  if (! FRAME_LIVE_P (f))
+    return Qnil;
+
   minibuffer_selected = EQ (minibuf_window, selected_window);

   /* Don't let the frame remain selected.  */
@@ -1237,7 +1450,7 @@
 	{
 	  FOR_EACH_FRAME (tail, frame1)
 	    {
-	      if (! EQ (frame, frame1))
+	      if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
 		break;
 	    }
 	}
@@ -1304,13 +1517,26 @@
      promise that the display of the frame must be valid until we have
      called the window-system-dependent frame destruction routine.  */

-  /* I think this should be done with a hook.  */
-#ifdef HAVE_WINDOW_SYSTEM
-  if (FRAME_WINDOW_P (f))
-    x_destroy_window (f);
-#endif
-
-  f->output_data.nothing = 0;
+  if (FRAME_DISPLAY (f)->delete_frame_hook)
+    (*FRAME_DISPLAY (f)->delete_frame_hook) (f);
+
+  {
+    struct display *display = FRAME_DISPLAY (f);
+
+    f->output_data.nothing = 0;
+    f->display = 0;             /* Now the frame is dead. */
+
+    /* If needed, delete the device that this frame was on.
+       (This must be done after the frame is killed.) */
+    display->reference_count--;
+    if (display->reference_count == 0)
+    {
+      if (display->delete_display_hook)
+        (*display->delete_display_hook) (display);
+      else
+        delete_display (display);
+    }
+  }

   /* If we've deleted the last_nonminibuf_frame, then try to find
      another one.  */
@@ -1455,11 +1681,11 @@

 #ifdef HAVE_MOUSE
   /* It's okay for the hook to refrain from storing anything.  */
-  if (mouse_position_hook)
-    (*mouse_position_hook) (&f, -1,
-			    &lispy_dummy, &party_dummy,
-			    &x, &y,
-			    &long_dummy);
+  if (FRAME_DISPLAY (f)->mouse_position_hook)
+    (*FRAME_DISPLAY (f)->mouse_position_hook) (&f, -1,
+                                              &lispy_dummy, &party_dummy,
+                                              &x, &y,
+                                              &long_dummy);
   if (! NILP (x))
     {
       col = XINT (x);
@@ -1498,11 +1724,11 @@

 #ifdef HAVE_MOUSE
   /* It's okay for the hook to refrain from storing anything.  */
-  if (mouse_position_hook)
-    (*mouse_position_hook) (&f, -1,
-			    &lispy_dummy, &party_dummy,
-			    &x, &y,
-			    &long_dummy);
+  if (FRAME_DISPLAY (f)->mouse_position_hook)
+    (*FRAME_DISPLAY (f)->mouse_position_hook) (&f, -1,
+                                              &lispy_dummy, &party_dummy,
+                                              &x, &y,
+                                              &long_dummy);
 #endif
   XSETFRAME (lispy_dummy, f);
   return Fcons (lispy_dummy, Fcons (x, y));
@@ -1768,16 +1994,19 @@
      (frame)
      Lisp_Object frame;
 {
+  struct frame *f;
   if (NILP (frame))
     frame = selected_frame;

   CHECK_LIVE_FRAME (frame);

+  f = XFRAME (frame);
+
   /* Do like the documentation says. */
   Fmake_frame_visible (frame);

-  if (frame_raise_lower_hook)
-    (*frame_raise_lower_hook) (XFRAME (frame), 1);
+  if (FRAME_DISPLAY (f)->frame_raise_lower_hook)
+    (*FRAME_DISPLAY (f)->frame_raise_lower_hook) (f, 1);

   return Qnil;
 }
@@ -1791,13 +2020,17 @@
      (frame)
      Lisp_Object frame;
 {
+  struct frame *f;
+
   if (NILP (frame))
     frame = selected_frame;

   CHECK_LIVE_FRAME (frame);

-  if (frame_raise_lower_hook)
-    (*frame_raise_lower_hook) (XFRAME (frame), 0);
+  f = XFRAME (frame);
+
+  if (FRAME_DISPLAY (f)->frame_raise_lower_hook)
+    (*FRAME_DISPLAY (f)->frame_raise_lower_hook) (f, 0);

   return Qnil;
 }
@@ -1831,6 +2064,8 @@
      (frame, focus_frame)
      Lisp_Object frame, focus_frame;
 {
+  struct frame *f;
+
   /* Note that we don't check for a live frame here.  It's reasonable
      to redirect the focus of a frame you're about to delete, if you
      know what other frame should receive those keystrokes.  */
@@ -1839,10 +2074,12 @@
   if (! NILP (focus_frame))
     CHECK_LIVE_FRAME (focus_frame);

-  XFRAME (frame)->focus_frame = focus_frame;
-
-  if (frame_rehighlight_hook)
-    (*frame_rehighlight_hook) (XFRAME (frame));
+  f = XFRAME (frame);
+
+  f->focus_frame = focus_frame;
+
+  if (FRAME_DISPLAY (f)->frame_rehighlight_hook)
+    (*FRAME_DISPLAY (f)->frame_rehighlight_hook) (f);

   return Qnil;
 }
@@ -2731,8 +2968,8 @@
 	      if (NATNUMP (param_index)
 		  && (XFASTINT (param_index)
 		      < sizeof (frame_parms)/sizeof (frame_parms[0]))
-		  && rif->frame_parm_handlers[XINT (param_index)])
-		(*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
+                  && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
+                (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
 	    }
 	}
     }
@@ -2775,8 +3012,8 @@
 	  if (NATNUMP (param_index)
 	      && (XFASTINT (param_index)
 		  < sizeof (frame_parms)/sizeof (frame_parms[0]))
-	      && rif->frame_parm_handlers[XINT (param_index)])
-	    (*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
+	      && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
+	    (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
 	}
     }

@@ -3977,7 +4214,13 @@
   staticpro (&Qbackground_mode);
   Qtty_color_mode = intern ("tty-color-mode");
   staticpro (&Qtty_color_mode);
-
+  Qtty = intern ("tty");
+  staticpro (&Qtty);
+  Qtty_type = intern ("tty-type");
+  staticpro (&Qtty_type);
+  Qwindow_system = intern ("window-system");
+  staticpro (&Qwindow_system);
+
   Qface_set_after_frame_default = intern ("face-set-after-frame-default");
   staticpro (&Qface_set_after_frame_default);

@@ -3993,6 +4236,11 @@
   Qx_frame_parameter = intern ("x-frame-parameter");
   staticpro (&Qx_frame_parameter);

+  Qdisplay_id = intern ("display-id");
+  staticpro (&Qdisplay_id);
+  Qdisplay_live_p = intern ("display-live-p");
+  staticpro (&Qdisplay_live_p);
+
   {
     int i;

@@ -4066,7 +4314,7 @@
   staticpro (&Qinhibit_default_face_x_resources);

   DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
-	       doc: /* The initial frame-object, which represents Emacs's stdout.  */);
+               doc: /* The initial frame-object, which represents Emacs's stdout.  */);

   DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
 	       doc: /* Non-nil if all of emacs is iconified and frame updates are not needed.  */);
@@ -4114,6 +4362,7 @@
   defsubr (&Sactive_minibuffer_window);
   defsubr (&Sframep);
   defsubr (&Sframe_live_p);
+  defsubr (&Swindow_system);
   defsubr (&Smake_terminal_frame);
   defsubr (&Shandle_switch_frame);
   defsubr (&Signore_event);
@@ -4124,6 +4373,7 @@
   defsubr (&Sframe_first_window);
   defsubr (&Sframe_selected_window);
   defsubr (&Sset_frame_selected_window);
+  defsubr (&Sframe_display);
   defsubr (&Sframe_list);
   defsubr (&Snext_frame);
   defsubr (&Sprevious_frame);
--- a/src/frame.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/frame.h	Mon Oct 25 18:17:28 2004 +0000
@@ -28,9 +28,7 @@

 /* Miscellanea.  */

-/* Nonzero means don't assume anything about current contents of
-   actual terminal frame */
-
+/* Nonzero means there is at least one garbaged frame. */
 extern int frame_garbaged;

 /* Nonzero means FRAME_MESSAGE_BUF (selected_frame) is being used by
@@ -43,6 +41,7 @@

 enum output_method
 {
+  output_initial,
   output_termcap,
   output_x_window,
   output_msdos_raw,
@@ -67,30 +66,10 @@
   HBAR_CURSOR
 };

-#if !defined(MSDOS) && !defined(WINDOWSNT) && !defined(MAC_OS)
-
-#if !defined(HAVE_X_WINDOWS)
-
-#define PIX_TYPE int
+#define FRAME_FOREGROUND_PIXEL(f) ((f)->foreground_pixel)
+#define FRAME_BACKGROUND_PIXEL(f) ((f)->background_pixel)

-/* A (mostly empty) x_output structure definition for building Emacs
-   on Unix and GNU/Linux without X support.  */
-struct x_output
-{
-  PIX_TYPE background_pixel;
-  PIX_TYPE foreground_pixel;
-};
-
-#endif /* ! HAVE_X_WINDOWS */
-
-
-#define FRAME_FOREGROUND_PIXEL(f) ((f)->output_data.x->foreground_pixel)
-#define FRAME_BACKGROUND_PIXEL(f) ((f)->output_data.x->background_pixel)
-
-/* A structure describing a termcap frame display.  */
-extern struct x_output tty_display;
-
-#endif /* ! MSDOS && ! WINDOWSNT && ! MAC_OS */
+struct display;

 struct frame
 {
@@ -278,20 +257,24 @@
   /* Canonical Y unit.  Height of a line, in pixels.  */
   int line_height;

-  /* The output method says how the contents of this frame
-     are displayed.  It could be using termcap, or using an X window.  */
+  /* The output method says how the contents of this frame are
+     displayed.  It could be using termcap, or using an X window.
+     This must be the same as the display->type. */
   enum output_method output_method;

-  /* A structure of auxiliary data used for displaying the contents.
-     struct x_output is used for X window frames;
-     it is defined in xterm.h.
-     struct w32_output is used for W32 window frames;
-     it is defined in w32term.h.  */
+  /* The display that this frame uses.  If this is NULL, then the
+     frame is deleted. */
+  struct display *display;
+
+  /* Display-dependent, frame-local auxiliary data used for displaying
+     the contents.  When the frame is deleted, this data is deleted as
+     well. */
   union output_data
   {
-    struct x_output *x;
-    struct w32_output *w32;
-    struct mac_output *mac;
+    struct tty_output *tty;     /* termchar.h */
+    struct x_output *x;         /* xterm.h */
+    struct w32_output *w32;     /* w32term.h */
+    struct mac_output *mac;     /* macterm.h */
     EMACS_INT nothing;
   }
   output_data;
@@ -307,9 +290,12 @@
   int left_fringe_width, right_fringe_width;

 #ifdef MULTI_KBOARD
+  /* XXX Maybe this should be moved to struct display, too. */
   /* A pointer to the kboard structure associated with this frame.
-     For termcap frames, this points to initial_kboard.  For X frames,
-     it will be the same as display.x->display_info->kboard.  */
+     For termcap frames, it will be the same as
+     display->display_info.tty->kboard.
+     For X frames, it will be the same as
+     display->display_info.x->kboard.  */
   struct kboard *kboard;
 #endif

@@ -336,13 +322,13 @@
      frame becomes visible again, it must be marked as garbaged.  The
      FRAME_SAMPLE_VISIBILITY macro takes care of this.

-     On Windows NT/9X, to avoid wasting effort updating visible frames
-     that are actually completely obscured by other windows on the
-     display, we bend the meaning of visible slightly: if greater than
-     1, then the frame is obscured - we still consider it to be
-     "visible" as seen from lisp, but we don't bother updating it.  We
-     must take care to garbage the frame when it ceaces to be obscured
-     though.  Note that these semantics are only used on NT/9X.
+     On ttys and on Windows NT/9X, to avoid wasting effort updating
+     visible frames that are actually completely obscured by other
+     windows on the display, we bend the meaning of visible slightly:
+     if greater than 1, then the frame is obscured - we still consider
+     it to be "visible" as seen from lisp, but we don't bother
+     updating it.  We must take care to garbage the frame when it
+     ceaces to be obscured though.

      iconified is nonzero if the frame is currently iconified.

@@ -455,7 +441,11 @@
   /* Set to non-zero in when we want for force a flush_display in
      update_frame, usually after resizing the frame.  */
   unsigned force_flush_display_p : 1;
-
+
+  /* All display backends seem to need these two pixel values. */
+  unsigned long background_pixel;
+  unsigned long foreground_pixel;
+
   /* Set to non-zero if the default face for the frame has been
      realized.  Reset to zero whenever the default face changes.
      Used to see the difference between a font change and face change.  */
@@ -477,6 +467,7 @@
 #define WINDOW_FRAME(w) (w)->frame

 /* Test a frame for particular kinds of display methods.  */
+#define FRAME_INITIAL_P(f) ((f)->output_method == output_initial)
 #define FRAME_TERMCAP_P(f) ((f)->output_method == output_termcap)
 #define FRAME_X_P(f) ((f)->output_method == output_x_window)
 #define FRAME_W32_P(f) ((f)->output_method == output_w32)
@@ -500,7 +491,7 @@
 #endif

 /* Nonzero if frame F is still alive (not deleted).  */
-#define FRAME_LIVE_P(f) ((f)->output_data.nothing != 0)
+#define FRAME_LIVE_P(f) ((f)->display != 0)

 /* Nonzero if frame F is a minibuffer-only frame.  */
 #define FRAME_MINIBUF_ONLY_P(f) \
@@ -740,7 +731,10 @@

    Also, if a frame used to be invisible, but has just become visible,
    it must be marked as garbaged, since redisplay hasn't been keeping
-   up its contents.  */
+   up its contents.
+
+   Note that a tty frame is visible if and only if it is the topmost
+   frame. */

 #define FRAME_SAMPLE_VISIBILITY(f) \
   (((f)->async_visible && (f)->visible != (f)->async_visible) ? \
@@ -780,10 +774,13 @@


 extern Lisp_Object Qframep, Qframe_live_p;
+extern Lisp_Object Qtty, Qtty_type;
+extern Lisp_Object Qdisplay_id, Qdisplay_live_p;

 extern struct frame *last_nonminibuf_frame;

-extern struct frame *make_terminal_frame P_ ((void));
+extern struct frame *make_initial_frame P_ ((void));
+extern struct frame *make_terminal_frame P_ ((struct display *));
 extern struct frame *make_frame P_ ((int));
 #ifdef HAVE_WINDOW_SYSTEM
 extern struct frame *make_minibuffer_frame P_ ((void));
@@ -1011,6 +1008,8 @@
 extern Lisp_Object Qleft, Qright, Qtop, Qbox;
 extern Lisp_Object Qdisplay;

+extern Lisp_Object Qwindow_system;
+
 #ifdef HAVE_WINDOW_SYSTEM

 /* The class of this X application.  */
--- a/src/fringe.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/fringe.c	Mon Oct 25 18:17:28 2004 +0000
@@ -28,6 +28,7 @@
 #include "dispextern.h"
 #include "buffer.h"
 #include "blockinput.h"
+#include "termhooks.h"

 #ifdef HAVE_WINDOW_SYSTEM

@@ -644,7 +645,7 @@
       break;
     }

-  rif->draw_fringe_bitmap (w, row, &p);
+  FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
 }

 void
@@ -1067,6 +1068,8 @@
   fbp = &fringe_bitmaps[n];
   if (*fbp && (*fbp)->dynamic)
     {
+      /* XXX Is SELECTED_FRAME OK here? */
+      struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
       if (rif && rif->destroy_fringe_bitmap)
 	rif->destroy_fringe_bitmap (n);
       xfree (*fbp);
@@ -1172,6 +1175,9 @@

   if (!once_p)
     {
+      /* XXX Is SELECTED_FRAME OK here? */
+      struct redisplay_interface *rif = FRAME_RIF (SELECTED_FRAME ());
+
       destroy_fringe_bitmap (which);

       if (rif && rif->define_fringe_bitmap)
@@ -1367,7 +1373,6 @@
      Lisp_Object pos, window;
 {
   struct window *w;
-  struct buffer *old_buffer = NULL;
   struct glyph_row *row;
   int textpos;
--- a/src/indent.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/indent.c	Mon Oct 25 18:17:28 2004 +0000
@@ -20,6 +20,8 @@
 Boston, MA 02111-1307, USA.  */

 #include <config.h>
+#include <stdio.h>
+
 #include "lisp.h"
 #include "buffer.h"
 #include "charset.h"
--- a/src/intervals.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/intervals.h	Mon Oct 25 18:17:28 2004 +0000
@@ -85,7 +85,7 @@
 			 || STRINGP ((Lisp_Object){(EMACS_INT)(i)}))
 #endif
 #define NULL_INTERVAL_P(i) \
-   (CHECK (!INT_LISPLIKE (i), "non-interval"), (i) == NULL_INTERVAL)
+  ((void)CHECK (!INT_LISPLIKE (i), "non-interval"), (i) == NULL_INTERVAL)
 /* old #define NULL_INTERVAL_P(i) ((i) == NULL_INTERVAL || INT_LISPLIKE (i)) */

 /* True if this interval has no right child. */
@@ -289,6 +289,7 @@
 extern INLINE void copy_intervals_to_string P_ ((Lisp_Object, struct buffer *,
 						 int, int));
 extern INTERVAL copy_intervals P_ ((INTERVAL, int, int));
+extern int compare_string_intervals P_ ((Lisp_Object s1, Lisp_Object s2));
 extern Lisp_Object textget P_ ((Lisp_Object, Lisp_Object));
 extern Lisp_Object lookup_char_property P_ ((Lisp_Object, Lisp_Object, int));
 extern void move_if_not_intangible P_ ((int));
--- a/src/keyboard.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/keyboard.c	Mon Oct 25 18:17:28 2004 +0000
@@ -22,13 +22,13 @@
 #include <config.h>
 #include <signal.h>
 #include <stdio.h>
+#include "lisp.h"
 #include "termchar.h"
 #include "termopts.h"
-#include "lisp.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "macros.h"
 #include "keyboard.h"
-#include "frame.h"
 #include "window.h"
 #include "commands.h"
 #include "buffer.h"
@@ -55,7 +55,6 @@
 #endif /* not MSDOS */

 #include "syssignal.h"
-#include "systty.h"

 #include <sys/types.h>
 #ifdef HAVE_UNISTD_H
@@ -89,9 +88,6 @@
 int interrupt_input_pending;


-/* File descriptor to use for input.  */
-extern int input_fd;
-
 #ifdef HAVE_WINDOW_SYSTEM
 /* Make all keyboard buffers much bigger when using X windows.  */
 #ifdef MAC_OS8
@@ -466,11 +462,6 @@
 /* Nonzero if input is available.  */
 int input_pending;

-/* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
-   keep 0200 bit in input chars.  0 to ignore the 0200 bit.  */
-
-int meta_key;
-
 /* Non-zero means force key bindings update in parse_menu_item.  */

 int update_menu_bindings;
@@ -597,9 +588,6 @@
 /* Nonzero while interrupts are temporarily deferred during redisplay.  */
 int interrupts_deferred;

-/* Nonzero means use ^S/^Q for flow control.  */
-int flow_control;
-
 /* Allow m- file to inhibit use of FIONREAD.  */
 #ifdef BROKEN_FIONREAD
 #undef FIONREAD
@@ -676,6 +664,7 @@
 static void clear_event P_ ((struct input_event *));
 static void any_kboard_state P_ ((void));
 static SIGTYPE interrupt_signal P_ ((int signalnum));
+static void handle_interrupt P_ ((void));
 static void timer_start_idle P_ ((void));
 static void timer_stop_idle P_ ((void));
 static void timer_resume_idle P_ ((void));
@@ -1225,9 +1214,7 @@
   if (!sf->glyphs_initialized_p
       /* This is the case of the frame dumped with Emacs, when we're
 	 running under a window system.  */
-      || (!NILP (Vwindow_system)
-	  && !inhibit_window_system
-	  && FRAME_TERMCAP_P (sf))
+      || FRAME_INITIAL_P (sf)
       || noninteractive)
     {
       stream = Qexternal_debugging_output;
@@ -1281,10 +1268,10 @@
     while (1)
       {
 	internal_catch (Qtop_level, top_level_1, Qnil);
-	/* Reset single_kboard in case top-level set it while
-	   evaluating an -f option, or we are stuck there for some
-	   other reason.  */
-	any_kboard_state ();
+        /* Reset single_kboard in case top-level set it while
+           evaluating an -f option, or we are stuck there for some
+           other reason. */
+        any_kboard_state ();
 	internal_catch (Qtop_level, command_loop_2, Qnil);
 	executing_macro = Qnil;

@@ -1399,12 +1386,12 @@
   Lisp_Object keybuf[30];
   int i;
   int no_direct;
-  int prev_modiff;
+  int prev_modiff = 0;
   struct buffer *prev_buffer = NULL;
 #ifdef MULTI_KBOARD
   int was_locked = single_kboard;
 #endif
-  int already_adjusted;
+  int already_adjusted = 0;

   current_kboard->Vprefix_arg = Qnil;
   current_kboard->Vlast_prefix_arg = Qnil;
@@ -2112,7 +2099,10 @@
 start_polling ()
 {
 #ifdef POLL_FOR_INPUT
-  if (read_socket_hook && !interrupt_input)
+  /* XXX This condition was (read_socket_hook && !interrupt_input),
+     but read_socket_hook is not global anymore.  Let's pretend that
+     it's always set. */
+  if (!interrupt_input)
     {
       /* Turn alarm handling on unconditionally.  It might have
 	 been turned off in process.c.  */
@@ -2146,7 +2136,10 @@
 input_polling_used ()
 {
 #ifdef POLL_FOR_INPUT
-  return read_socket_hook && !interrupt_input;
+  /* XXX This condition was (read_socket_hook && !interrupt_input),
+     but read_socket_hook is not global anymore.  Let's pretend that
+     it's always set. */
+  return !interrupt_input;
 #else
   return 0;
 #endif
@@ -2158,7 +2151,10 @@
 stop_polling ()
 {
 #ifdef POLL_FOR_INPUT
-  if (read_socket_hook && !interrupt_input)
+  /* XXX This condition was (read_socket_hook && !interrupt_input),
+     but read_socket_hook is not global anymore.  Let's pretend that
+     it's always set. */
+  if (!interrupt_input)
     ++poll_suppress_count;
 #endif
 }
@@ -3670,7 +3666,7 @@
 	  }

 	  last_event_timestamp = event->timestamp;
-	  interrupt_signal (0 /* dummy */);
+	  handle_interrupt ();
 	  return;
 	}

@@ -4141,7 +4137,11 @@
 	 If there is no valid info, it does not store anything
 	 so x remains nil.  */
       x = Qnil;
-      (*mouse_position_hook) (&f, 0, &bar_window, &part, &x, &y, &time);
+
+      /* XXX Can f or mouse_position_hook be NULL here? */
+      if (f && FRAME_DISPLAY (f)->mouse_position_hook)
+        (*FRAME_DISPLAY (f)->mouse_position_hook) (&f, 0, &bar_window,
+                                                   &part, &x, &y, &time);

       obj = Qnil;

@@ -6309,8 +6309,8 @@
 	{
 	  int len = SBYTES (name_alist_or_stem);
 	  char *buf = (char *) alloca (len + 50);
-	  sprintf (buf, "%s-%ld", SDATA (name_alist_or_stem),
-		   (long) XINT (symbol_int) + 1);
+          sprintf (buf, "%s-%ld", SDATA (name_alist_or_stem),
+                   (long) XINT (symbol_int) + 1);
 	  value = intern (buf);
 	}
       else if (name_table != 0 && name_table[symbol_num])
@@ -6589,7 +6589,10 @@
     }
   else
 #ifdef POLL_FOR_INPUT
-  if (read_socket_hook && !interrupt_input && poll_suppress_count == 0)
+  /* XXX This condition was (read_socket_hook && !interrupt_input),
+     but read_socket_hook is not global anymore.  Let's pretend that
+     it's always set. */
+  if (!interrupt_input && poll_suppress_count == 0)
     {
       SIGMASKTYPE mask;
       mask = sigblock (sigmask (SIGALRM));
@@ -6666,147 +6669,215 @@
 read_avail_input (expected)
      int expected;
 {
-  register int i;
   int nread = 0;
-
-  if (read_socket_hook)
-    {
-      int discard = 0;
-      int nr;
-      struct input_event hold_quit;
-
-      EVENT_INIT (hold_quit);
-      hold_quit.kind = NO_EVENT;
-
-      /* No need for FIONREAD or fcntl; just say don't wait.  */
-      while (nr = (*read_socket_hook) (input_fd, expected, &hold_quit), nr > 0)
-	{
-	  nread += nr;
-	  expected = 0;
-	}
-      if (hold_quit.kind != NO_EVENT)
-	kbd_buffer_store_event (&hold_quit);
-    }
-  else
-    {
-      /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
-	 the kbd_buffer can really hold.  That may prevent loss
-	 of characters on some systems when input is stuffed at us.  */
-      unsigned char cbuf[KBD_BUFFER_SIZE - 1];
-      int n_to_read;
-
-      /* Determine how many characters we should *try* to read.  */
+  int err = 0;
+  struct display *d;
+
+  /* Loop through the available displays, and call their input hooks. */
+  d = display_list;
+  while (d)
+    {
+      struct display *next = d->next_display;
+
+      if (d->read_socket_hook)
+        {
+          int nr;
+
+          struct input_event hold_quit;
+
+          EVENT_INIT (hold_quit);
+          hold_quit.kind = NO_EVENT;
+
+          /* No need for FIONREAD or fcntl; just say don't wait.  */
+          while (nr = (*d->read_socket_hook) (d, expected, &hold_quit), nr > 0)
+            {
+              nread += nr;
+              expected = 0;
+            }
+
+          if (nr == -1)          /* Not OK to read input now. */
+            {
+              err = 1;
+            }
+          else if (nr == -2)          /* Non-transient error. */
+            {
+              /* The display device terminated; it should be closed. */
+
+              /* Kill Emacs if this was our last display. */
+              if (! display_list->next_display)
+                /* Formerly simply reported no input, but that
+                   sometimes led to a failure of Emacs to terminate.
+                   SIGHUP seems appropriate if we can't reach the
+                   terminal.  */
+                /* ??? Is it really right to send the signal just to
+                   this process rather than to the whole process
+                   group?  Perhaps on systems with FIONREAD Emacs is
+                   alone in its group.  */
+                kill (getpid (), SIGHUP);
+
+              /* XXX Is calling delete_display safe here?  It calls Fdelete_frame. */
+              if (d->delete_display_hook)
+                (*d->delete_display_hook) (d);
+              else
+                delete_display (d);
+            }
+
+          if (hold_quit.kind != NO_EVENT)
+            kbd_buffer_store_event (&hold_quit);
+        }
+
+      d = next;
+    }
+
+  if (err && !nread)
+    nread = -1;
+
+  return nread;
+}
+
+/* This is the tty way of reading available input.
+
+   Note that each terminal device has its own `struct display' object,
+   and so this function is called once for each individual termcap
+   display.  The first parameter indicates which device to read from.  */
+
+int
+tty_read_avail_input (struct display *display,
+                      int expected,
+                      struct input_event *hold_quit)
+{
+  /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
+     the kbd_buffer can really hold.  That may prevent loss
+     of characters on some systems when input is stuffed at us.  */
+  unsigned char cbuf[KBD_BUFFER_SIZE - 1];
+  int n_to_read, i;
+  struct tty_display_info *tty = display->display_info.tty;
+  int nread = 0;
+
+  if (display->type != output_termcap)
+    abort ();
+
+  /* XXX I think the following code should be moved to separate hook
+     functions in system-dependent files. */
 #ifdef WINDOWSNT
-      return 0;
+  return 0;
 #else /* not WINDOWSNT */
 #ifdef MSDOS
-      n_to_read = dos_keysns ();
-      if (n_to_read == 0)
-	return 0;
+  n_to_read = dos_keysns ();
+  if (n_to_read == 0)
+    return 0;
+
+  cbuf[0] = dos_keyread ();
+  nread = 1;
+
 #else /* not MSDOS */
+
+  if (! tty->term_initted)      /* In case we get called during bootstrap. */
+    return 0;
+
+  if (! tty->input)
+    return 0;                   /* The terminal is suspended. */
+
+  /* Determine how many characters we should *try* to read.  */
 #ifdef FIONREAD
-      /* Find out how much input is available.  */
-      if (ioctl (input_fd, FIONREAD, &n_to_read) < 0)
-	/* Formerly simply reported no input, but that sometimes led to
-	   a failure of Emacs to terminate.
-	   SIGHUP seems appropriate if we can't reach the terminal.  */
-	/* ??? Is it really right to send the signal just to this process
-	   rather than to the whole process group?
-	   Perhaps on systems with FIONREAD Emacs is alone in its group.  */
-	{
-	  if (! noninteractive)
-	    kill (getpid (), SIGHUP);
-	  else
-	    n_to_read = 0;
-	}
-      if (n_to_read == 0)
-	return 0;
-      if (n_to_read > sizeof cbuf)
-	n_to_read = sizeof cbuf;
+  /* Find out how much input is available.  */
+  if (ioctl (fileno (tty->input), FIONREAD, &n_to_read) < 0)
+    {
+      if (! noninteractive)
+        return -2;          /* Close this display. */
+      else
+        n_to_read = 0;
+    }
+  if (n_to_read == 0)
+    return 0;
+  if (n_to_read > sizeof cbuf)
+    n_to_read = sizeof cbuf;
 #else /* no FIONREAD */
 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
-      /* Read some input if available, but don't wait.  */
-      n_to_read = sizeof cbuf;
-      fcntl (input_fd, F_SETFL, O_NDELAY);
-#else
-      you lose;
-#endif
-#endif
-#endif /* not MSDOS */
-#endif /* not WINDOWSNT */
-
-      /* Now read; for one reason or another, this will not block.
-	 NREAD is set to the number of chars read.  */
-      do
-	{
-#ifdef MSDOS
-	  cbuf[0] = dos_keyread ();
-	  nread = 1;
+  /* Read some input if available, but don't wait.  */
+  n_to_read = sizeof cbuf;
+  fcntl (fileno (tty->input), F_SETFL, O_NDELAY);
 #else
-	  nread = emacs_read (input_fd, cbuf, n_to_read);
-#endif
-	  /* POSIX infers that processes which are not in the session leader's
-	     process group won't get SIGHUP's at logout time.  BSDI adheres to
-	     this part standard and returns -1 from read (0) with errno==EIO
-	     when the control tty is taken away.
-	     Jeffrey Honig <jch@bsdi.com> says this is generally safe.  */
-	  if (nread == -1 && errno == EIO)
-	    kill (0, SIGHUP);
+  you lose;
+#endif
+#endif
+
+  /* Now read; for one reason or another, this will not block.
+     NREAD is set to the number of chars read.  */
+  do
+    {
+      nread = emacs_read (fileno (tty->input), cbuf, n_to_read);
+      /* POSIX infers that processes which are not in the session leader's
+         process group won't get SIGHUP's at logout time.  BSDI adheres to
+         this part standard and returns -1 from read (0) with errno==EIO
+         when the control tty is taken away.
+         Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
+      if (nread == -1 && errno == EIO)
+        return -2;          /* Close this display. */
 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
-	  /* The kernel sometimes fails to deliver SIGHUP for ptys.
-	     This looks incorrect, but it isn't, because _BSD causes
-	     O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
-	     and that causes a value other than 0 when there is no input.  */
-	  if (nread == 0)
-	    kill (0, SIGHUP);
-#endif
-	}
-      while (
-	     /* We used to retry the read if it was interrupted.
-		But this does the wrong thing when O_NDELAY causes
-		an EAGAIN error.  Does anybody know of a situation
-		where a retry is actually needed?  */
+      /* The kernel sometimes fails to deliver SIGHUP for ptys.
+         This looks incorrect, but it isn't, because _BSD causes
+         O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
+         and that causes a value other than 0 when there is no input.  */
+      if (nread == 0)
+        return -2;          /* Close this display. */
+#endif
+    }
+  while (
+         /* We used to retry the read if it was interrupted.
+            But this does the wrong thing when O_NDELAY causes
+            an EAGAIN error.  Does anybody know of a situation
+            where a retry is actually needed?  */
 #if 0
-	     nread < 0 && (errno == EAGAIN
+         nread < 0 && (errno == EAGAIN
 #ifdef EFAULT
-			   || errno == EFAULT
+                       || errno == EFAULT
 #endif
 #ifdef EBADSLT
-			   || errno == EBADSLT
-#endif
-			   )
+                       || errno == EBADSLT
+#endif
+                       )
 #else
-	     0
-#endif
-	     );
+         0
+#endif
+         );

 #ifndef FIONREAD
 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
-      fcntl (input_fd, F_SETFL, 0);
+  fcntl (fileno (tty->input), F_SETFL, 0);
 #endif /* USG or DGUX or CYGWIN */
 #endif /* no FIONREAD */
-      for (i = 0; i < nread; i++)
-	{
-	  struct input_event buf;
-	  EVENT_INIT (buf);
-	  buf.kind = ASCII_KEYSTROKE_EVENT;
-	  buf.modifiers = 0;
-	  if (meta_key == 1 && (cbuf[i] & 0x80))
-	    buf.modifiers = meta_modifier;
-	  if (meta_key != 2)
-	    cbuf[i] &= ~0x80;
-
-	  buf.code = cbuf[i];
-	  buf.frame_or_window = selected_frame;
-	  buf.arg = Qnil;
-
-	  kbd_buffer_store_event (&buf);
-	  /* Don't look at input that follows a C-g too closely.
-	     This reduces lossage due to autorepeat on C-g.  */
-	  if (buf.kind == ASCII_KEYSTROKE_EVENT
-	      && buf.code == quit_char)
-	    break;
-	}
+
+  if (nread <= 0)
+    return nread;
+
+#endif /* not MSDOS */
+#endif /* not WINDOWSNT */
+
+  for (i = 0; i < nread; i++)
+    {
+      struct input_event buf;
+      EVENT_INIT (buf);
+      buf.kind = ASCII_KEYSTROKE_EVENT;
+      buf.modifiers = 0;
+      if (tty->meta_key == 1 && (cbuf[i] & 0x80))
+        buf.modifiers = meta_modifier;
+      if (tty->meta_key != 2)
+        cbuf[i] &= ~0x80;
+
+      buf.code = cbuf[i];
+      /* Set the frame corresponding to the active tty.  Note that the
+         value of selected_frame is not reliable here, redisplay tends
+         to temporarily change it. */
+      buf.frame_or_window = tty->top_frame;
+      buf.arg = Qnil;
+
+      kbd_buffer_store_event (&buf);
+      /* Don't look at input that follows a C-g too closely.
+         This reduces lossage due to autorepeat on C-g.  */
+      if (buf.kind == ASCII_KEYSTROKE_EVENT
+          && buf.code == quit_char)
+        break;
     }

   return nread;
@@ -9902,8 +9973,12 @@
 	 from an idle timer function.  The symptom of the bug is that
 	 the cursor sometimes doesn't become visible until the next X
 	 event is processed.  --gerd.  */
-      if (rif)
-	rif->flush_display (NULL);
+      {
+        Lisp_Object tail, frame;
+        FOR_EACH_FRAME (tail, frame)
+          if (FRAME_RIF (XFRAME (frame)))
+            FRAME_RIF (XFRAME (frame))->flush_display (XFRAME (frame));
+      }
     }

   return input_pending;
@@ -10145,6 +10220,9 @@
   int width, height;
   struct gcpro gcpro1;

+  if (tty_list && tty_list->next)
+    error ("There are other tty frames open; close them before suspending Emacs");
+
   if (!NILP (stuffstring))
     CHECK_STRING (stuffstring);

@@ -10153,11 +10231,11 @@
     call1 (Vrun_hooks, intern ("suspend-hook"));

   GCPRO1 (stuffstring);
-  get_frame_size (&old_width, &old_height);
-  reset_sys_modes ();
+  get_tty_size (fileno (CURTTY ()->input), &old_width, &old_height);
+  reset_all_sys_modes ();
   /* sys_suspend can get an error if it tries to fork a subshell
      and the system resources aren't available for that.  */
-  record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_sys_modes,
+  record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object))) init_all_sys_modes,
 			 Qnil);
   stuff_buffered_input (stuffstring);
   if (cannot_suspend)
@@ -10169,7 +10247,7 @@
   /* Check if terminal/window size has changed.
      Note that this is not useful when we are running directly
      with a window system; but suspend should be disabled in that case.  */
-  get_frame_size (&width, &height);
+  get_tty_size (fileno (CURTTY ()->input), &width, &height);
   if (width != old_width || height != old_height)
     change_frame_size (SELECTED_FRAME (), height, width, 0, 0, 0);

@@ -10229,10 +10307,10 @@
 {
   input_available_clear_time = time_to_clear;

-  /* Tell interrupt_signal to throw back to read_char,  */
+  /* Tell handle_interrupt to throw back to read_char,  */
   waiting_for_input = 1;

-  /* If interrupt_signal was called before and buffered a C-g,
+  /* If handle_interrupt was called before and buffered a C-g,
      make it run again now, to avoid timing error. */
   if (!NILP (Vquit_flag))
     quit_throw_to_read_char ();
@@ -10241,45 +10319,76 @@
 void
 clear_waiting_for_input ()
 {
-  /* Tell interrupt_signal not to throw back to read_char,  */
+  /* Tell handle_interrupt not to throw back to read_char,  */
   waiting_for_input = 0;
   input_available_clear_time = 0;
 }

+/* The SIGINT handler.
+
+   If we have a frame on the controlling tty, the SIGINT was generated
+   by C-g, so we call handle_interrupt.  Otherwise, the handler kills
+   Emacs.  */
+
+static SIGTYPE
+interrupt_signal (signalnum)	/* If we don't have an argument, */
+     int signalnum;		/* some compilers complain in signal calls. */
+{
+  /* Must preserve main program's value of errno.  */
+  int old_errno = errno;
+  struct display *display;
+
+#if defined (USG) && !defined (POSIX_SIGNALS)
+  /* USG systems forget handlers when they are used;
+     must reestablish each time */
+  signal (SIGINT, interrupt_signal);
+  signal (SIGQUIT, interrupt_signal);
+#endif /* USG */
+
+  /* See if we have an active display on our controlling terminal. */
+  display = get_named_tty_display (NULL);
+  if (!display)
+    {
+      /* If there are no frames there, let's pretend that we are a
+         well-behaving UN*X program and quit. */
+      fatal_error_signal (SIGTERM);
+    }
+  else
+    {
+      /* Otherwise, the SIGINT was probably generated by C-g.  */
+
+      /* Set internal_last_event_frame to the top frame of the
+         controlling tty, if we have a frame there.  We disable the
+         interrupt key on secondary ttys, so the SIGINT must have come
+         from the controlling tty.  */
+      internal_last_event_frame = display->display_info.tty->top_frame;
+
+      handle_interrupt ();
+    }
+
+  errno = old_errno;
+}
+
 /* This routine is called at interrupt level in response to C-g.

-   If interrupt_input, this is the handler for SIGINT.  Otherwise, it
-   is called from kbd_buffer_store_event, in handling SIGIO or
-   SIGTINT.
+   It is called from the SIGINT handler or kbd_buffer_store_event.

    If `waiting_for_input' is non zero, then unless `echoing' is
    nonzero, immediately throw back to read_char.

    Otherwise it sets the Lisp variable quit-flag not-nil.  This causes
    eval to throw, when it gets a chance.  If quit-flag is already
-   non-nil, it stops the job right away.  */
-
-static SIGTYPE
-interrupt_signal (signalnum)	/* If we don't have an argument, */
-     int signalnum;		/* some compilers complain in signal calls. */
+   non-nil, it stops the job right away. */
+
+static void
+handle_interrupt ()
 {
   char c;
-  /* Must preserve main program's value of errno.  */
-  int old_errno = errno;
   struct frame *sf = SELECTED_FRAME ();

-#if defined (USG) && !defined (POSIX_SIGNALS)
-  if (!read_socket_hook && NILP (Vwindow_system))
-    {
-      /* USG systems forget handlers when they are used;
-	 must reestablish each time */
-      signal (SIGINT, interrupt_signal);
-      signal (SIGQUIT, interrupt_signal);
-    }
-#endif /* USG */
-
   cancel_echoing ();

+  /* XXX This code needs to be revised for multi-tty support. */
   if (!NILP (Vquit_flag)
       && (FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf)))
     {
@@ -10289,7 +10398,7 @@
       sigblock (sigmask (SIGINT));

       fflush (stdout);
-      reset_sys_modes ();
+      reset_all_sys_modes ();

 #ifdef SIGTSTP			/* Support possible in later USG versions */
 /*
@@ -10368,7 +10477,7 @@
       printf ("Continuing...\n");
 #endif /* not MSDOS */
       fflush (stdout);
-      init_sys_modes ();
+      init_all_sys_modes ();
       sigfree ();
     }
   else
@@ -10396,9 +10505,7 @@
     }

   if (waiting_for_input && !echoing)
-    quit_throw_to_read_char ();
-
-  errno = old_errno;
+      quit_throw_to_read_char ();
 }

 /* Handle a C-g by making read_char return C-g.  */
@@ -10445,6 +10552,11 @@
      (interrupt, flow, meta, quit)
      Lisp_Object interrupt, flow, meta, quit;
 {
+  /* XXX This function needs to be revised for multi-device support.
+     Currently it compiles fine, but its semantics are wrong.  It sets
+     global parameters (e.g. interrupt_input) based on only the
+     current frame's device. */
+
   if (!NILP (quit)
       && (!INTEGERP (quit) || XINT (quit) < 0 || XINT (quit) > 0400))
     error ("set-input-mode: QUIT must be an ASCII character");
@@ -10455,12 +10567,12 @@

 #ifndef DOS_NT
   /* this causes startup screen to be restored and messes with the mouse */
-  reset_sys_modes ();
+  reset_all_sys_modes ();
 #endif

 #ifdef SIGIO
 /* Note SIGIO has been undef'd if FIONREAD is missing.  */
-  if (read_socket_hook)
+  if (FRAME_DISPLAY (SELECTED_FRAME ())->read_socket_hook)
     {
       /* When using X, don't give the user a real choice,
 	 because we haven't implemented the mechanisms to support it.  */
@@ -10481,19 +10593,24 @@
   interrupt_input = 1;
 #endif

-  flow_control = !NILP (flow);
-  if (NILP (meta))
-    meta_key = 0;
-  else if (EQ (meta, Qt))
-    meta_key = 1;
-  else
-    meta_key = 2;
+  if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
+    {
+      struct tty_display_info *tty = CURTTY ();
+      tty->flow_control = !NILP (flow);
+      if (NILP (meta))
+        tty->meta_key = 0;
+      else if (EQ (meta, Qt))
+        tty->meta_key = 1;
+      else
+        tty->meta_key = 2;
+    }
+
   if (!NILP (quit))
     /* Don't let this value be out of range.  */
-    quit_char = XINT (quit) & (meta_key ? 0377 : 0177);
+    quit_char = XINT (quit) & (NILP (meta) ? 0177 : 0377);

 #ifndef DOS_NT
-  init_sys_modes ();
+  init_all_sys_modes ();
 #endif

 #ifdef POLL_FOR_INPUT
@@ -10520,10 +10637,21 @@
      ()
 {
   Lisp_Object val[4];
+  struct frame *sf = XFRAME (selected_frame);

   val[0] = interrupt_input ? Qt : Qnil;
-  val[1] = flow_control ? Qt : Qnil;
-  val[2] = meta_key == 2 ? make_number (0) : meta_key == 1 ? Qt : Qnil;
+  if (FRAME_TERMCAP_P (sf))
+    {
+      val[1] = FRAME_TTY (sf)->flow_control ? Qt : Qnil;
+      val[2] = (FRAME_TTY (sf)->meta_key == 2
+                ? make_number (0)
+                : (CURTTY ()->meta_key == 1 ? Qt : Qnil));
+    }
+  else
+    {
+      val[1] = Qnil;
+      val[2] = Qt;
+    }
   XSETFASTINT (val[3], quit_char);

   return Flist (sizeof (val) / sizeof (val[0]), val);
@@ -10686,8 +10814,14 @@
   wipe_kboard (current_kboard);
   init_kboard (current_kboard);

-  if (!noninteractive && !read_socket_hook && NILP (Vwindow_system))
-    {
+  if (!noninteractive)
+    {
+      /* Before multi-tty support, these handlers used to be installed
+         only if the current session was a tty session.  Now an Emacs
+         session may have multiple display types, so we always handle
+         SIGINT.  There is special code in interrupt_signal to exit
+         Emacs on SIGINT when there are no termcap frames on the
+         controlling terminal. */
       signal (SIGINT, interrupt_signal);
 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
       /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
--- a/src/keyboard.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/keyboard.h	Mon Oct 25 18:17:28 2004 +0000
@@ -21,7 +21,7 @@
 /* Length of echobuf field in each KBOARD.  */

 /* Each KBOARD represents one logical input stream from which Emacs gets input.
-   If we are using an ordinary terminal, it has one KBOARD object.
+   If we are using ordinary terminals, it has one KBOARD object for each terminal device.
    Usually each X display screen has its own KBOARD,
    but when two of them are on the same X server,
    we assume they share a keyboard and give them one KBOARD in common.
@@ -152,7 +152,7 @@
   };

 #ifdef MULTI_KBOARD
-/* Temporarily used before a frame has been opened, and for termcap frames */
+/* Temporarily used before a frame has been opened. */
 extern KBOARD *initial_kboard;

 /* In the single-kboard state, this is the kboard
@@ -341,5 +341,8 @@
 extern Lisp_Object menu_item_eval_property P_ ((Lisp_Object));
 extern int  kbd_buffer_events_waiting P_ ((int));

+extern int tty_read_avail_input P_ ((struct display *, int,
+                                     struct input_event *));
+
 /* arch-tag: 769cbade-1ba9-4950-b886-db265b061aa3
    (do not change this comment) */
--- a/src/keymap.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/keymap.c	Mon Oct 25 18:17:28 2004 +0000
@@ -27,6 +27,7 @@
 #include "buffer.h"
 #include "charset.h"
 #include "keyboard.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "blockinput.h"
 #include "puresize.h"
--- a/src/lisp.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/lisp.h	Mon Oct 25 18:17:28 2004 +0000
@@ -63,14 +63,14 @@

 #ifdef ENABLE_CHECKING

-#define CHECK(check,msg) (((check) || suppress_checking		\
-			   ? (void) 0				\
-			   : die ((msg), __FILE__, __LINE__)),	\
+#define CHECK(check,msg) ((void)((check) || suppress_checking           \
+                                 ? (void) 0                             \
+                                 : die ((msg), __FILE__, __LINE__)),	\
 			  0)
 #else

 /* Produce same side effects and result, but don't complain.  */
-#define CHECK(check,msg) ((check),0)
+#define CHECK(check,msg) ((void)(check),0)

 #endif

@@ -3048,26 +3048,28 @@
 EXFUN (Fx_popup_dialog, 2);
 extern void syms_of_xmenu P_ ((void));

+/* defined in termchar.h */
+struct tty_display_info;
+
+/* defined in termhooks.h */
+struct display;
+
 /* defined in sysdep.c */
 extern void stuff_char P_ ((char c));
 extern void init_sigio P_ ((int));
-extern void request_sigio P_ ((void));
-extern void unrequest_sigio P_ ((void));
-extern void reset_sys_modes P_ ((void));
 extern void sys_subshell P_ ((void));
 extern void sys_suspend P_ ((void));
 extern void discard_tty_input P_ ((void));
-extern void init_sys_modes P_ ((void));
-extern void reset_sys_modes P_ ((void));
-extern void get_frame_size P_ ((int *, int *));
+extern void init_sys_modes P_ ((struct tty_display_info *));
+extern void reset_sys_modes P_ ((struct tty_display_info *));
+extern void init_all_sys_modes P_ ((void));
+extern void reset_all_sys_modes P_ ((void));
 extern void wait_for_termination P_ ((int));
 extern void flush_pending_output P_ ((int));
 extern void child_setup_tty P_ ((int));
 extern void setup_pty P_ ((int));
 extern int set_window_size P_ ((int, int, int));
 extern void create_process P_ ((Lisp_Object, char **, Lisp_Object));
-extern int tabs_safe_p P_ ((void));
-extern void init_baud_rate P_ ((void));
 extern int emacs_open P_ ((const char *, int, int));
 extern int emacs_close P_ ((int));
 extern int emacs_read P_ ((int, char *, unsigned int));
--- a/src/lread.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/lread.c	Mon Oct 25 18:17:28 2004 +0000
@@ -33,6 +33,7 @@
 #include <epaths.h>
 #include "commands.h"
 #include "keyboard.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "coding.h"
--- a/src/macterm.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/macterm.c	Mon Oct 25 18:17:28 2004 +0000
@@ -9166,12 +9166,13 @@
   redeem_scroll_bar_hook = XTredeem_scroll_bar;
   judge_scroll_bars_hook = XTjudge_scroll_bars;

-  scroll_region_ok = 1;         /* we'll scroll partial frames */
-  char_ins_del_ok = 1;
-  line_ins_del_ok = 1;          /* we'll just blt 'em */
-  fast_clear_end_of_line = 1;   /* X does this well */
-  memory_below_frame = 0;       /* we don't remember what scrolls
-				   off the bottom */
+  TTY_SCROLL_REGION_OK (CURTTY ()) = 1; /* we'll scroll partial frames */
+  TTY_CHAR_INS_DEL_OK (CURTTY ()) = 1;
+  TTY_LINE_INS_DEL_OK (CURTTY ()) = 1; /* we'll just blt 'em */
+  TTY_FAST_CLEAR_END_OF_LINE (CURTTY ()) = 1; /* X does this well */
+  TTY_MEMORY_BELOW_FRAME (CURTTY ()) = 0; /* we don't remember what
+                                                         scrolls off the
+                                                         bottom */
   baud_rate = 19200;

   x_noop_count = 0;
--- a/src/macterm.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/macterm.h	Mon Oct 25 18:17:28 2004 +0000
@@ -399,9 +399,6 @@
 #define FRAME_MAC_WINDOW(f) ((f)->output_data.mac->mWP)
 #define FRAME_X_WINDOW(f) ((f)->output_data.mac->mWP)

-#define FRAME_FOREGROUND_PIXEL(f) ((f)->output_data.x->foreground_pixel)
-#define FRAME_BACKGROUND_PIXEL(f) ((f)->output_data.x->background_pixel)
-
 #define FRAME_FONT(f) ((f)->output_data.mac->font)
 #define FRAME_FONTSET(f) ((f)->output_data.mac->fontset)
--- a/src/minibuf.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/minibuf.c	Mon Oct 25 18:17:28 2004 +0000
@@ -34,6 +34,7 @@
 #include "syntax.h"
 #include "intervals.h"
 #include "keymap.h"
+#include "termhooks.h"

 extern int quit_char;

@@ -706,8 +707,12 @@
       XWINDOW (minibuf_window)->cursor.x = 0;
       XWINDOW (minibuf_window)->must_be_updated_p = 1;
       update_frame (XFRAME (selected_frame), 1, 1);
-      if (rif && rif->flush_display)
-	rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame));
+      {
+        struct frame *f = XFRAME (XWINDOW (minibuf_window)->frame);
+        struct redisplay_interface *rif = FRAME_RIF (f);
+        if (rif && rif->flush_display)
+          rif->flush_display (f);
+      }
     }

   /* Make minibuffer contents into a string.  */
--- a/src/msdos.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/msdos.c	Mon Oct 25 18:17:28 2004 +0000
@@ -2583,7 +2583,7 @@
   set_terminal_modes_hook = IT_set_terminal_modes;
   reset_terminal_modes_hook = IT_reset_terminal_modes;
   set_terminal_window_hook = IT_set_terminal_window;
-  char_ins_del_ok = 0;
+  TTY_CHAR_INS_DEL_OK (CURTTY ()) = 0;
 #endif
 }

@@ -4880,7 +4880,7 @@
      char *badfunc;
 {
   fprintf (stderr, "%s not yet implemented\r\n", badfunc);
-  reset_sys_modes ();
+  reset_all_sys_modes ();
   exit (1);
 }
--- a/src/process.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/process.c	Mon Oct 25 18:17:28 2004 +0000
@@ -126,11 +126,11 @@
 #include "charset.h"
 #include "coding.h"
 #include "process.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "termopts.h"
 #include "commands.h"
 #include "keyboard.h"
-#include "frame.h"
 #include "blockinput.h"
 #include "dispextern.h"
 #include "composite.h"
@@ -302,11 +302,11 @@

 static SELECT_TYPE input_wait_mask;

-/* Mask that excludes keyboard input descriptor (s).  */
+/* Mask that excludes keyboard input descriptor(s).  */

 static SELECT_TYPE non_keyboard_wait_mask;

-/* Mask that excludes process input descriptor (s).  */
+/* Mask that excludes process input descriptor(s).  */

 static SELECT_TYPE non_process_wait_mask;

@@ -6555,20 +6555,12 @@


-/* The first time this is called, assume keyboard input comes from DESC
-   instead of from where we used to expect it.
-   Subsequent calls mean assume input keyboard can come from DESC
-   in addition to other places.  */
-
-static int add_keyboard_wait_descriptor_called_flag;
+/* Add DESC to the set of keyboard input descriptors.  */

 void
 add_keyboard_wait_descriptor (desc)
      int desc;
 {
-  if (! add_keyboard_wait_descriptor_called_flag)
-    FD_CLR (0, &input_wait_mask);
-  add_keyboard_wait_descriptor_called_flag = 1;
   FD_SET (desc, &input_wait_mask);
   FD_SET (desc, &non_process_wait_mask);
   if (desc > max_keyboard_desc)
@@ -6633,7 +6625,12 @@
   process_output_skip = 0;
 #endif

+  /* Don't do this, it caused infinite select loops.  The display
+     method should call add_keyboard_wait_descriptor on stdin if it
+     needs that.  */
+#if 0
   FD_SET (0, &input_wait_mask);
+#endif

   Vprocess_alist = Qnil;
   for (i = 0; i < MAXDESC; i++)
--- a/src/scroll.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/scroll.c	Mon Oct 25 18:17:28 2004 +0000
@@ -22,12 +22,13 @@
 #include <config.h>
 #include <stdio.h>
 #include <string.h>
+#include "lisp.h"
 #include "termchar.h"
-#include "lisp.h"
 #include "dispextern.h"
 #include "keyboard.h"
 #include "frame.h"
 #include "window.h"
+#include "termhooks.h"

 /* All costs measured in characters.
    So no cost can exceed the area of a frame, measured in characters.
@@ -57,10 +58,12 @@
     unsigned char writecount;
   };

-static void do_direct_scrolling P_ ((struct glyph_matrix *,
+static void do_direct_scrolling P_ ((struct frame *,
+                                     struct glyph_matrix *,
 				     struct matrix_elt *,
 				     int, int));
-static void do_scrolling P_ ((struct glyph_matrix *,
+static void do_scrolling P_ ((struct frame *,
+                              struct glyph_matrix *,
 			      struct matrix_elt *,
 			      int, int));

@@ -100,7 +103,8 @@
   register struct matrix_elt *p, *p1;
   register int cost, cost1;

-  int lines_moved = window_size + (scroll_region_ok ? 0 : lines_below);
+  int lines_moved = window_size
+    + (FRAME_SCROLL_REGION_OK (frame) ? 0 : lines_below);
   /* first_insert_cost[I] is the cost of doing the first insert-line
      at the i'th line of the lines we are considering,
      where I is origin 1 (as it is below).  */
@@ -240,7 +244,8 @@
    of lines.  */

 static void
-do_scrolling (current_matrix, matrix, window_size, unchanged_at_top)
+do_scrolling (frame, current_matrix, matrix, window_size, unchanged_at_top)
+     struct frame *frame;
      struct glyph_matrix *current_matrix;
      struct matrix_elt *matrix;
      int window_size;
@@ -307,12 +312,12 @@
 	  /* Set the terminal window, if not done already.  */
  	  if (! terminal_window_p)
 	    {
-	      set_terminal_window (window_size + unchanged_at_top);
+	      set_terminal_window (frame, window_size + unchanged_at_top);
 	      terminal_window_p = 1;
 	    }

 	  /* Delete lines on the terminal.  */
-	  ins_del_lines (j + unchanged_at_top, - p->deletecount);
+	  ins_del_lines (frame, j + unchanged_at_top, - p->deletecount);
 	}
       else
 	{
@@ -337,7 +342,7 @@
       /* Set the terminal window if not yet done.  */
       if (!terminal_window_p)
 	{
-	  set_terminal_window (window_size + unchanged_at_top);
+	  set_terminal_window (frame, window_size + unchanged_at_top);
 	  terminal_window_p = 1;
 	}

@@ -346,7 +351,7 @@
 	  --queue;

 	  /* Do the deletion on the terminal.  */
-	  ins_del_lines (queue->pos, queue->count);
+	  ins_del_lines (frame, queue->pos, queue->count);

 	  /* All lines in the range deleted become empty in the glyph
 	     matrix.  Assign to them glyph rows that are not retained.
@@ -379,7 +384,7 @@
   CHECK_MATRIX (current_matrix);

   if (terminal_window_p)
-    set_terminal_window (0);
+    set_terminal_window (frame, 0);
 }


@@ -466,7 +471,8 @@
   /* Overhead of setting the scroll window, plus the extra cost
      cost of scrolling by a distance of one.  The extra cost is
      added once for consistency with the cost vectors */
-  scroll_overhead = scroll_region_cost + extra_cost;
+  scroll_overhead
+    = FRAME_SCROLL_REGION_COST (frame) + extra_cost;

   /* initialize the top left corner of the matrix */
   matrix->writecost = 0;
@@ -649,8 +655,9 @@
    the cost matrix for this approach is constructed. */

 static void
-do_direct_scrolling (current_matrix, cost_matrix, window_size,
-		     unchanged_at_top)
+do_direct_scrolling (frame, current_matrix, cost_matrix,
+                     window_size, unchanged_at_top)
+     struct frame *frame;
      struct glyph_matrix *current_matrix;
      struct matrix_elt *cost_matrix;
      int window_size;
@@ -741,9 +748,9 @@
 	  if (i > j)
 	    {
 	      /* Immediately insert lines */
-	      set_terminal_window (i + unchanged_at_top);
+	      set_terminal_window (frame, i + unchanged_at_top);
 	      terminal_window_p = 1;
-	      ins_del_lines (j - n_to_write + unchanged_at_top, i - j);
+	      ins_del_lines (frame, j - n_to_write + unchanged_at_top, i - j);
 	    }
 	  else if (i < j)
 	    {
@@ -773,9 +780,9 @@
 	  --queue;
 	  if (queue->count)
 	    {
-	      set_terminal_window (queue->window);
+	      set_terminal_window (frame, queue->window);
 	      terminal_window_p = 1;
-	      ins_del_lines (queue->pos, queue->count);
+	      ins_del_lines (frame, queue->pos, queue->count);
 	    }
 	  else
 	    {
@@ -798,7 +805,7 @@
 		       copy_from, retained_p);

   if (terminal_window_p)
-    set_terminal_window (0);
+    set_terminal_window (frame, 0);
 }


@@ -818,13 +825,13 @@
   matrix = ((struct matrix_elt *)
 	    alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix));

-  if (scroll_region_ok)
+  if (FRAME_SCROLL_REGION_OK (frame))
     {
       calculate_direct_scrolling (frame, matrix, window_size,
 				  unchanged_at_bottom,
 				  draw_cost, old_draw_cost,
 				  old_hash, new_hash, free_at_end);
-      do_direct_scrolling (frame->current_matrix,
+      do_direct_scrolling (frame, frame->current_matrix,
 			   matrix, window_size, unchanged_at_top);
     }
   else
@@ -832,7 +839,8 @@
       calculate_scrolling (frame, matrix, window_size, unchanged_at_bottom,
 			   draw_cost, old_hash, new_hash,
 			   free_at_end);
-      do_scrolling (frame->current_matrix, matrix, window_size,
+      do_scrolling (frame,
+                    frame->current_matrix, matrix, window_size,
 		    unchanged_at_top);
     }
 }
@@ -914,7 +922,7 @@
   if (amount == 0)
     return 0;

-  if (! scroll_region_ok)
+  if (! FRAME_SCROLL_REGION_OK (frame))
     limit = height;
   else if (amount > 0)
     limit += amount;
--- a/src/sysdep.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/sysdep.c	Mon Oct 25 18:17:28 2004 +0000
@@ -46,6 +46,8 @@
 #endif
 #endif

+#include "sysselect.h"
+
 #include "blockinput.h"
 #undef NULL

@@ -180,6 +182,7 @@
 #include "termopts.h"
 #include "dispextern.h"
 #include "process.h"
+#include "cm.h"  /* for reset_sys_modes */

 #ifdef WINDOWSNT
 #include <direct.h>
@@ -242,16 +245,11 @@

 int emacs_ospeed;

-/* The file descriptor for Emacs's input terminal.
-   Under Unix, this is normally zero except when using X;
-   under VMS, we place the input channel number here.  */
-int input_fd;
-
 void croak P_ ((char *));

 #ifdef AIXHFT
-void hft_init ();
-void hft_reset ();
+void hft_init P_ ((struct tty_display_info *));
+void hft_reset P_ ((struct tty_display_info *));
 #endif

 /* Temporary used by `sigblock' when defined in terms of signprocmask.  */
@@ -259,16 +257,7 @@
 SIGMASKTYPE sigprocmask_set;


-/* Specify a different file descriptor for further input operations.  */
-
-void
-change_input_fd (fd)
-     int fd;
-{
-  input_fd = fd;
-}
-
-/* Discard pending input on descriptor input_fd.  */
+/* Discard pending input on all input descriptors.  */

 void
 discard_tty_input ()
@@ -279,54 +268,61 @@
   if (noninteractive)
     return;

-  /* Discarding input is not safe when the input could contain
-     replies from the X server.  So don't do it.  */
-  if (read_socket_hook)
-    return;
-
 #ifdef VMS
   end_kbd_input ();
-  SYS$QIOW (0, input_fd, IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
+  SYS$QIOW (0, fileno (CURTTY()->input), IO$_READVBLK|IO$M_PURGE, input_iosb, 0, 0,
 	    &buf.main, 0, 0, terminator_mask, 0, 0);
   queue_kbd_input ();
 #else /* not VMS */
 #ifdef APOLLO
   {
-    int zero = 0;
-    ioctl (input_fd, TIOCFLUSH, &zero);
+    struct tty_display_info *tty;
+    for (tty = tty_list; tty; tty = tty->next)
+      {
+        int zero = 0;
+        if (tty->input)
+          ioctl (fileno (tty->input), TIOCFLUSH, &zero);
+      }
   }
 #else /* not Apollo */
 #ifdef MSDOS    /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */
   while (dos_keyread () != -1)
     ;
 #else /* not MSDOS */
-  EMACS_GET_TTY (input_fd, &buf);
-  EMACS_SET_TTY (input_fd, &buf, 0);
+  {
+    struct tty_display_info *tty;
+    for (tty = tty_list; tty; tty = tty->next)
+      {
+        if (tty->input)         /* Is the device suspended? */
+          {
+            EMACS_GET_TTY (fileno (tty->input), &buf);
+            EMACS_SET_TTY (fileno (tty->input), &buf, 0);
+          }
+      }
+  }
 #endif /* not MSDOS */
 #endif /* not Apollo */
 #endif /* not VMS */
 #endif /* not WINDOWSNT */
 }

+
 #ifdef SIGTSTP

 /* Arrange for character C to be read as the next input from
-   the terminal.  */
+   the terminal.
+   XXX What if we have multiple ttys?
+*/

 void
-#ifdef PROTOTYPES
 stuff_char (char c)
-#else
-stuff_char (c)
-     char c;
-#endif
 {
-  if (read_socket_hook)
+  if (! FRAME_TERMCAP_P (SELECTED_FRAME ()))
     return;

 /* Should perhaps error if in batch mode */
 #ifdef TIOCSTI
-  ioctl (input_fd, TIOCSTI, &c);
+  ioctl (fileno (CURTTY()->input), TIOCSTI, &c);
 #else /* no TIOCSTI */
   error ("Cannot stuff terminal input characters in this version of Unix");
 #endif /* no TIOCSTI */
@@ -335,7 +331,7 @@
 #endif /* SIGTSTP */

 void
-init_baud_rate ()
+init_baud_rate (int fd)
 {
   if (noninteractive)
     emacs_ospeed = 0;
@@ -350,7 +346,7 @@
 #ifdef VMS
       struct sensemode sg;

-      SYS$QIOW (0, input_fd, IO$_SENSEMODE, &sg, 0, 0,
+      SYS$QIOW (0, fd, IO$_SENSEMODE, &sg, 0, 0,
 		&sg.class, 12, 0, 0, 0, 0 );
       emacs_ospeed = sg.xmit_baud;
 #else /* not VMS */
@@ -358,7 +354,7 @@
       struct termios sg;

       sg.c_cflag = B9600;
-      tcgetattr (input_fd, &sg);
+      tcgetattr (fd, &sg);
       emacs_ospeed = cfgetospeed (&sg);
 #if defined (USE_GETOBAUD) && defined (getobaud)
       /* m88k-motorola-sysv3 needs this (ghazi@noc.rutgers.edu) 9/1/94. */
@@ -371,16 +367,16 @@

       sg.c_cflag = B9600;
 #ifdef HAVE_TCATTR
-      tcgetattr (input_fd, &sg);
+      tcgetattr (fd, &sg);
 #else
-      ioctl (input_fd, TCGETA, &sg);
+      ioctl (fd, TCGETA, &sg);
 #endif
       emacs_ospeed = sg.c_cflag & CBAUD;
 #else /* neither VMS nor TERMIOS nor TERMIO */
       struct sgttyb sg;

       sg.sg_ospeed = B9600;
-      if (ioctl (input_fd, TIOCGETP, &sg) < 0)
+      if (ioctl (fd, TIOCGETP, &sg) < 0)
 	abort ();
       emacs_ospeed = sg.sg_ospeed;
 #endif /* not HAVE_TERMIO */
@@ -396,6 +392,7 @@
     baud_rate = 1200;
 }

+
 /*ARGSUSED*/
 void
 set_exclusive_use (fd)
@@ -657,7 +654,7 @@

 #ifdef BSD4_1
   if (interrupt_input)
-    reset_sigio ();
+    reset_sigio (0);
 #endif /* BSD4_1 */
 #ifdef RTU
   {
@@ -914,53 +911,88 @@
     }
 }

+#ifndef SIGIO
+/* If SIGIO is broken, don't do anything. */
+void
+init_sigio (int fd)
+{
+}
+
+void
+reset_sigio (int fd)
+{
+}
+
+void
+request_sigio (void)
+{
+}
+
+void
+unrequest_sigio (void)
+{
+}
+
+#else
 #ifdef F_SETFL

-int old_fcntl_flags;
+int old_fcntl_flags[MAXDESC];

 void
 init_sigio (fd)
      int fd;
 {
 #ifdef FASYNC
-  old_fcntl_flags = fcntl (fd, F_GETFL, 0) & ~FASYNC;
-  fcntl (fd, F_SETFL, old_fcntl_flags | FASYNC);
+  old_fcntl_flags[fd] = fcntl (fd, F_GETFL, 0) & ~FASYNC;
+  fcntl (fd, F_SETFL, old_fcntl_flags[fd] | FASYNC);
 #endif
   interrupts_deferred = 0;
 }

 void
-reset_sigio ()
+reset_sigio (fd)
+     int fd;
 {
-  unrequest_sigio ();
+#ifdef FASYNC
+  fcntl (fd, F_SETFL, old_fcntl_flags[fd]);
+#endif
 }

 #ifdef FASYNC		/* F_SETFL does not imply existence of FASYNC */
+/* XXX Uhm, FASYNC is not used anymore here. */

 void
 request_sigio ()
 {
+  /* XXX read_socket_hook is not global anymore.  Is blocking SIGIO
+     bad under X? */
+#if 0
   if (read_socket_hook)
     return;
+#endif

 #ifdef SIGWINCH
   sigunblock (sigmask (SIGWINCH));
 #endif
-  fcntl (input_fd, F_SETFL, old_fcntl_flags | FASYNC);
+  sigunblock (sigmask (SIGIO));

   interrupts_deferred = 0;
 }

 void
-unrequest_sigio ()
-{
+unrequest_sigio (void)
+{
+  /* XXX read_socket_hook is not global anymore.  Is blocking SIGIO
+     bad under X? */
+#if 0
   if (read_socket_hook)
     return;
-
+#endif
+
 #ifdef SIGWINCH
   sigblock (sigmask (SIGWINCH));
 #endif
-  fcntl (input_fd, F_SETFL, old_fcntl_flags);
+  sigblock (sigmask (SIGIO));
   interrupts_deferred = 1;
 }

@@ -975,7 +1007,8 @@
   if (read_socket_hook)
     return;

-  ioctl (input_fd, FIOASYNC, &on);
+  /* XXX CURTTY() is bogus here. */
+  ioctl (fileno (CURTTY ()->input), FIOASYNC, &on);
   interrupts_deferred = 0;
 }

@@ -987,7 +1020,8 @@
   if (read_socket_hook)
     return;

-  ioctl (input_fd, FIOASYNC, &off);
+  /* XXX CURTTY() is bogus here. */
+  ioctl (fileno (CURTTY ()->input), FIOASYNC, &off);
   interrupts_deferred = 1;
 }

@@ -1008,7 +1042,7 @@

   sigemptyset (&st);
   sigaddset (&st, SIGIO);
-  ioctl (input_fd, FIOASYNC, &on);
+  ioctl (0, FIOASYNC, &on);     /* XXX This fails for multiple ttys. */
   interrupts_deferred = 0;
   sigprocmask (SIG_UNBLOCK, &st, (sigset_t *)0);
 }
@@ -1021,7 +1055,7 @@
   if (read_socket_hook)
     return;

-  ioctl (input_fd, FIOASYNC, &off);
+  ioctl (0, FIOASYNC, &off);  /* XXX This fails for multiple ttys. */
   interrupts_deferred = 1;
 }

@@ -1051,6 +1085,7 @@
 #endif /* STRIDE */
 #endif /* FASYNC */
 #endif /* F_SETFL */
+#endif /* SIGIO */

 /* Saving and restoring the process group of Emacs's terminal.  */

@@ -1073,30 +1108,35 @@
    the tty's pgroup just like any other terminal setting.  If
    inherited_group was not the tty's pgroup, then we'll get a
    SIGTTmumble when we try to change the tty's pgroup, and a CONT if
-   it goes foreground in the future, which is what should happen.  */
+   it goes foreground in the future, which is what should happen.
+
+   This variable is initialized in emacs.c.  */
 int inherited_pgroup;

-/* Split off the foreground process group to Emacs alone.
-   When we are in the foreground, but not started in our own process
-   group, redirect the TTY to point to our own process group.  We need
-   to be in our own process group to receive SIGIO properly.  */
+/* Split off the foreground process group to Emacs alone.  When we are
+   in the foreground, but not started in our own process group,
+   redirect the tty device handle FD to point to our own process
+   group.  We need to be in our own process group to receive SIGIO
+   properly.  */
 void
-narrow_foreground_group ()
+narrow_foreground_group (int fd)
 {
   int me = getpid ();

   setpgrp (0, inherited_pgroup);
+  if (! inherited_pgroup)
+    abort ();                   /* Should not happen. */
   if (inherited_pgroup != me)
-    EMACS_SET_TTY_PGRP (input_fd, &me);
+      EMACS_SET_TTY_PGRP (fd, &me); /* XXX This only works on the controlling tty. */
   setpgrp (0, me);
 }

 /* Set the tty to our original foreground group.  */
 void
-widen_foreground_group ()
+widen_foreground_group (int fd)
 {
   if (inherited_pgroup != getpid ())
-    EMACS_SET_TTY_PGRP (input_fd, &inherited_pgroup);
+    EMACS_SET_TTY_PGRP (fd, &inherited_pgroup);
   setpgrp (0, inherited_pgroup);
 }

@@ -1254,14 +1294,6 @@
 }


-/* The initial tty mode bits */
-struct emacs_tty old_tty;
-
-/* 1 if we have been through init_sys_modes.  */
-int term_initted;
-
-/* 1 if outer tty status has been recorded.  */
-int old_tty_valid;

 #ifdef BSD4_1
 /* BSD 4.1 needs to keep track of the lmode bits in order to start
@@ -1271,7 +1303,7 @@

 #ifndef F_SETOWN_BUG
 #ifdef F_SETOWN
-int old_fcntl_owner;
+int old_fcntl_owner[MAXDESC];
 #endif /* F_SETOWN */
 #endif /* F_SETOWN_BUG */

@@ -1296,8 +1328,22 @@
 static struct tchars new_tchars = {-1,-1,-1,-1,-1,-1};
 #endif

+/* Initialize the terminal mode on all tty devices that are currently
+   open. */
+
 void
-init_sys_modes ()
+init_all_sys_modes (void)
+{
+  struct tty_display_info *tty;
+  for (tty = tty_list; tty; tty = tty->next)
+    init_sys_modes (tty);
+}
+
+/* Initialize the terminal mode on the given tty device. */
+
+void
+init_sys_modes (tty_out)
+     struct tty_display_info *tty_out;
 {
   struct emacs_tty tty;

@@ -1323,6 +1369,9 @@
   if (noninteractive)
     return;

+  if (!tty_out->output)
+    return;                     /* The tty is suspended. */
+
 #ifdef VMS
   if (!input_ef)
     input_ef = get_kbd_event_flag ();
@@ -1353,266 +1402,287 @@
 #ifndef VMS4_4
   sys_access_reinit ();
 #endif
-#endif /* not VMS */
+#endif /* VMS */

 #ifdef BSD_PGRPS
-  if (! read_socket_hook && EQ (Vwindow_system, Qnil))
-    narrow_foreground_group ();
+#if 0
+  /* read_socket_hook is not global anymore.  I think doing this
+     unconditionally will not cause any problems. */
+  if (! read_socket_hook && EQ (Vinitial_window_system, Qnil))
+#endif
+    narrow_foreground_group (fileno (tty_out->input));
 #endif

-#ifdef HAVE_WINDOW_SYSTEM
-  /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
-     needs the initialization code below.  */
-  if (!read_socket_hook && EQ (Vwindow_system, Qnil))
-#endif
-    {
-      EMACS_GET_TTY (input_fd, &old_tty);
-
-      old_tty_valid = 1;
-
-      tty = old_tty;
+  if (! tty_out->old_tty)
+    tty_out->old_tty = (struct emacs_tty *) xmalloc (sizeof (struct emacs_tty));
+
+  EMACS_GET_TTY (fileno (tty_out->input), tty_out->old_tty);
+
+  tty = *tty_out->old_tty;

 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
-      XSETINT (Vtty_erase_char, old_tty.main.c_cc[VERASE]);
+  XSETINT (Vtty_erase_char, tty.main.c_cc[VERASE]);

 #ifdef DGUX
-      /* This allows meta to be sent on 8th bit.  */
-      tty.main.c_iflag &= ~INPCK;	/* don't check input for parity */
+  /* This allows meta to be sent on 8th bit.  */
+  tty.main.c_iflag &= ~INPCK;	/* don't check input for parity */
 #endif
-      tty.main.c_iflag |= (IGNBRK);	/* Ignore break condition */
-      tty.main.c_iflag &= ~ICRNL;	/* Disable map of CR to NL on input */
+  tty.main.c_iflag |= (IGNBRK);	/* Ignore break condition */
+  tty.main.c_iflag &= ~ICRNL;	/* Disable map of CR to NL on input */
 #ifdef INLCR  /* I'm just being cautious,
 		 since I can't check how widespread INLCR is--rms.  */
-      tty.main.c_iflag &= ~INLCR;	/* Disable map of NL to CR on input */
+  tty.main.c_iflag &= ~INLCR;	/* Disable map of NL to CR on input */
 #endif
 #ifdef ISTRIP
-      tty.main.c_iflag &= ~ISTRIP;	/* don't strip 8th bit on input */
+  tty.main.c_iflag &= ~ISTRIP;	/* don't strip 8th bit on input */
 #endif
-      tty.main.c_lflag &= ~ECHO;	/* Disable echo */
-      tty.main.c_lflag &= ~ICANON;	/* Disable erase/kill processing */
+  tty.main.c_lflag &= ~ECHO;	/* Disable echo */
+  tty.main.c_lflag &= ~ICANON;	/* Disable erase/kill processing */
 #ifdef IEXTEN
-      tty.main.c_lflag &= ~IEXTEN;	/* Disable other editing characters.  */
+  tty.main.c_lflag &= ~IEXTEN;	/* Disable other editing characters.  */
 #endif
-      tty.main.c_lflag |= ISIG;	/* Enable signals */
-      if (flow_control)
-	{
-	  tty.main.c_iflag |= IXON;	/* Enable start/stop output control */
+  tty.main.c_lflag |= ISIG;	/* Enable signals */
+  if (tty_out->flow_control)
+    {
+      tty.main.c_iflag |= IXON;	/* Enable start/stop output control */
 #ifdef IXANY
-	  tty.main.c_iflag &= ~IXANY;
+      tty.main.c_iflag &= ~IXANY;
 #endif /* IXANY */
-	}
-      else
-	tty.main.c_iflag &= ~IXON;	/* Disable start/stop output control */
-      tty.main.c_oflag &= ~ONLCR;	/* Disable map of NL to CR-NL
-					   on output */
-      tty.main.c_oflag &= ~TAB3;	/* Disable tab expansion */
+    }
+  else
+    tty.main.c_iflag &= ~IXON;	/* Disable start/stop output control */
+  tty.main.c_oflag &= ~ONLCR;	/* Disable map of NL to CR-NL
+                                   on output */
+  tty.main.c_oflag &= ~TAB3;	/* Disable tab expansion */
 #ifdef CS8
-      if (meta_key)
-	{
-	  tty.main.c_cflag |= CS8;	/* allow 8th bit on input */
-	  tty.main.c_cflag &= ~PARENB;/* Don't check parity */
-	}
+  if (tty_out->meta_key)
+    {
+      tty.main.c_cflag |= CS8;	/* allow 8th bit on input */
+      tty.main.c_cflag &= ~PARENB;/* Don't check parity */
+    }
 #endif
+  if (tty_out->input == stdin)
+    {
       tty.main.c_cc[VINTR] = quit_char;	/* C-g (usually) gives SIGINT */
       /* Set up C-g for both SIGQUIT and SIGINT.
-	 We don't know which we will get, but we handle both alike
-	 so which one it really gives us does not matter.  */
+         We don't know which we will get, but we handle both alike
+         so which one it really gives us does not matter.  */
       tty.main.c_cc[VQUIT] = quit_char;
-      tty.main.c_cc[VMIN] = 1;	/* Input should wait for at least 1 char */
-      tty.main.c_cc[VTIME] = 0;	/* no matter how long that takes.  */
+    }
+  else
+    {
+      /* We normally don't get interrupt or quit signals from tty
+         devices other than our controlling terminal; therefore,
+         we must handle C-g as normal input.  Unfortunately, this
+         means that the interrupt and quit feature must be
+         disabled on secondary ttys, or we would not even see the
+         keypress.
+
+         Note that even though emacsclient could have special code
+         to pass SIGINT to Emacs, we should _not_ enable
+         interrupt/quit keys for emacsclient frames.  This means
+         that we can't break out of loops in C code from a
+         secondary tty frame, but we can always decide what
+         display the C-g came from, which is more important from a
+         usability point of view.  (Consider the case when two
+         people work together using the same Emacs instance.)  */
+      tty.main.c_cc[VINTR] = CDISABLE;
+      tty.main.c_cc[VQUIT] = CDISABLE;
+    }
+  tty.main.c_cc[VMIN] = 1;	/* Input should wait for at least 1 char */
+  tty.main.c_cc[VTIME] = 0;	/* no matter how long that takes.  */
 #ifdef VSWTCH
-      tty.main.c_cc[VSWTCH] = CDISABLE;	/* Turn off shell layering use
+  tty.main.c_cc[VSWTCH] = CDISABLE;	/* Turn off shell layering use
 					   of C-z */
 #endif /* VSWTCH */
-
+
 #if defined (mips) || defined (HAVE_TCATTR)
 #ifdef VSUSP
-      tty.main.c_cc[VSUSP] = CDISABLE;	/* Turn off mips handling of C-z.  */
+  tty.main.c_cc[VSUSP] = CDISABLE;	/* Turn off mips handling of C-z.  */
 #endif /* VSUSP */
 #ifdef V_DSUSP
-      tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
+  tty.main.c_cc[V_DSUSP] = CDISABLE; /* Turn off mips handling of C-y.  */
 #endif /* V_DSUSP */
 #ifdef VDSUSP /* Some systems have VDSUSP, some have V_DSUSP.  */
-      tty.main.c_cc[VDSUSP] = CDISABLE;
+  tty.main.c_cc[VDSUSP] = CDISABLE;
 #endif /* VDSUSP */
 #ifdef VLNEXT
-      tty.main.c_cc[VLNEXT] = CDISABLE;
+  tty.main.c_cc[VLNEXT] = CDISABLE;
 #endif /* VLNEXT */
 #ifdef VREPRINT
-      tty.main.c_cc[VREPRINT] = CDISABLE;
+  tty.main.c_cc[VREPRINT] = CDISABLE;
 #endif /* VREPRINT */
 #ifdef VWERASE
-      tty.main.c_cc[VWERASE] = CDISABLE;
+  tty.main.c_cc[VWERASE] = CDISABLE;
 #endif /* VWERASE */
 #ifdef VDISCARD
-      tty.main.c_cc[VDISCARD] = CDISABLE;
+  tty.main.c_cc[VDISCARD] = CDISABLE;
 #endif /* VDISCARD */

-      if (flow_control)
-	{
+  if (tty_out->flow_control)
+    {
 #ifdef VSTART
-	  tty.main.c_cc[VSTART] = '\021';
+      tty.main.c_cc[VSTART] = '\021';
 #endif /* VSTART */
 #ifdef VSTOP
-	  tty.main.c_cc[VSTOP] = '\023';
+      tty.main.c_cc[VSTOP] = '\023';
 #endif /* VSTOP */
-	}
-      else
-	{
+    }
+  else
+    {
 #ifdef VSTART
-	  tty.main.c_cc[VSTART] = CDISABLE;
+      tty.main.c_cc[VSTART] = CDISABLE;
 #endif /* VSTART */
 #ifdef VSTOP
-	  tty.main.c_cc[VSTOP] = CDISABLE;
+      tty.main.c_cc[VSTOP] = CDISABLE;
 #endif /* VSTOP */
-	}
+    }
 #endif /* mips or HAVE_TCATTR */

 #ifdef SET_LINE_DISCIPLINE
-      /* Need to explicitly request TERMIODISC line discipline or
-         Ultrix's termios does not work correctly.  */
-      tty.main.c_line = SET_LINE_DISCIPLINE;
+  /* Need to explicitly request TERMIODISC line discipline or
+     Ultrix's termios does not work correctly.  */
+  tty.main.c_line = SET_LINE_DISCIPLINE;
 #endif
 #ifdef AIX
 #ifndef IBMR2AIX
-      /* AIX enhanced edit loses NULs, so disable it.  */
-      tty.main.c_line = 0;
-      tty.main.c_iflag &= ~ASCEDIT;
+  /* AIX enhanced edit loses NULs, so disable it.  */
+  tty.main.c_line = 0;
+  tty.main.c_iflag &= ~ASCEDIT;
 #else
-      tty.main.c_cc[VSTRT] = CDISABLE;
-      tty.main.c_cc[VSTOP] = CDISABLE;
-      tty.main.c_cc[VSUSP] = CDISABLE;
-      tty.main.c_cc[VDSUSP] = CDISABLE;
+  tty.main.c_cc[VSTRT] = CDISABLE;
+  tty.main.c_cc[VSTOP] = CDISABLE;
+  tty.main.c_cc[VSUSP] = CDISABLE;
+  tty.main.c_cc[VDSUSP] = CDISABLE;
 #endif /* IBMR2AIX */
-      if (flow_control)
-	{
+  if (tty_out->flow_control)
+    {
 #ifdef VSTART
-	  tty.main.c_cc[VSTART] = '\021';
+      tty.main.c_cc[VSTART] = '\021';
 #endif /* VSTART */
 #ifdef VSTOP
-	  tty.main.c_cc[VSTOP] = '\023';
+      tty.main.c_cc[VSTOP] = '\023';
 #endif /* VSTOP */
-	}
-      /* Also, PTY overloads NUL and BREAK.
-	 don't ignore break, but don't signal either, so it looks like NUL.
-	 This really serves a purpose only if running in an XTERM window
-	 or via TELNET or the like, but does no harm elsewhere.  */
-      tty.main.c_iflag &= ~IGNBRK;
-      tty.main.c_iflag &= ~BRKINT;
+    }
+  /* Also, PTY overloads NUL and BREAK.
+     don't ignore break, but don't signal either, so it looks like NUL.
+     This really serves a purpose only if running in an XTERM window
+     or via TELNET or the like, but does no harm elsewhere.  */
+  tty.main.c_iflag &= ~IGNBRK;
+  tty.main.c_iflag &= ~BRKINT;
 #endif
 #else /* if not HAVE_TERMIO */
 #ifdef VMS
-      tty.main.tt_char |= TT$M_NOECHO;
-      if (meta_key)
-	tty.main.tt_char |= TT$M_EIGHTBIT;
-      if (flow_control)
-	tty.main.tt_char |= TT$M_TTSYNC;
-      else
-	tty.main.tt_char &= ~TT$M_TTSYNC;
-      tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
+  tty.main.tt_char |= TT$M_NOECHO;
+  if (meta_key)
+    tty.main.tt_char |= TT$M_EIGHTBIT;
+  if (tty_out->flow_control)
+    tty.main.tt_char |= TT$M_TTSYNC;
+  else
+    tty.main.tt_char &= ~TT$M_TTSYNC;
+  tty.main.tt2_char |= TT2$M_PASTHRU | TT2$M_XON;
 #else /* not VMS (BSD, that is) */
 #ifndef DOS_NT
-      XSETINT (Vtty_erase_char, tty.main.sg_erase);
-      tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
-      if (meta_key)
-	tty.main.sg_flags |= ANYP;
-      tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
+  XSETINT (Vtty_erase_char, tty.main.sg_erase);
+  tty.main.sg_flags &= ~(ECHO | CRMOD | XTABS);
+  if (meta_key)
+    tty.main.sg_flags |= ANYP;
+  tty.main.sg_flags |= interrupt_input ? RAW : CBREAK;
 #endif /* not DOS_NT */
 #endif /* not VMS (BSD, that is) */
 #endif /* not HAVE_TERMIO */

-      /* If going to use CBREAK mode, we must request C-g to interrupt
-	 and turn off start and stop chars, etc.  If not going to use
-	 CBREAK mode, do this anyway so as to turn off local flow
-	 control for user coming over network on 4.2; in this case,
-	 only t_stopc and t_startc really matter.  */
+  /* If going to use CBREAK mode, we must request C-g to interrupt
+     and turn off start and stop chars, etc.  If not going to use
+     CBREAK mode, do this anyway so as to turn off local flow
+     control for user coming over network on 4.2; in this case,
+     only t_stopc and t_startc really matter.  */
 #ifndef HAVE_TERMIO
 #ifdef HAVE_TCHARS
-      /* Note: if not using CBREAK mode, it makes no difference how we
-	 set this */
-      tty.tchars = new_tchars;
-      tty.tchars.t_intrc = quit_char;
-      if (flow_control)
-	{
-	  tty.tchars.t_startc = '\021';
-	  tty.tchars.t_stopc = '\023';
-	}
-
-      tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | old_tty.lmode;
+  /* Note: if not using CBREAK mode, it makes no difference how we
+     set this */
+  tty.tchars = new_tchars;
+  tty.tchars.t_intrc = quit_char;
+  if (tty_out->flow_control)
+    {
+      tty.tchars.t_startc = '\021';
+      tty.tchars.t_stopc = '\023';
+    }
+
+  tty.lmode = LDECCTQ | LLITOUT | LPASS8 | LNOFLSH | tty_out->old_tty.lmode;
 #ifdef ultrix
-      /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
-	 anything, and leaving it in breaks the meta key.  Go figure.  */
-      tty.lmode &= ~LLITOUT;
+  /* Under Ultrix 4.2a, leaving this out doesn't seem to hurt
+     anything, and leaving it in breaks the meta key.  Go figure.  */
+  tty.lmode &= ~LLITOUT;
 #endif
-
+
 #ifdef BSD4_1
-      lmode = tty.lmode;
+  lmode = tty.lmode;
 #endif

 #endif /* HAVE_TCHARS */
 #endif /* not HAVE_TERMIO */

 #ifdef HAVE_LTCHARS
-      tty.ltchars = new_ltchars;
+  tty.ltchars = new_ltchars;
 #endif /* HAVE_LTCHARS */
 #ifdef MSDOS	/* Demacs 1.1.2 91/10/20 Manabu Higashida, MW Aug 1993 */
-      if (!term_initted)
-	internal_terminal_init ();
-      dos_ttraw ();
+  if (!tty_out->term_initted)
+    internal_terminal_init ();
+  dos_ttraw ();
 #endif

-      EMACS_SET_TTY (input_fd, &tty, 0);
-
-      /* This code added to insure that, if flow-control is not to be used,
-	 we have an unlocked terminal at the start. */
+  EMACS_SET_TTY (fileno (tty_out->input), &tty, 0);
+
+  /* This code added to insure that, if flow-control is not to be used,
+     we have an unlocked terminal at the start. */

 #ifdef TCXONC
-      if (!flow_control) ioctl (input_fd, TCXONC, 1);
+  if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TCXONC, 1);
 #endif
 #ifndef APOLLO
 #ifdef TIOCSTART
-      if (!flow_control) ioctl (input_fd, TIOCSTART, 0);
+  if (!tty_out->flow_control) ioctl (fileno (tty_out->input), TIOCSTART, 0);
 #endif
 #endif

 #if defined (HAVE_TERMIOS) || defined (HPUX9)
 #ifdef TCOON
-      if (!flow_control) tcflow (input_fd, TCOON);
+  if (!tty_out->flow_control) tcflow (fileno (tty_out->input), TCOON);
 #endif
 #endif

 #ifdef AIXHFT
-      hft_init ();
+  hft_init (tty_out);
 #ifdef IBMR2AIX
-      {
-	/* IBM's HFT device usually thinks a ^J should be LF/CR.  We need it
-	   to be only LF.  This is the way that is done. */
-	struct termio tty;
-
-	if (ioctl (1, HFTGETID, &tty) != -1)
-	  write (1, "\033[20l", 5);
-      }
+  {
+    /* IBM's HFT device usually thinks a ^J should be LF/CR.  We need it
+       to be only LF.  This is the way that is done. */
+    struct termio tty;
+
+    if (ioctl (1, HFTGETID, &tty) != -1)
+      write (1, "\033[20l", 5);
+  }
 #endif
 #endif /* AIXHFT */

 #ifdef VMS
 /*  Appears to do nothing when in PASTHRU mode.
-      SYS$QIOW (0, input_fd, IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
+      SYS$QIOW (0, fileno (tty_out->input), IO$_SETMODE|IO$M_OUTBAND, 0, 0, 0,
 		interrupt_signal, oob_chars, 0, 0, 0, 0);
 */
-      queue_kbd_input (0);
+  queue_kbd_input (0);
 #endif /* VMS */
-    }

 #ifdef F_SETFL
 #ifndef F_SETOWN_BUG
 #ifdef F_GETOWN		/* F_SETFL does not imply existence of F_GETOWN */
-  if (interrupt_input
-      && ! read_socket_hook && EQ (Vwindow_system, Qnil))
+  if (interrupt_input)
     {
-      old_fcntl_owner = fcntl (input_fd, F_GETOWN, 0);
-      fcntl (input_fd, F_SETOWN, getpid ());
-      init_sigio (input_fd);
+      old_fcntl_owner[fileno (tty_out->input)] =
+        fcntl (fileno (tty_out->input), F_GETOWN, 0);
+      fcntl (fileno (tty_out->input), F_SETOWN, getpid ());
+      init_sigio (fileno (tty_out->input));
     }
 #endif /* F_GETOWN */
 #endif /* F_SETOWN_BUG */
@@ -1620,7 +1690,7 @@

 #ifdef BSD4_1
   if (interrupt_input)
-    init_sigio (input_fd);
+    init_sigio (fileno (tty_out->input));
 #endif

 #ifdef VMS  /* VMS sometimes has this symbol but lacks setvbuf.  */
@@ -1630,53 +1700,55 @@
   /* This symbol is defined on recent USG systems.
      Someone says without this call USG won't really buffer the file
      even with a call to setbuf. */
-  setvbuf (stdout, (char *) _sobuf, _IOFBF, sizeof _sobuf);
+  setvbuf (tty_out->output, (char *) _sobuf, _IOFBF, sizeof _sobuf);
 #else
-  setbuf (stdout, (char *) _sobuf);
+  setbuf (tty_out->output, (char *) _sobuf);
 #endif
-#ifdef HAVE_WINDOW_SYSTEM
-  /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
-     needs the initialization code below.  */
-  if (EQ (Vwindow_system, Qnil)
-#ifndef WINDOWSNT
-      /* When running in tty mode on NT/Win95, we have a read_socket
-	 hook, but still need the rest of the initialization code below.  */
-      && (! read_socket_hook)
-#endif
-      )
-#endif
-    set_terminal_modes ();
-
-  if (!term_initted
-      && FRAMEP (Vterminal_frame)
-      && FRAME_TERMCAP_P (XFRAME (Vterminal_frame)))
-    init_frame_faces (XFRAME (Vterminal_frame));
-
-  if (term_initted && no_redraw_on_reenter)
+
+  tty_set_terminal_modes (tty_out->display);
+
+  if (!tty_out->term_initted)
+    {
+      Lisp_Object tail, frame;
+      FOR_EACH_FRAME (tail, frame)
+        {
+          /* XXX This needs to be revised. */
+          if (FRAME_TERMCAP_P (XFRAME (frame))
+              && FRAME_TTY (XFRAME (frame)) == tty_out)
+            init_frame_faces (XFRAME (frame));
+        }
+    }
+
+  if (tty_out->term_initted && no_redraw_on_reenter)
     {
       if (display_completed)
 	direct_output_forward_char (0);
     }
   else
     {
+      Lisp_Object tail, frame;
       frame_garbaged = 1;
-      if (FRAMEP (Vterminal_frame))
-	FRAME_GARBAGED_P (XFRAME (Vterminal_frame)) = 1;
+      FOR_EACH_FRAME (tail, frame)
+        {
+          if (FRAME_TERMCAP_P (XFRAME (frame))
+              && FRAME_TTY (XFRAME (frame)) == tty_out)
+            FRAME_GARBAGED_P (XFRAME (frame)) = 1;
+        }
     }

-  term_initted = 1;
+  tty_out->term_initted = 1;
 }

 /* Return nonzero if safe to use tabs in output.
    At the time this is called, init_sys_modes has not been done yet.  */

 int
-tabs_safe_p ()
+tabs_safe_p (int fd)
 {
-  struct emacs_tty tty;
-
-  EMACS_GET_TTY (input_fd, &tty);
-  return EMACS_TTY_TABS_OK (&tty);
+  struct emacs_tty etty;
+
+  EMACS_GET_TTY (fd, &etty);
+  return EMACS_TTY_TABS_OK (&etty);
 }

 /* Get terminal size from system.
@@ -1684,8 +1756,7 @@
    We store 0 if there's no valid information.  */

 void
-get_frame_size (widthp, heightp)
-     int *widthp, *heightp;
+get_tty_size (int fd, int *widthp, int *heightp)
 {

 #ifdef TIOCGWINSZ
@@ -1693,7 +1764,7 @@
   /* BSD-style.  */
   struct winsize size;

-  if (ioctl (input_fd, TIOCGWINSZ, &size) == -1)
+  if (ioctl (fd, TIOCGWINSZ, &size) == -1)
     *widthp = *heightp = 0;
   else
     {
@@ -1707,7 +1778,7 @@
   /* SunOS - style.  */
   struct ttysize size;

-  if (ioctl (input_fd, TIOCGSIZE, &size) == -1)
+  if (ioctl (fd, TIOCGSIZE, &size) == -1)
     *widthp = *heightp = 0;
   else
     {
@@ -1720,7 +1791,7 @@

   struct sensemode tty;

-  SYS$QIOW (0, input_fd, IO$_SENSEMODE, &tty, 0, 0,
+  SYS$QIOW (0, fd, IO$_SENSEMODE, &tty, 0, 0,
 	    &tty.class, 12, 0, 0, 0, 0);
   *widthp = tty.scr_wid;
   *heightp = tty.scr_len;
@@ -1733,7 +1804,6 @@
   *widthp = 0;
   *heightp = 0;
 #endif
-
 #endif /* not VMS */
 #endif /* not SunOS-style */
 #endif /* not BSD-style */
@@ -1777,37 +1847,58 @@
 }


-/* Prepare the terminal for exiting Emacs; move the cursor to the
-   bottom of the frame, turn off interrupt-driven I/O, etc.  */
+
+/* Prepare all terminal devices for exiting Emacs. */
+
 void
-reset_sys_modes ()
+reset_all_sys_modes (void)
 {
-  struct frame *sf;
-
+  struct tty_display_info *tty;
+  for (tty = tty_list; tty; tty = tty->next)
+    reset_sys_modes (tty);
+}
+
+/* Prepare the terminal for closing it; move the cursor to the
+   bottom of the frame, turn off interrupt-driven I/O, etc.  */
+
+void
+reset_sys_modes (tty_out)
+     struct tty_display_info *tty_out;
+{
   if (noninteractive)
     {
       fflush (stdout);
       return;
     }
-  if (!term_initted)
+  if (!tty_out->term_initted)
     return;
-#ifdef HAVE_WINDOW_SYSTEM
-  /* Emacs' window system on MSDOG uses the `internal terminal' and therefore
-     needs the clean-up code below.  */
-  if (!EQ (Vwindow_system, Qnil)
-#ifndef WINDOWSNT
-      /* When running in tty mode on NT/Win95, we have a read_socket
-	 hook, but still need the rest of the clean-up code below.  */
-      || read_socket_hook
-#endif
-      )
-    return;
-#endif
-  sf = SELECTED_FRAME ();
-  cursor_to (FRAME_LINES (sf) - 1, 0);
-  clear_end_of_line (FRAME_COLS (sf));
-  /* clear_end_of_line may move the cursor */
-  cursor_to (FRAME_LINES (sf) - 1, 0);
+
+  if (!tty_out->output)
+    return;                     /* The tty is suspended. */
+
+  /* Go to and clear the last line of the terminal. */
+
+  cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
+
+  /* Code adapted from tty_clear_end_of_line. */
+  if (tty_out->TS_clr_line)
+    {
+      emacs_tputs (tty_out, tty_out->TS_clr_line, 1, cmputc);
+    }
+  else
+    {			/* have to do it the hard way */
+      int i;
+      turn_off_insert (tty_out);
+
+      for (i = curX (tty_out); i < FrameCols (tty_out) - 1; i++)
+        {
+          fputc (' ', tty_out->output);
+        }
+    }
+
+  cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
+  fflush (tty_out->output);
+
 #if defined (IBMR2AIX) && defined (AIXHFT)
   {
     /* HFT devices normally use ^J as a LF/CR.  We forced it to
@@ -1819,12 +1910,12 @@
   }
 #endif

-  reset_terminal_modes ();
-  fflush (stdout);
+  tty_reset_terminal_modes (tty_out->display);
+  fflush (tty_out->output);
 #ifdef BSD_SYSTEM
 #ifndef BSD4_1
   /* Avoid possible loss of output when changing terminal modes.  */
-  fsync (fileno (stdout));
+  fsync (fileno (tty_out->output));
 #endif
 #endif

@@ -1833,22 +1924,25 @@
 #ifdef F_SETOWN		/* F_SETFL does not imply existence of F_SETOWN */
   if (interrupt_input)
     {
-      reset_sigio ();
-      fcntl (input_fd, F_SETOWN, old_fcntl_owner);
+      reset_sigio (fileno (tty_out->input));
+      fcntl (fileno (tty_out->input), F_SETOWN,
+             old_fcntl_owner[fileno (tty_out->input)]);
     }
 #endif /* F_SETOWN */
 #endif /* F_SETOWN_BUG */
 #ifdef O_NDELAY
-  fcntl (input_fd, F_SETFL, fcntl (input_fd, F_GETFL, 0) & ~O_NDELAY);
+  fcntl (fileno (tty_out->input), F_SETFL,
+         fcntl (fileno (tty_out->input), F_GETFL, 0) & ~O_NDELAY);
 #endif
 #endif /* F_SETFL */
 #ifdef BSD4_1
   if (interrupt_input)
-    reset_sigio ();
+    reset_sigio (fileno (tty_out->input));
 #endif /* BSD4_1 */

-  if (old_tty_valid)
-    while (EMACS_SET_TTY (input_fd, &old_tty, 0) < 0 && errno == EINTR)
+  if (tty_out->old_tty)
+    while (EMACS_SET_TTY (fileno (tty_out->input),
+                          tty_out->old_tty, 0) < 0 && errno == EINTR)
       ;

 #ifdef MSDOS	/* Demacs 1.1.2 91/10/20 Manabu Higashida */
@@ -1859,7 +1953,7 @@
   /* Ultrix's termios *ignores* any line discipline except TERMIODISC.
      A different old line discipline is therefore not restored, yet.
      Restore the old line discipline by hand.  */
-  ioctl (0, TIOCSETD, &old_tty.main.c_line);
+  ioctl (0, TIOCSETD, &tty_out->old_tty.main.c_line);
 #endif

 #ifdef AIXHFT
@@ -1867,7 +1961,7 @@
 #endif

 #ifdef BSD_PGRPS
-  widen_foreground_group ();
+  widen_foreground_group (fileno (tty_out->input));
 #endif
 }

@@ -1932,9 +2026,9 @@
 {
   int status;

-  if (input_fd == 0)
+  if (fileno (CURTTY ()->input)) == 0)
     {
-      status = SYS$ASSIGN (&input_dsc, &input_fd, 0, 0);
+      status = SYS$ASSIGN (&input_dsc, &fileno (CURTTY ()->input)), 0, 0);
       if (! (status & 1))
 	LIB$STOP (status);
     }
@@ -1945,7 +2039,7 @@
 void
 stop_vms_input ()
 {
-  return SYS$DASSGN (input_fd);
+  return SYS$DASSGN (fileno (CURTTY ()->input)));
 }

 short input_buffer;
@@ -1961,7 +2055,7 @@

   waiting_for_ast = 0;
   stop_input = 0;
-  status = SYS$QIO (0, input_fd, IO$_READVBLK,
+  status = SYS$QIO (0, fileno (CURTTY()->input), IO$_READVBLK,
 		    &input_iosb, kbd_input_ast, 1,
 		    &input_buffer, 1, 0, terminator_mask, 0, 0);
 }
@@ -2078,7 +2172,7 @@
 #endif
   if (LIB$AST_IN_PROG ())  /* Don't wait if suspending from kbd_buffer_store_event! */
     {
-      SYS$CANCEL (input_fd);
+      SYS$CANCEL (fileno (CURTTY()->input));
       return;
     }

@@ -2087,7 +2181,7 @@
   SYS$CLREF (input_ef);
   waiting_for_ast = 1;
   stop_input = 1;
-  SYS$CANCEL (input_fd);
+  SYS$CANCEL (fileno (CURTTY()->input));
   SYS$SETAST (1);
   SYS$WAITFR (input_ef);
   waiting_for_ast = 0;
@@ -2149,7 +2243,8 @@
   request_sigio ();
 }

-reset_sigio ()
+reset_sigio (fd)
+     int fd;
 {
   unrequest_sigio ();
 }
@@ -2484,7 +2579,9 @@
      SELECT_TYPE *rfds, *wfds, *efds;
      EMACS_TIME *timeout;
 {
-  int ravail = 0;
+  /* XXX This needs to be updated for multi-tty support.  Is there
+     anybody who needs to emulate select these days?  */
+ int ravail = 0;
   SELECT_TYPE orfds;
   int timeoutval;
   int *local_timeout;
@@ -2499,7 +2596,7 @@
 #if defined (HAVE_SELECT) && defined (HAVE_X_WINDOWS)
   /* If we're using X, then the native select will work; we only need the
      emulation for non-X usage.  */
-  if (!NILP (Vwindow_system))
+  if (!NILP (Vinitial_window_system))
     return select (nfds, rfds, wfds, efds, timeout);
 #endif
   timeoutval = timeout ? EMACS_SECS (*timeout) : 100000;
@@ -2608,7 +2705,7 @@
     }
   return ravail;
 }
-#endif /* not WINDOWSNT */
+#endif not WINDOWSNT

 /* Read keyboard input into the standard buffer,
    waiting for at least one character.  */
@@ -2616,6 +2713,8 @@
 void
 read_input_waiting ()
 {
+  /* XXX This needs to be updated for multi-tty support.  Is there
+     anybody who needs to emulate select these days?  */
   int nread, i;
   extern int quit_char;

@@ -2669,6 +2768,10 @@
     }
 }

+#if !defined (HAVE_SELECT) || defined (BROKEN_SELECT_NON_X)
+#define select sys_select
+#endif
+
 #endif /* not HAVE_SELECT */
 #endif /* not VMS */
 #endif /* not MSDOS */
@@ -2685,12 +2788,13 @@
 }

 void
-reset_sigio ()
+reset_sigio (fd)
+     int fd;
 {
   if (noninteractive)
     return;
   lmode = ~LINTRUP & lmode;
-  ioctl (0, TIOCLSET, &lmode);
+  ioctl (fd, TIOCLSET, &lmode);
 }

 void
@@ -3138,7 +3242,7 @@
 #undef abort
 sys_abort ()
 {
-  reset_sys_modes ();
+  reset_all_sys_modes ();
   LIB$SIGNAL (SS$_DEBUG);
 }
 #endif /* abort */
@@ -3455,7 +3559,7 @@
      char *badfunc;
 {
   printf ("%s not yet implemented\r\n", badfunc);
-  reset_sys_modes ();
+  reset_all_sys_modes ();
   exit (1);
 }

@@ -5043,7 +5147,7 @@
      char *badfunc;
 {
   printf ("%s not yet implemented\r\n", badfunc);
-  reset_sys_modes ();
+  reset_all_sys_modes ();
   exit (1);
 }

@@ -5065,7 +5169,7 @@

 /* Called from init_sys_modes.  */
 void
-hft_init ()
+hft_init (struct tty_display_info *tty_out)
 {
   int junk;

@@ -5111,15 +5215,12 @@
     keymap.hfkey[1].hf_char = 127;
     hftctl (0, HFSKBD, &buf);
   }
-  /* The HFT system on AIX doesn't optimize for scrolling, so it's really ugly
-     at times.  */
-  line_ins_del_ok = char_ins_del_ok = 0;
 }

 /* Reset the rubout key to backspace.  */

 void
-hft_reset ()
+hft_reset (struct tty_display_info *tty_out)
 {
   struct hfbuf buf;
   struct hfkeymap keymap;
--- a/src/syssignal.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/syssignal.h	Mon Oct 25 18:17:28 2004 +0000
@@ -27,6 +27,7 @@
    indicate that SIGIO doesn't work by #undef-ing SIGIO.  If this file
    #includes <signal.h>, then that will re-#define SIGIO and confuse
    things.  */
+/* XXX This is not correct anymore, there is a BROKEN_SIGIO macro. */

 #define SIGMASKTYPE sigset_t
--- a/src/term.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/term.c	Mon Oct 25 18:17:28 2004 +0000
@@ -26,9 +26,19 @@
 #include <ctype.h>
 #include <string.h>

+#include <sys/file.h>
+
+#include <unistd.h>             /* For isatty. */
+
+#if HAVE_TERMIOS_H
+#include <termios.h>		/* For TIOCNOTTY. */
+#endif
+
+#include <signal.h>
+
+#include "lisp.h"
 #include "termchar.h"
 #include "termopts.h"
-#include "lisp.h"
 #include "charset.h"
 #include "coding.h"
 #include "keyboard.h"
@@ -38,6 +48,8 @@
 #include "dispextern.h"
 #include "window.h"
 #include "keymap.h"
+#include "syssignal.h"
+#include "systty.h"

 /* For now, don't try to include termcap.h.  On some systems,
    configure finds a non-standard termcap.h that the main build
@@ -60,24 +72,44 @@
 #include "macterm.h"
 #endif

+#ifndef O_RDWR
+#define O_RDWR 2
+#endif
+
+#ifndef O_NOCTTY
+#define O_NOCTTY 0
+#endif
+
 static void turn_on_face P_ ((struct frame *, int face_id));
 static void turn_off_face P_ ((struct frame *, int face_id));
-static void tty_show_cursor P_ ((void));
-static void tty_hide_cursor P_ ((void));
-
-#define OUTPUT(a) \
-     tputs (a, (int) (FRAME_LINES (XFRAME (selected_frame)) - curY), cmputc)
-#define OUTPUT1(a) tputs (a, 1, cmputc)
-#define OUTPUTL(a, lines) tputs (a, lines, cmputc)
-
-#define OUTPUT_IF(a)							\
-     do {								\
-       if (a)								\
-         tputs (a, (int) (FRAME_LINES (XFRAME (selected_frame))	\
-			  - curY), cmputc);				\
-     } while (0)
-
-#define OUTPUT1_IF(a) do { if (a) tputs (a, 1, cmputc); } while (0)
+static void tty_show_cursor P_ ((struct tty_display_info *));
+static void tty_hide_cursor P_ ((struct tty_display_info *));
+
+static struct display *get_tty_display (Lisp_Object display);
+
+void delete_initial_display P_ ((struct display *));
+void create_tty_output P_ ((struct frame *));
+void delete_tty_output P_ ((struct frame *));
+
+#define OUTPUT(tty, a)                                          \
+  emacs_tputs ((tty), a,                                        \
+               (int) (FRAME_LINES (XFRAME (selected_frame))     \
+                      - curY (tty)),                            \
+               cmputc)
+
+#define OUTPUT1(tty, a) emacs_tputs ((tty), a, 1, cmputc)
+#define OUTPUTL(tty, a, lines) emacs_tputs ((tty), a, lines, cmputc)
+
+#define OUTPUT_IF(tty, a)                                               \
+  do {                                                                  \
+    if (a)                                                              \
+      emacs_tputs ((tty), a,                                            \
+                   (int) (FRAME_LINES (XFRAME (selected_frame))         \
+                          - curY (tty) ),                               \
+                   cmputc);                                             \
+  } while (0)
+
+#define OUTPUT1_IF(tty, a) do { if (a) emacs_tputs ((tty), a, 1, cmputc); } while (0)

 /* Display space properties */

@@ -87,203 +119,27 @@

 Lisp_Object Vring_bell_function;

-/* Terminal characteristics that higher levels want to look at.
-   These are all extern'd in termchar.h */
-
-int must_write_spaces;		/* Nonzero means spaces in the text
-				   must actually be output; can't just skip
-				   over some columns to leave them blank.  */
-int min_padding_speed;		/* Speed below which no padding necessary */
-
-int line_ins_del_ok;		/* Terminal can insert and delete lines */
-int char_ins_del_ok;		/* Terminal can insert and delete chars */
-int scroll_region_ok;		/* Terminal supports setting the
-				   scroll window */
-int scroll_region_cost;		/* Cost of setting a scroll window,
-				   measured in characters */
-int memory_below_frame;		/* Terminal remembers lines
-				   scrolled off bottom */
-int fast_clear_end_of_line;	/* Terminal has a `ce' string */
-
-/* Nonzero means no need to redraw the entire frame on resuming
-   a suspended Emacs.  This is useful on terminals with multiple pages,
-   where one page is used for Emacs and another for all else. */
-
+/* Functions to call after suspending a tty. */
+Lisp_Object Vsuspend_tty_functions;
+
+/* Functions to call after resuming a tty. */
+Lisp_Object Vresume_tty_functions;
+
+/* Chain of all displays currently in use. */
+struct display *display_list;
+
+/* The initial display device, created by initial_term_init. */
+struct display *initial_display;
+
+/* Chain of all tty device parameters. */
+struct tty_display_info *tty_list;
+
+/* Nonzero means no need to redraw the entire frame on resuming a
+   suspended Emacs.  This is useful on terminals with multiple
+   pages, where one page is used for Emacs and another for all
+   else. */
 int no_redraw_on_reenter;

-/* Hook functions that you can set to snap out the functions in this file.
-   These are all extern'd in termhooks.h  */
-
-void (*cursor_to_hook) P_ ((int, int));
-void (*raw_cursor_to_hook) P_ ((int, int));
-void (*clear_to_end_hook) P_ ((void));
-void (*clear_frame_hook) P_ ((void));
-void (*clear_end_of_line_hook) P_ ((int));
-
-void (*ins_del_lines_hook) P_ ((int, int));
-
-void (*delete_glyphs_hook) P_ ((int));
-
-void (*ring_bell_hook) P_ ((void));
-
-void (*reset_terminal_modes_hook) P_ ((void));
-void (*set_terminal_modes_hook) P_ ((void));
-void (*update_begin_hook) P_ ((struct frame *));
-void (*update_end_hook) P_ ((struct frame *));
-void (*set_terminal_window_hook) P_ ((int));
-void (*insert_glyphs_hook) P_ ((struct glyph *, int));
-void (*write_glyphs_hook) P_ ((struct glyph *, int));
-void (*delete_glyphs_hook) P_ ((int));
-
-int (*read_socket_hook) P_ ((int, int, struct input_event *));
-
-void (*frame_up_to_date_hook) P_ ((struct frame *));
-
-/* Return the current position of the mouse.
-
-   Set *f to the frame the mouse is in, or zero if the mouse is in no
-   Emacs frame.  If it is set to zero, all the other arguments are
-   garbage.
-
-   If the motion started in a scroll bar, set *bar_window to the
-   scroll bar's window, *part to the part the mouse is currently over,
-   *x to the position of the mouse along the scroll bar, and *y to the
-   overall length of the scroll bar.
-
-   Otherwise, set *bar_window to Qnil, and *x and *y to the column and
-   row of the character cell the mouse is over.
-
-   Set *time to the time the mouse was at the returned position.
-
-   This should clear mouse_moved until the next motion
-   event arrives.  */
-
-void (*mouse_position_hook) P_ ((FRAME_PTR *f, int insist,
-				 Lisp_Object *bar_window,
-				 enum scroll_bar_part *part,
-				 Lisp_Object *x,
-				 Lisp_Object *y,
-				 unsigned long *time));
-
-/* When reading from a minibuffer in a different frame, Emacs wants
-   to shift the highlight from the selected frame to the mini-buffer's
-   frame; under X, this means it lies about where the focus is.
-   This hook tells the window system code to re-decide where to put
-   the highlight.  */
-
-void (*frame_rehighlight_hook) P_ ((FRAME_PTR f));
-
-/* If we're displaying frames using a window system that can stack
-   frames on top of each other, this hook allows you to bring a frame
-   to the front, or bury it behind all the other windows.  If this
-   hook is zero, that means the device we're displaying on doesn't
-   support overlapping frames, so there's no need to raise or lower
-   anything.
-
-   If RAISE is non-zero, F is brought to the front, before all other
-   windows.  If RAISE is zero, F is sent to the back, behind all other
-   windows.  */
-
-void (*frame_raise_lower_hook) P_ ((FRAME_PTR f, int raise));
-
-/* Set the vertical scroll bar for WINDOW to have its upper left corner
-   at (TOP, LEFT), and be LENGTH rows high.  Set its handle to
-   indicate that we are displaying PORTION characters out of a total
-   of WHOLE characters, starting at POSITION.  If WINDOW doesn't yet
-   have a scroll bar, create one for it.  */
-
-void (*set_vertical_scroll_bar_hook)
-     P_ ((struct window *window,
-	  int portion, int whole, int position));
-
-
-/* The following three hooks are used when we're doing a thorough
-   redisplay of the frame.  We don't explicitly know which scroll bars
-   are going to be deleted, because keeping track of when windows go
-   away is a real pain - can you say set-window-configuration?
-   Instead, we just assert at the beginning of redisplay that *all*
-   scroll bars are to be removed, and then save scroll bars from the
-   fiery pit when we actually redisplay their window.  */
-
-/* Arrange for all scroll bars on FRAME to be removed at the next call
-   to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
-   `*redeem_scroll_bar_hook' is applied to its window before the judgment.
-
-   This should be applied to each frame each time its window tree is
-   redisplayed, even if it is not displaying scroll bars at the moment;
-   if the HAS_SCROLL_BARS flag has just been turned off, only calling
-   this and the judge_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-
-void (*condemn_scroll_bars_hook) P_ ((FRAME_PTR frame));
-
-/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
-   Note that it's okay to redeem a scroll bar that is not condemned.  */
-
-void (*redeem_scroll_bar_hook) P_ ((struct window *window));
-
-/* Remove all scroll bars on FRAME that haven't been saved since the
-   last call to `*condemn_scroll_bars_hook'.
-
-   This should be applied to each frame after each time its window
-   tree is redisplayed, even if it is not displaying scroll bars at the
-   moment; if the HAS_SCROLL_BARS flag has just been turned off, only
-   calling this and condemn_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-
-void (*judge_scroll_bars_hook) P_ ((FRAME_PTR FRAME));
-
-/* Strings, numbers and flags taken from the termcap entry.  */
-
-char *TS_ins_line;		/* "al" */
-char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
-char *TS_bell;			/* "bl" */
-char *TS_clr_to_bottom;		/* "cd" */
-char *TS_clr_line;		/* "ce", clear to end of line */
-char *TS_clr_frame;		/* "cl" */
-char *TS_set_scroll_region;	/* "cs" (2 params, first line and last line) */
-char *TS_set_scroll_region_1;   /* "cS" (4 params: total lines,
-				   lines above scroll region, lines below it,
-				   total lines again) */
-char *TS_del_char;		/* "dc" */
-char *TS_del_multi_chars;	/* "DC" (one parameter, # chars to delete) */
-char *TS_del_line;		/* "dl" */
-char *TS_del_multi_lines;	/* "DL" (one parameter, # lines to delete) */
-char *TS_delete_mode;		/* "dm", enter character-delete mode */
-char *TS_end_delete_mode;	/* "ed", leave character-delete mode */
-char *TS_end_insert_mode;	/* "ei", leave character-insert mode */
-char *TS_ins_char;		/* "ic" */
-char *TS_ins_multi_chars;	/* "IC" (one parameter, # chars to insert) */
-char *TS_insert_mode;		/* "im", enter character-insert mode */
-char *TS_pad_inserted_char;	/* "ip".  Just padding, no commands.  */
-char *TS_end_keypad_mode;	/* "ke" */
-char *TS_keypad_mode;		/* "ks" */
-char *TS_pad_char;		/* "pc", char to use as padding */
-char *TS_repeat;		/* "rp" (2 params, # times to repeat
-				   and character to be repeated) */
-char *TS_end_standout_mode;	/* "se" */
-char *TS_fwd_scroll;		/* "sf" */
-char *TS_standout_mode;		/* "so" */
-char *TS_rev_scroll;		/* "sr" */
-char *TS_end_termcap_modes;	/* "te" */
-char *TS_termcap_modes;		/* "ti" */
-char *TS_visible_bell;		/* "vb" */
-char *TS_cursor_normal;		/* "ve" */
-char *TS_cursor_visible;	/* "vs" */
-char *TS_cursor_invisible;	/* "vi" */
-char *TS_set_window;		/* "wi" (4 params, start and end of window,
-				   each as vpos and hpos) */
-
-/* Value of the "NC" (no_color_video) capability, or 0 if not
-   present.  */
-
-static int TN_no_color_video;

 /* Meaning of bits in no_color_video.  Each bit set means that the
    corresponding attribute cannot be combined with colors.  */
@@ -301,68 +157,6 @@
   NC_ALT_CHARSET = 1 << 8
 };

-/* "md" -- turn on bold (extra bright mode).  */
-
-char *TS_enter_bold_mode;
-
-/* "mh" -- turn on half-bright mode.  */
-
-char *TS_enter_dim_mode;
-
-/* "mb" -- enter blinking mode.  */
-
-char *TS_enter_blink_mode;
-
-/* "mr" -- enter reverse video mode.  */
-
-char *TS_enter_reverse_mode;
-
-/* "us"/"ue" -- start/end underlining.  */
-
-char *TS_exit_underline_mode, *TS_enter_underline_mode;
-
-/* "as"/"ae" -- start/end alternate character set.  Not really
-   supported, yet.  */
-
-char *TS_enter_alt_charset_mode, *TS_exit_alt_charset_mode;
-
-/* "me" -- switch appearances off.  */
-
-char *TS_exit_attribute_mode;
-
-/* "Co" -- number of colors.  */
-
-int TN_max_colors;
-
-/* "pa" -- max. number of color pairs on screen.  Not handled yet.
-   Could be a problem if not equal to TN_max_colors * TN_max_colors.  */
-
-int TN_max_pairs;
-
-/* "op" -- SVr4 set default pair to its original value.  */
-
-char *TS_orig_pair;
-
-/* "AF"/"AB" or "Sf"/"Sb"-- set ANSI or SVr4 foreground/background color.
-   1 param, the color index.  */
-
-char *TS_set_foreground, *TS_set_background;
-
-int TF_hazeltine;	/* termcap hz flag. */
-int TF_insmode_motion;	/* termcap mi flag: can move while in insert mode. */
-int TF_standout_motion;	/* termcap mi flag: can move while in standout mode. */
-int TF_underscore;	/* termcap ul flag: _ underlines if over-struck on
-			   non-blank position.  Must clear before writing _.  */
-int TF_teleray;		/* termcap xt flag: many weird consequences.
-			   For t1061. */
-
-static int RPov;	/* # chars to start a TS_repeat */
-
-static int delete_in_insert_mode;	/* delete mode == insert mode */
-
-static int se_is_so;	/* 1 if same string both enters and leaves
-			   standout mode */
-
 /* internal state */

 /* The largest frame width in any call to calculate_costs.  */
@@ -373,33 +167,17 @@

 int max_frame_lines;

-static int costs_set;	  /* Nonzero if costs have been calculated. */
-
-int insert_mode;			/* Nonzero when in insert mode.  */
-int standout_mode;			/* Nonzero when in standout mode.  */
-
-/* Size of window specified by higher levels.
-   This is the number of lines, from the top of frame downwards,
-   which can participate in insert-line/delete-line operations.
-
-   Effectively it excludes the bottom frame_lines - specified_window_size
-   lines from those operations.  */
-
-int specified_window;
-
-/* Frame currently being redisplayed; 0 if not currently redisplaying.
-   (Direct output does not count).  */
-
-FRAME_PTR updating_frame;
+/* Non-zero if we have dropped our controlling tty and therefore
+   should not open a frame on stdout. */
+static int no_controlling_tty;
+
+/* The first unallocated display id. */
+static int next_display_id;

 /* Provided for lisp packages.  */

 static int system_uses_terminfo;

-/* Flag used in tty_show/hide_cursor.  */
-
-static int tty_cursor_hidden;
-
 char *tparam ();

 extern char *tgetstr ();
@@ -417,7 +195,7 @@
 #endif /* WINDOWSNT */

 void
-ring_bell ()
+ring_bell (struct frame *f)
 {
   if (!NILP (Vring_bell_function))
     {
@@ -438,160 +216,189 @@

       Vring_bell_function = function;
     }
-  else if (!FRAME_TERMCAP_P (XFRAME (selected_frame)))
-    (*ring_bell_hook) ();
-  else
-    OUTPUT (TS_visible_bell && visible_bell ? TS_visible_bell : TS_bell);
+  else if (FRAME_DISPLAY (f)->ring_bell_hook)
+    (*FRAME_DISPLAY (f)->ring_bell_hook) (f);
 }

+/* Ring the bell on a tty. */
+
 void
-set_terminal_modes ()
+tty_ring_bell (struct frame *f)
 {
-  if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->output)
     {
-      OUTPUT_IF (TS_termcap_modes);
-      OUTPUT_IF (TS_cursor_visible);
-      OUTPUT_IF (TS_keypad_mode);
-      losecursor ();
+      OUTPUT (tty, (tty->TS_visible_bell && visible_bell
+                    ? tty->TS_visible_bell
+                    : tty->TS_bell));
+      fflush (tty->output);
     }
-  else
-    (*set_terminal_modes_hook) ();
 }

+/* Set up termcap modes for Emacs. */
+
 void
-reset_terminal_modes ()
+tty_set_terminal_modes (struct display *display)
 {
-  if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
+  struct tty_display_info *tty = display->display_info.tty;
+
+  if (tty->output)
     {
-      turn_off_highlight ();
-      turn_off_insert ();
-      OUTPUT_IF (TS_end_keypad_mode);
-      OUTPUT_IF (TS_cursor_normal);
-      OUTPUT_IF (TS_end_termcap_modes);
-      OUTPUT_IF (TS_orig_pair);
+      OUTPUT_IF (tty, tty->TS_termcap_modes);
+      OUTPUT_IF (tty, tty->TS_cursor_visible);
+      OUTPUT_IF (tty, tty->TS_keypad_mode);
+      losecursor (tty);
+    }
+}
+
+/* Reset termcap modes before exiting Emacs. */
+
+void
+tty_reset_terminal_modes (struct display *display)
+{
+  struct tty_display_info *tty = display->display_info.tty;
+
+  if (tty->output)
+    {
+      turn_off_highlight (tty);
+      turn_off_insert (tty);
+      OUTPUT_IF (tty, tty->TS_end_keypad_mode);
+      OUTPUT_IF (tty, tty->TS_cursor_normal);
+      OUTPUT_IF (tty, tty->TS_end_termcap_modes);
+      OUTPUT_IF (tty, tty->TS_orig_pair);
       /* Output raw CR so kernel can track the cursor hpos.  */
+      current_tty = tty;
       cmputc ('\r');
     }
-  else if (reset_terminal_modes_hook)
-    (*reset_terminal_modes_hook) ();
-}
-
-void
-update_begin (f)
-     struct frame *f;
-{
-  updating_frame = f;
-  if (!FRAME_TERMCAP_P (f))
-    update_begin_hook (f);
 }

 void
-update_end (f)
-     struct frame *f;
+update_begin (struct frame *f)
 {
-  if (FRAME_TERMCAP_P (f))
-    {
-      if (!XWINDOW (selected_window)->cursor_off_p)
-	tty_show_cursor ();
-      turn_off_insert ();
-      background_highlight ();
-    }
-  else
-    update_end_hook (f);
-
-  updating_frame = NULL;
+  if (FRAME_DISPLAY (f)->update_begin_hook)
+    (*FRAME_DISPLAY (f)->update_begin_hook) (f);
 }

 void
-set_terminal_window (size)
-     int size;
+update_end (struct frame *f)
+{
+  if (FRAME_DISPLAY (f)->update_end_hook)
+    (*FRAME_DISPLAY (f)->update_end_hook) (f);
+}
+
+/* Flag the end of a display update on a termcap display. */
+
+void
+tty_update_end (struct frame *f)
 {
-  if (FRAME_TERMCAP_P (updating_frame))
-    {
-      specified_window = size ? size : FRAME_LINES (updating_frame);
-      if (scroll_region_ok)
-	set_scroll_region (0, specified_window);
-    }
-  else
-    set_terminal_window_hook (size);
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (!XWINDOW (selected_window)->cursor_off_p)
+    tty_show_cursor (tty);
+  turn_off_insert (tty);
+  background_highlight (tty);
+}
+
+/* Specify how many text lines, from the top of the window,
+   should be affected by insert-lines and delete-lines operations.
+   This, and those operations, are used only within an update
+   that is bounded by calls to update_begin and update_end.  */
+
+void
+set_terminal_window (struct frame *f, int size)
+{
+  if (FRAME_DISPLAY (f)->set_terminal_window_hook)
+    (*FRAME_DISPLAY (f)->set_terminal_window_hook) (f, size);
+}
+
+/* The implementation of set_terminal_window for termcap frames. */
+
+void
+tty_set_terminal_window (struct frame *f, int size)
+{
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  tty->specified_window = size ? size : FRAME_LINES (f);
+  if (FRAME_SCROLL_REGION_OK (f))
+    set_scroll_region (f, 0, tty->specified_window);
 }

 void
-set_scroll_region (start, stop)
-     int start, stop;
+set_scroll_region (struct frame *f, int start, int stop)
 {
   char *buf;
-  struct frame *sf = XFRAME (selected_frame);
-
-  if (TS_set_scroll_region)
-    buf = tparam (TS_set_scroll_region, 0, 0, start, stop - 1);
-  else if (TS_set_scroll_region_1)
-    buf = tparam (TS_set_scroll_region_1, 0, 0,
-		  FRAME_LINES (sf), start,
-		  FRAME_LINES (sf) - stop,
-		  FRAME_LINES (sf));
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->TS_set_scroll_region)
+    buf = tparam (tty->TS_set_scroll_region, 0, 0, start, stop - 1);
+  else if (tty->TS_set_scroll_region_1)
+    buf = tparam (tty->TS_set_scroll_region_1, 0, 0,
+		  FRAME_LINES (f), start,
+		  FRAME_LINES (f) - stop,
+		  FRAME_LINES (f));
   else
-    buf = tparam (TS_set_window, 0, 0, start, 0, stop, FRAME_COLS (sf));
-
-  OUTPUT (buf);
+    buf = tparam (tty->TS_set_window, 0, 0, start, 0, stop, FRAME_COLS (f));
+
+  OUTPUT (tty, buf);
   xfree (buf);
-  losecursor ();
+  losecursor (tty);
 }


 static void
-turn_on_insert ()
+turn_on_insert (struct tty_display_info *tty)
 {
-  if (!insert_mode)
-    OUTPUT (TS_insert_mode);
-  insert_mode = 1;
+  if (!tty->insert_mode)
+    OUTPUT (tty, tty->TS_insert_mode);
+  tty->insert_mode = 1;
 }

 void
-turn_off_insert ()
+turn_off_insert (struct tty_display_info *tty)
 {
-  if (insert_mode)
-    OUTPUT (TS_end_insert_mode);
-  insert_mode = 0;
+  if (tty->insert_mode)
+    OUTPUT (tty, tty->TS_end_insert_mode);
+  tty->insert_mode = 0;
 }

 /* Handle highlighting.  */

 void
-turn_off_highlight ()
+turn_off_highlight (struct tty_display_info *tty)
 {
-  if (standout_mode)
-    OUTPUT_IF (TS_end_standout_mode);
-  standout_mode = 0;
+  if (tty->standout_mode)
+    OUTPUT_IF (tty, tty->TS_end_standout_mode);
+  tty->standout_mode = 0;
 }

 static void
-turn_on_highlight ()
+turn_on_highlight (struct tty_display_info *tty)
 {
-  if (!standout_mode)
-    OUTPUT_IF (TS_standout_mode);
-  standout_mode = 1;
+  if (!tty->standout_mode)
+    OUTPUT_IF (tty, tty->TS_standout_mode);
+  tty->standout_mode = 1;
 }

 static void
-toggle_highlight ()
+toggle_highlight (struct tty_display_info *tty)
 {
-  if (standout_mode)
-    turn_off_highlight ();
+  if (tty->standout_mode)
+    turn_off_highlight (tty);
   else
-    turn_on_highlight ();
+    turn_on_highlight (tty);
 }


 /* Make cursor invisible.  */

 static void
-tty_hide_cursor ()
+tty_hide_cursor (struct tty_display_info *tty)
 {
-  if (tty_cursor_hidden == 0)
+  if (tty->cursor_hidden == 0)
     {
-      tty_cursor_hidden = 1;
-      OUTPUT_IF (TS_cursor_invisible);
+      tty->cursor_hidden = 1;
+      OUTPUT_IF (tty, tty->TS_cursor_invisible);
     }
 }

@@ -599,13 +406,13 @@
 /* Ensure that cursor is visible.  */

 static void
-tty_show_cursor ()
+tty_show_cursor (struct tty_display_info *tty)
 {
-  if (tty_cursor_hidden)
+  if (tty->cursor_hidden)
     {
-      tty_cursor_hidden = 0;
-      OUTPUT_IF (TS_cursor_normal);
-      OUTPUT_IF (TS_cursor_visible);
+      tty->cursor_hidden = 0;
+      OUTPUT_IF (tty, tty->TS_cursor_normal);
+      OUTPUT_IF (tty, tty->TS_cursor_visible);
     }
 }

@@ -615,23 +422,23 @@
    depends on the user option inverse-video.  */

 void
-background_highlight ()
+background_highlight (struct tty_display_info *tty)
 {
   if (inverse_video)
-    turn_on_highlight ();
+    turn_on_highlight (tty);
   else
-    turn_off_highlight ();
+    turn_off_highlight (tty);
 }

 /* Set standout mode to the mode specified for the text to be output.  */

 static void
-highlight_if_desired ()
+highlight_if_desired (struct tty_display_info *tty)
 {
   if (inverse_video)
-    turn_on_highlight ();
+    turn_on_highlight (tty);
   else
-    turn_off_highlight ();
+    turn_off_highlight (tty);
 }


@@ -639,76 +446,85 @@
    frame-relative coordinates.  */

 void
-cursor_to (vpos, hpos)
-     int vpos, hpos;
+cursor_to (struct frame *f, int vpos, int hpos)
 {
-  struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
-
-  if (! FRAME_TERMCAP_P (f) && cursor_to_hook)
-    {
-      (*cursor_to_hook) (vpos, hpos);
-      return;
-    }
+  if (FRAME_DISPLAY (f)->cursor_to_hook)
+    (*FRAME_DISPLAY (f)->cursor_to_hook) (f, vpos, hpos);
+}
+
+void
+tty_cursor_to (struct frame *f, int vpos, int hpos)
+{
+  struct tty_display_info *tty = FRAME_TTY (f);

   /* Detect the case where we are called from reset_sys_modes
      and the costs have never been calculated.  Do nothing.  */
-  if (! costs_set)
+  if (! tty->costs_set)
     return;

-  if (curY == vpos && curX == hpos)
+  if (curY (tty) == vpos
+      && curX (tty) == hpos)
     return;
-  if (!TF_standout_motion)
-    background_highlight ();
-  if (!TF_insmode_motion)
-    turn_off_insert ();
-  cmgoto (vpos, hpos);
+  if (!tty->TF_standout_motion)
+    background_highlight (tty);
+  if (!tty->TF_insmode_motion)
+    turn_off_insert (tty);
+  cmgoto (tty, vpos, hpos);
 }

 /* Similar but don't take any account of the wasted characters.  */

 void
-raw_cursor_to (row, col)
-     int row, col;
+raw_cursor_to (struct frame *f, int row, int col)
+{
+  if (FRAME_DISPLAY (f)->raw_cursor_to_hook)
+    (*FRAME_DISPLAY (f)->raw_cursor_to_hook) (f, row, col);
+}
+
+void
+tty_raw_cursor_to (struct frame *f, int row, int col)
 {
-  struct frame *f = updating_frame ? updating_frame : XFRAME (selected_frame);
-  if (! FRAME_TERMCAP_P (f))
-    {
-      (*raw_cursor_to_hook) (row, col);
-      return;
-    }
-  if (curY == row && curX == col)
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (curY (tty) == row
+      && curX (tty) == col)
     return;
-  if (!TF_standout_motion)
-    background_highlight ();
-  if (!TF_insmode_motion)
-    turn_off_insert ();
-  cmgoto (row, col);
+  if (!tty->TF_standout_motion)
+    background_highlight (tty);
+  if (!tty->TF_insmode_motion)
+    turn_off_insert (tty);
+  cmgoto (tty, row, col);
 }

 /* Erase operations */

-/* clear from cursor to end of frame */
+/* Clear from cursor to end of frame. */
 void
-clear_to_end ()
+clear_to_end (struct frame *f)
+{
+  if (FRAME_DISPLAY (f)->clear_to_end_hook)
+    (*FRAME_DISPLAY (f)->clear_to_end_hook) (f);
+}
+
+/* Clear from cursor to end of frame on a termcap device. */
+
+void
+tty_clear_to_end (struct frame *f)
 {
   register int i;
-
-  if (clear_to_end_hook && ! FRAME_TERMCAP_P (updating_frame))
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->TS_clr_to_bottom)
     {
-      (*clear_to_end_hook) ();
-      return;
-    }
-  if (TS_clr_to_bottom)
-    {
-      background_highlight ();
-      OUTPUT (TS_clr_to_bottom);
+      background_highlight (tty);
+      OUTPUT (tty, tty->TS_clr_to_bottom);
     }
   else
     {
-      for (i = curY; i < FRAME_LINES (XFRAME (selected_frame)); i++)
+      for (i = curY (tty); i < FRAME_LINES (f); i++)
 	{
-	  cursor_to (i, 0);
-	  clear_end_of_line (FRAME_COLS (XFRAME (selected_frame)));
+	  cursor_to (f, i, 0);
+	  clear_end_of_line (f, FRAME_COLS (f));
 	}
     }
 }
@@ -716,26 +532,29 @@
 /* Clear entire frame */

 void
-clear_frame ()
+clear_frame (struct frame *f)
 {
-  struct frame *sf = XFRAME (selected_frame);
-
-  if (clear_frame_hook
-      && ! FRAME_TERMCAP_P ((updating_frame ? updating_frame : sf)))
+  if (FRAME_DISPLAY (f)->clear_frame_hook)
+    (*FRAME_DISPLAY (f)->clear_frame_hook) (f);
+}
+
+/* Clear an entire termcap frame. */
+
+void
+tty_clear_frame (struct frame *f)
+{
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->TS_clr_frame)
     {
-      (*clear_frame_hook) ();
-      return;
-    }
-  if (TS_clr_frame)
-    {
-      background_highlight ();
-      OUTPUT (TS_clr_frame);
-      cmat (0, 0);
+      background_highlight (tty);
+      OUTPUT (tty, tty->TS_clr_frame);
+      cmat (tty, 0, 0);
     }
   else
     {
-      cursor_to (0, 0);
-      clear_to_end ();
+      cursor_to (f, 0, 0);
+      clear_to_end (f);
     }
 }

@@ -745,49 +564,51 @@
    Note that the cursor may be moved, on terminals lacking a `ce' string.  */

 void
-clear_end_of_line (first_unused_hpos)
-     int first_unused_hpos;
+clear_end_of_line (struct frame *f, int first_unused_hpos)
+{
+  if (FRAME_DISPLAY (f)->clear_end_of_line_hook)
+    (*FRAME_DISPLAY (f)->clear_end_of_line_hook) (f, first_unused_hpos);
+}
+
+/* An implementation of clear_end_of_line for termcap frames.
+
+   Note that the cursor may be moved, on terminals lacking a `ce' string.  */
+
+void
+tty_clear_end_of_line (struct frame *f, int first_unused_hpos)
 {
   register int i;
-
-  if (clear_end_of_line_hook
-      && ! FRAME_TERMCAP_P ((updating_frame
-			       ? updating_frame
-			     : XFRAME (selected_frame))))
-    {
-      (*clear_end_of_line_hook) (first_unused_hpos);
-      return;
-    }
+  struct tty_display_info *tty = FRAME_TTY (f);

   /* Detect the case where we are called from reset_sys_modes
      and the costs have never been calculated.  Do nothing.  */
-  if (! costs_set)
+  if (! tty->costs_set)
     return;

-  if (curX >= first_unused_hpos)
+  if (curX (tty) >= first_unused_hpos)
     return;
-  background_highlight ();
-  if (TS_clr_line)
+  background_highlight (tty);
+  if (tty->TS_clr_line)
     {
-      OUTPUT1 (TS_clr_line);
+      OUTPUT1 (tty, tty->TS_clr_line);
     }
   else
     {			/* have to do it the hard way */
-      struct frame *sf = XFRAME (selected_frame);
-      turn_off_insert ();
+      turn_off_insert (tty);

       /* Do not write in last row last col with Auto-wrap on. */
-      if (AutoWrap && curY == FRAME_LINES (sf) - 1
-	  && first_unused_hpos == FRAME_COLS (sf))
+      if (AutoWrap (tty)
+          && curY (tty) == FrameRows (tty) - 1
+	  && first_unused_hpos == FrameCols (tty))
 	first_unused_hpos--;

-      for (i = curX; i < first_unused_hpos; i++)
+      for (i = curX (tty); i < first_unused_hpos; i++)
 	{
-	  if (termscript)
-	    fputc (' ', termscript);
-	  putchar (' ');
+	  if (tty->termscript)
+	    fputc (' ', tty->termscript);
+	  fputc (' ', tty->output);
 	}
-      cmplus (first_unused_hpos - curX);
+      cmplus (tty, first_unused_hpos - curX (tty));
     }
 }

@@ -800,11 +621,12 @@
    return value is the number of bytes store in DST.  */

 int
-encode_terminal_code (src, dst, src_len, dst_len, consumed)
-     struct glyph *src;
-     int src_len;
-     unsigned char *dst;
-     int dst_len, *consumed;
+encode_terminal_code (struct coding_system *coding,
+                      struct glyph *src,
+                      unsigned char *dst,
+                      int src_len,
+                      int dst_len,
+                      int *consumed)
 {
   struct glyph *src_start = src, *src_end = src + src_len;
   unsigned char *dst_start = dst, *dst_end = dst + dst_len;
@@ -815,13 +637,12 @@
   register int tlen = GLYPH_TABLE_LENGTH;
   register Lisp_Object *tbase = GLYPH_TABLE_BASE;
   int result;
-  struct coding_system *coding;
-
-  /* If terminal_coding does any conversion, use it, otherwise use
+
+  /* If the specified coding does any conversion, use it, otherwise use
      safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
-     because it always return 1 if the member src_multibyte is 1.  */
-  coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
-	    ? &terminal_coding
+     because it always returns 1 if the member src_multibyte is 1.  */
+  coding = (coding->common_flags & CODING_REQUIRE_ENCODING_MASK
+	    ? coding
 	    : &safe_terminal_coding);

   while (src < src_end)
@@ -900,42 +721,45 @@
 }


+/* Output LEN glyphs starting at STRING at the nominal cursor position.
+   Advance the nominal cursor over the text.  */
+
 void
-write_glyphs (string, len)
-     register struct glyph *string;
-     register int len;
+write_glyphs (struct frame *f, struct glyph *string, int len)
+{
+  if (FRAME_DISPLAY (f)->write_glyphs_hook)
+    (*FRAME_DISPLAY (f)->write_glyphs_hook) (f, string, len);
+}
+
+/* An implementation of write_glyphs for termcap frames. */
+
+void
+tty_write_glyphs (struct frame *f, struct glyph *string, int len)
 {
   int produced, consumed;
-  struct frame *sf = XFRAME (selected_frame);
-  struct frame *f = updating_frame ? updating_frame : sf;
   unsigned char conversion_buffer[1024];
   int conversion_buffer_size = sizeof conversion_buffer;

-  if (write_glyphs_hook
-      && ! FRAME_TERMCAP_P (f))
-    {
-      (*write_glyphs_hook) (string, len);
-      return;
-    }
-
-  turn_off_insert ();
-  tty_hide_cursor ();
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  turn_off_insert (tty);
+  tty_hide_cursor (tty);

   /* Don't dare write in last column of bottom line, if Auto-Wrap,
      since that would scroll the whole frame on some terminals.  */

-  if (AutoWrap
-      && curY + 1 == FRAME_LINES (sf)
-      && (curX + len) == FRAME_COLS (sf))
+  if (AutoWrap (tty)
+      && curY (tty) + 1 == FRAME_LINES (f)
+      && (curX (tty) + len) == FRAME_COLS (f))
     len --;
   if (len <= 0)
     return;

-  cmplus (len);
+  cmplus (tty, len);

   /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
      the tail.  */
-  terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+  FRAME_TERMINAL_CODING (f)->mode &= ~CODING_MODE_LAST_BLOCK;

   while (len > 0)
     {
@@ -948,7 +772,7 @@
 	  break;

       /* Turn appearance modes of the face of the run on.  */
-      highlight_if_desired ();
+      highlight_if_desired (tty);
       turn_on_face (f, face_id);

       while (n > 0)
@@ -956,16 +780,19 @@
 	  /* We use a fixed size (1024 bytes) of conversion buffer.
 	     Usually it is sufficient, but if not, we just repeat the
 	     loop.  */
-	  produced = encode_terminal_code (string, conversion_buffer,
+	  produced = encode_terminal_code (FRAME_TERMINAL_CODING (f),
+                                           string, conversion_buffer,
 					   n, conversion_buffer_size,
 					   &consumed);
 	  if (produced > 0)
 	    {
-	      fwrite (conversion_buffer, 1, produced, stdout);
-	      if (ferror (stdout))
-		clearerr (stdout);
-	      if (termscript)
-		fwrite (conversion_buffer, 1, produced, termscript);
+	      fwrite (conversion_buffer, 1, produced,
+                      tty->output);
+	      if (ferror (tty->output))
+		clearerr (tty->output);
+	      if (tty->termscript)
+		fwrite (conversion_buffer, 1, produced,
+                        tty->termscript);
 	    }
 	  len -= consumed;
 	  n -= consumed;
@@ -974,73 +801,77 @@

       /* Turn appearance modes off.  */
       turn_off_face (f, face_id);
-      turn_off_highlight ();
+      turn_off_highlight (tty);
     }

   /* We may have to output some codes to terminate the writing.  */
-  if (CODING_REQUIRE_FLUSHING (&terminal_coding))
+  if (CODING_REQUIRE_FLUSHING (FRAME_TERMINAL_CODING (f)))
     {
-      terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
-      encode_coding (&terminal_coding, "", conversion_buffer,
-		     0, conversion_buffer_size);
-      if (terminal_coding.produced > 0)
+      FRAME_TERMINAL_CODING (f)->mode |= CODING_MODE_LAST_BLOCK;
+      encode_coding (FRAME_TERMINAL_CODING (f), "",
+                     conversion_buffer, 0, conversion_buffer_size);
+      if (FRAME_TERMINAL_CODING (f)->produced > 0)
 	{
-	  fwrite (conversion_buffer, 1, terminal_coding.produced, stdout);
-	  if (ferror (stdout))
-	    clearerr (stdout);
-	  if (termscript)
-	    fwrite (conversion_buffer, 1, terminal_coding.produced,
-		    termscript);
+	  fwrite (conversion_buffer, 1,
+                  FRAME_TERMINAL_CODING (f)->produced,
+                  tty->output);
+	  if (ferror (tty->output))
+	    clearerr (tty->output);
+	  if (tty->termscript)
+	    fwrite (conversion_buffer, 1,
+                    FRAME_TERMINAL_CODING (f)->produced,
+		    tty->termscript);
 	}
     }

-  cmcheckmagic ();
+  cmcheckmagic (tty);
 }

-/* If start is zero, insert blanks instead of a string at start */
+/* Insert LEN glyphs from START at the nominal cursor position.
+
+   If start is zero, insert blanks instead of a string at start */

 void
-insert_glyphs (start, len)
-     register struct glyph *start;
-     register int len;
+insert_glyphs (struct frame *f, struct glyph *start, int len)
+{
+  if (len <= 0)
+    return;
+
+  if (FRAME_DISPLAY (f)->insert_glyphs_hook)
+    (*FRAME_DISPLAY (f)->insert_glyphs_hook) (f, start, len);
+}
+
+/* An implementation of insert_glyphs for termcap frames. */
+
+void
+tty_insert_glyphs (struct frame *f, struct glyph *start, int len)
 {
   char *buf;
   struct glyph *glyph = NULL;
-  struct frame *f, *sf;
-
-  if (len <= 0)
-    return;
-
-  if (insert_glyphs_hook)
+
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->TS_ins_multi_chars)
     {
-      (*insert_glyphs_hook) (start, len);
+      buf = tparam (tty->TS_ins_multi_chars, 0, 0, len);
+      OUTPUT1 (tty, buf);
+      xfree (buf);
+      if (start)
+	write_glyphs (f, start, len);
       return;
     }

-  sf = XFRAME (selected_frame);
-  f = updating_frame ? updating_frame : sf;
-
-  if (TS_ins_multi_chars)
-    {
-      buf = tparam (TS_ins_multi_chars, 0, 0, len);
-      OUTPUT1 (buf);
-      xfree (buf);
-      if (start)
-	write_glyphs (start, len);
-      return;
-    }
-
-  turn_on_insert ();
-  cmplus (len);
+  turn_on_insert (tty);
+  cmplus (tty, len);
   /* The bit CODING_MODE_LAST_BLOCK should be set to 1 only at the tail.  */
-  terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+  FRAME_TERMINAL_CODING (f)->mode &= ~CODING_MODE_LAST_BLOCK;
   while (len-- > 0)
     {
       int produced, consumed;
       unsigned char conversion_buffer[1024];
       int conversion_buffer_size = sizeof conversion_buffer;

-      OUTPUT1_IF (TS_ins_char);
+      OUTPUT1_IF (tty, tty->TS_ins_char);
       if (!start)
 	{
 	  conversion_buffer[0] = SPACEGLYPH;
@@ -1048,7 +879,7 @@
 	}
       else
 	{
-	  highlight_if_desired ();
+	  highlight_if_desired (tty);
 	  turn_on_face (f, start->face_id);
 	  glyph = start;
 	  ++start;
@@ -1056,98 +887,107 @@
 	     occupies more than one column.  */
 	  while (len && CHAR_GLYPH_PADDING_P (*start))
 	    {
-	      OUTPUT1_IF (TS_ins_char);
+	      OUTPUT1_IF (tty, tty->TS_ins_char);
 	      start++, len--;
 	    }

 	  if (len <= 0)
 	    /* This is the last glyph.  */
-	    terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
+	    FRAME_TERMINAL_CODING (f)->mode |= CODING_MODE_LAST_BLOCK;

 	  /* The size of conversion buffer (1024 bytes) is surely
 	     sufficient for just one glyph.  */
-	  produced = encode_terminal_code (glyph, conversion_buffer, 1,
+	  produced = encode_terminal_code (FRAME_TERMINAL_CODING (f),
+                                           glyph, conversion_buffer, 1,
 					   conversion_buffer_size, &consumed);
 	}

       if (produced > 0)
 	{
-	  fwrite (conversion_buffer, 1, produced, stdout);
-	  if (ferror (stdout))
-	    clearerr (stdout);
-	  if (termscript)
-	    fwrite (conversion_buffer, 1, produced, termscript);
+	  fwrite (conversion_buffer, 1, produced,
+                  tty->output);
+	  if (ferror (tty->output))
+	    clearerr (tty->output);
+	  if (tty->termscript)
+	    fwrite (conversion_buffer, 1, produced,
+                    tty->termscript);
 	}

-      OUTPUT1_IF (TS_pad_inserted_char);
+      OUTPUT1_IF (tty, tty->TS_pad_inserted_char);
       if (start)
 	{
 	  turn_off_face (f, glyph->face_id);
-	  turn_off_highlight ();
+	  turn_off_highlight (tty);
 	}
     }

-  cmcheckmagic ();
+  cmcheckmagic (tty);
 }

+/* Delete N glyphs at the nominal cursor position. */
+
 void
-delete_glyphs (n)
-     register int n;
+delete_glyphs (struct frame *f, int n)
+{
+  if (FRAME_DISPLAY (f)->delete_glyphs_hook)
+    (*FRAME_DISPLAY (f)->delete_glyphs_hook) (f, n);
+}
+
+/* An implementation of delete_glyphs for termcap frames. */
+
+void
+tty_delete_glyphs (struct frame *f, int n)
 {
   char *buf;
   register int i;

-  if (delete_glyphs_hook && ! FRAME_TERMCAP_P (updating_frame))
+  struct tty_display_info *tty = FRAME_TTY (f);
+
+  if (tty->delete_in_insert_mode)
     {
-      (*delete_glyphs_hook) (n);
-      return;
-    }
-
-  if (delete_in_insert_mode)
-    {
-      turn_on_insert ();
+      turn_on_insert (tty);
     }
   else
     {
-      turn_off_insert ();
-      OUTPUT_IF (TS_delete_mode);
+      turn_off_insert (tty);
+      OUTPUT_IF (tty, tty->TS_delete_mode);
     }

-  if (TS_del_multi_chars)
+  if (tty->TS_del_multi_chars)
     {
-      buf = tparam (TS_del_multi_chars, 0, 0, n);
-      OUTPUT1 (buf);
+      buf = tparam (tty->TS_del_multi_chars, 0, 0, n);
+      OUTPUT1 (tty, buf);
       xfree (buf);
     }
   else
     for (i = 0; i < n; i++)
-      OUTPUT1 (TS_del_char);
-  if (!delete_in_insert_mode)
-    OUTPUT_IF (TS_end_delete_mode);
+      OUTPUT1 (tty, tty->TS_del_char);
+  if (!tty->delete_in_insert_mode)
+    OUTPUT_IF (tty, tty->TS_end_delete_mode);
 }

 /* Insert N lines at vpos VPOS.  If N is negative, delete -N lines.  */

 void
-ins_del_lines (vpos, n)
-     int vpos, n;
+ins_del_lines (struct frame *f, int vpos, int n)
 {
-  char *multi = n > 0 ? TS_ins_multi_lines : TS_del_multi_lines;
-  char *single = n > 0 ? TS_ins_line : TS_del_line;
-  char *scroll = n > 0 ? TS_rev_scroll : TS_fwd_scroll;
-  struct frame *sf;
+  if (FRAME_DISPLAY (f)->ins_del_lines_hook)
+    (*FRAME_DISPLAY (f)->ins_del_lines_hook) (f, vpos, n);
+}
+
+/* An implementation of ins_del_lines for termcap frames. */
+
+void
+tty_ins_del_lines (struct frame *f, int vpos, int n)
+{
+  struct tty_display_info *tty = FRAME_TTY (f);
+  char *multi = n > 0 ? tty->TS_ins_multi_lines : tty->TS_del_multi_lines;
+  char *single = n > 0 ? tty->TS_ins_line : tty->TS_del_line;
+  char *scroll = n > 0 ? tty->TS_rev_scroll : tty->TS_fwd_scroll;

   register int i = n > 0 ? n : -n;
   register char *buf;

-  if (ins_del_lines_hook && ! FRAME_TERMCAP_P (updating_frame))
-    {
-      (*ins_del_lines_hook) (vpos, n);
-      return;
-    }
-
-  sf = XFRAME (selected_frame);
-
   /* If the lines below the insertion are being pushed
      into the end of the window, this is the same as clearing;
      and we know the lines are already clear, since the matching
@@ -1155,45 +995,49 @@
   /* If the lines below the deletion are blank lines coming
      out of the end of the window, don't bother,
      as there will be a matching inslines later that will flush them. */
-  if (scroll_region_ok && vpos + i >= specified_window)
+  if (FRAME_SCROLL_REGION_OK (f)
+      && vpos + i >= tty->specified_window)
     return;
-  if (!memory_below_frame && vpos + i >= FRAME_LINES (sf))
+  if (!FRAME_MEMORY_BELOW_FRAME (f)
+      && vpos + i >= FRAME_LINES (f))
     return;
-
+
   if (multi)
     {
-      raw_cursor_to (vpos, 0);
-      background_highlight ();
+      raw_cursor_to (f, vpos, 0);
+      background_highlight (tty);
       buf = tparam (multi, 0, 0, i);
-      OUTPUT (buf);
+      OUTPUT (tty, buf);
       xfree (buf);
     }
   else if (single)
     {
-      raw_cursor_to (vpos, 0);
-      background_highlight ();
+      raw_cursor_to (f, vpos, 0);
+      background_highlight (tty);
       while (--i >= 0)
-	OUTPUT (single);
-      if (TF_teleray)
-	curX = 0;
+        OUTPUT (tty, single);
+      if (tty->TF_teleray)
+        curX (tty) = 0;
     }
   else
     {
-      set_scroll_region (vpos, specified_window);
+      set_scroll_region (f, vpos, tty->specified_window);
       if (n < 0)
-	raw_cursor_to (specified_window - 1, 0);
+        raw_cursor_to (f, tty->specified_window - 1, 0);
       else
-	raw_cursor_to (vpos, 0);
-      background_highlight ();
+        raw_cursor_to (f, vpos, 0);
+      background_highlight (tty);
       while (--i >= 0)
-	OUTPUTL (scroll, specified_window - vpos);
-      set_scroll_region (0, specified_window);
+        OUTPUTL (tty, scroll, tty->specified_window - vpos);
+      set_scroll_region (f, 0, tty->specified_window);
     }
-
-  if (!scroll_region_ok && memory_below_frame && n < 0)
+
+  if (!FRAME_SCROLL_REGION_OK (f)
+      && FRAME_MEMORY_BELOW_FRAME (f)
+      && n < 0)
     {
-      cursor_to (FRAME_LINES (sf) + n, 0);
-      clear_to_end ();
+      cursor_to (f, FRAME_LINES (f) + n, 0);
+      clear_to_end (f);
     }
 }

@@ -1201,8 +1045,7 @@
    not counting any line-dependent padding.  */

 int
-string_cost (str)
-     char *str;
+string_cost (char *str)
 {
   cost = 0;
   if (str)
@@ -1214,8 +1057,7 @@
    counting any line-dependent padding at one line.  */

 static int
-string_cost_one_line (str)
-     char *str;
+string_cost_one_line (char *str)
 {
   cost = 0;
   if (str)
@@ -1227,8 +1069,7 @@
    in tenths of characters.  */

 int
-per_line_cost (str)
-     register char *str;
+per_line_cost (char *str)
 {
   cost = 0;
   if (str)
@@ -1251,26 +1092,26 @@

 /* ARGSUSED */
 static void
-calculate_ins_del_char_costs (frame)
-     FRAME_PTR frame;
+calculate_ins_del_char_costs (struct frame *f)
 {
+  struct tty_display_info *tty = FRAME_TTY (f);
   int ins_startup_cost, del_startup_cost;
   int ins_cost_per_char, del_cost_per_char;
   register int i;
   register int *p;

-  if (TS_ins_multi_chars)
+  if (tty->TS_ins_multi_chars)
     {
       ins_cost_per_char = 0;
-      ins_startup_cost = string_cost_one_line (TS_ins_multi_chars);
+      ins_startup_cost = string_cost_one_line (tty->TS_ins_multi_chars);
     }
-  else if (TS_ins_char || TS_pad_inserted_char
-	   || (TS_insert_mode && TS_end_insert_mode))
+  else if (tty->TS_ins_char || tty->TS_pad_inserted_char
+	   || (tty->TS_insert_mode && tty->TS_end_insert_mode))
     {
-      ins_startup_cost = (30 * (string_cost (TS_insert_mode)
-				+ string_cost (TS_end_insert_mode))) / 100;
-      ins_cost_per_char = (string_cost_one_line (TS_ins_char)
-			   + string_cost_one_line (TS_pad_inserted_char));
+      ins_startup_cost = (30 * (string_cost (tty->TS_insert_mode)
+				+ string_cost (tty->TS_end_insert_mode))) / 100;
+      ins_cost_per_char = (string_cost_one_line (tty->TS_ins_char)
+			   + string_cost_one_line (tty->TS_pad_inserted_char));
     }
   else
     {
@@ -1278,18 +1119,18 @@
       ins_cost_per_char = 0;
     }

-  if (TS_del_multi_chars)
+  if (tty->TS_del_multi_chars)
     {
       del_cost_per_char = 0;
-      del_startup_cost = string_cost_one_line (TS_del_multi_chars);
+      del_startup_cost = string_cost_one_line (tty->TS_del_multi_chars);
     }
-  else if (TS_del_char)
+  else if (tty->TS_del_char)
     {
-      del_startup_cost = (string_cost (TS_delete_mode)
-			  + string_cost (TS_end_delete_mode));
-      if (delete_in_insert_mode)
+      del_startup_cost = (string_cost (tty->TS_delete_mode)
+			  + string_cost (tty->TS_end_delete_mode));
+      if (tty->delete_in_insert_mode)
 	del_startup_cost /= 2;
-      del_cost_per_char = string_cost_one_line (TS_del_char);
+      del_cost_per_char = string_cost_one_line (tty->TS_del_char);
     }
   else
     {
@@ -1298,75 +1139,80 @@
     }

   /* Delete costs are at negative offsets */
-  p = &char_ins_del_cost (frame)[0];
-  for (i = FRAME_COLS (frame); --i >= 0;)
+  p = &char_ins_del_cost (f)[0];
+  for (i = FRAME_COLS (f); --i >= 0;)
     *--p = (del_startup_cost += del_cost_per_char);

   /* Doing nothing is free */
-  p = &char_ins_del_cost (frame)[0];
+  p = &char_ins_del_cost (f)[0];
   *p++ = 0;

   /* Insert costs are at positive offsets */
-  for (i = FRAME_COLS (frame); --i >= 0;)
+  for (i = FRAME_COLS (f); --i >= 0;)
     *p++ = (ins_startup_cost += ins_cost_per_char);
 }

 void
-calculate_costs (frame)
-     FRAME_PTR frame;
+calculate_costs (struct frame *frame)
 {
-  register char *f = (TS_set_scroll_region
-		      ? TS_set_scroll_region
-		      : TS_set_scroll_region_1);
-
   FRAME_COST_BAUD_RATE (frame) = baud_rate;

-  scroll_region_cost = string_cost (f);
-
-  /* These variables are only used for terminal stuff.  They are allocated
-     once for the terminal frame of X-windows emacs, but not used afterwards.
-
-     char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
-     X turns off char_ins_del_ok. */
-
-  max_frame_lines = max (max_frame_lines, FRAME_LINES (frame));
-  max_frame_cols = max (max_frame_cols, FRAME_COLS (frame));
-
-  costs_set = 1;
-
-  if (char_ins_del_vector != 0)
-    char_ins_del_vector
-      = (int *) xrealloc (char_ins_del_vector,
-			  (sizeof (int)
-			   + 2 * max_frame_cols * sizeof (int)));
-  else
-    char_ins_del_vector
-      = (int *) xmalloc (sizeof (int)
-			 + 2 * max_frame_cols * sizeof (int));
-
-  bzero (char_ins_del_vector, (sizeof (int)
-			       + 2 * max_frame_cols * sizeof (int)));
-
-  if (f && (!TS_ins_line && !TS_del_line))
-    do_line_insertion_deletion_costs (frame,
-				      TS_rev_scroll, TS_ins_multi_lines,
-				      TS_fwd_scroll, TS_del_multi_lines,
-				      f, f, 1);
-  else
-    do_line_insertion_deletion_costs (frame,
-				      TS_ins_line, TS_ins_multi_lines,
-				      TS_del_line, TS_del_multi_lines,
-				      0, 0, 1);
-
-  calculate_ins_del_char_costs (frame);
-
-  /* Don't use TS_repeat if its padding is worse than sending the chars */
-  if (TS_repeat && per_line_cost (TS_repeat) * baud_rate < 9000)
-    RPov = string_cost (TS_repeat);
-  else
-    RPov = FRAME_COLS (frame) * 2;
-
-  cmcostinit ();		/* set up cursor motion costs */
+  if (FRAME_TERMCAP_P (frame))
+    {
+      struct tty_display_info *tty = FRAME_TTY (frame);
+      register char *f = (tty->TS_set_scroll_region
+                          ? tty->TS_set_scroll_region
+                          : tty->TS_set_scroll_region_1);
+
+      FRAME_SCROLL_REGION_COST (frame) = string_cost (f);
+
+      tty->costs_set = 1;
+
+      /* These variables are only used for terminal stuff.  They are
+         allocated once for the terminal frame of X-windows emacs, but not
+         used afterwards.
+
+         char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
+         X turns off char_ins_del_ok. */
+
+      max_frame_lines = max (max_frame_lines, FRAME_LINES (frame));
+      max_frame_cols = max (max_frame_cols, FRAME_COLS (frame));
+
+      if (char_ins_del_vector != 0)
+        char_ins_del_vector
+          = (int *) xrealloc (char_ins_del_vector,
+                              (sizeof (int)
+                               + 2 * max_frame_cols * sizeof (int)));
+      else
+        char_ins_del_vector
+          = (int *) xmalloc (sizeof (int)
+                             + 2 * max_frame_cols * sizeof (int));
+
+      bzero (char_ins_del_vector, (sizeof (int)
+                                   + 2 * max_frame_cols * sizeof (int)));
+
+
+      if (f && (!tty->TS_ins_line && !tty->TS_del_line))
+        do_line_insertion_deletion_costs (frame,
+                                          tty->TS_rev_scroll, tty->TS_ins_multi_lines,
+                                          tty->TS_fwd_scroll, tty->TS_del_multi_lines,
+                                          f, f, 1);
+      else
+        do_line_insertion_deletion_costs (frame,
+                                          tty->TS_ins_line, tty->TS_ins_multi_lines,
+                                          tty->TS_del_line, tty->TS_del_multi_lines,
+                                          0, 0, 1);
+
+      calculate_ins_del_char_costs (frame);
+
+      /* Don't use TS_repeat if its padding is worse than sending the chars */
+      if (tty->TS_repeat && per_line_cost (tty->TS_repeat) * baud_rate < 9000)
+        tty->RPov = string_cost (tty->TS_repeat);
+      else
+        tty->RPov = FRAME_COLS (frame) * 2;
+
+      cmcostinit (FRAME_TTY (frame)); /* set up cursor motion costs */
+    }
 }

 struct fkey_table {
@@ -1898,10 +1744,10 @@
    from them.  Some display attributes may not be used together with
    color; the termcap capability `NC' specifies which ones.  */

-#define MAY_USE_WITH_COLORS_P(ATTR)		\
-     (TN_max_colors > 0				\
-      ? (TN_no_color_video & (ATTR)) == 0	\
-      : 1)
+#define MAY_USE_WITH_COLORS_P(tty, ATTR)                \
+  (tty->TN_max_colors > 0				\
+   ? (tty->TN_no_color_video & (ATTR)) == 0             \
+   : 1)

 /* Turn appearances of face FACE_ID on tty frame F on.  */

@@ -1913,12 +1759,13 @@
   struct face *face = FACE_FROM_ID (f, face_id);
   long fg = face->foreground;
   long bg = face->background;
+  struct tty_display_info *tty = FRAME_TTY (f);

   /* Do this first because TS_end_standout_mode may be the same
      as TS_exit_attribute_mode, which turns all appearances off. */
-  if (MAY_USE_WITH_COLORS_P (NC_REVERSE))
+  if (MAY_USE_WITH_COLORS_P (tty, NC_REVERSE))
     {
-      if (TN_max_colors > 0)
+      if (tty->TN_max_colors > 0)
 	{
 	  if (fg >= 0 && bg >= 0)
 	    {
@@ -1932,13 +1779,13 @@
 	    {
 	      if (fg == FACE_TTY_DEFAULT_FG_COLOR
 		  || bg == FACE_TTY_DEFAULT_BG_COLOR)
-		toggle_highlight ();
+		toggle_highlight (tty);
 	    }
 	  else
 	    {
 	      if (fg == FACE_TTY_DEFAULT_BG_COLOR
 		  || bg == FACE_TTY_DEFAULT_FG_COLOR)
-		toggle_highlight ();
+		toggle_highlight (tty);
 	    }
 	}
       else
@@ -1949,53 +1796,53 @@
 	    {
 	      if (fg == FACE_TTY_DEFAULT_FG_COLOR
 		  || bg == FACE_TTY_DEFAULT_BG_COLOR)
-		toggle_highlight ();
+		toggle_highlight (tty);
 	    }
 	  else
 	    {
 	      if (fg == FACE_TTY_DEFAULT_BG_COLOR
 		  || bg == FACE_TTY_DEFAULT_FG_COLOR)
-		toggle_highlight ();
+		toggle_highlight (tty);
 	    }
 	}
     }

   if (face->tty_bold_p)
     {
-      if (MAY_USE_WITH_COLORS_P (NC_BOLD))
-	OUTPUT1_IF (TS_enter_bold_mode);
+      if (MAY_USE_WITH_COLORS_P (tty, NC_BOLD))
+	OUTPUT1_IF (tty, tty->TS_enter_bold_mode);
     }
   else if (face->tty_dim_p)
-    if (MAY_USE_WITH_COLORS_P (NC_DIM))
-      OUTPUT1_IF (TS_enter_dim_mode);
+    if (MAY_USE_WITH_COLORS_P (tty, NC_DIM))
+      OUTPUT1_IF (tty, tty->TS_enter_dim_mode);

   /* Alternate charset and blinking not yet used.  */
   if (face->tty_alt_charset_p
-      && MAY_USE_WITH_COLORS_P (NC_ALT_CHARSET))
-    OUTPUT1_IF (TS_enter_alt_charset_mode);
+      && MAY_USE_WITH_COLORS_P (tty, NC_ALT_CHARSET))
+    OUTPUT1_IF (tty, tty->TS_enter_alt_charset_mode);

   if (face->tty_blinking_p
-      && MAY_USE_WITH_COLORS_P (NC_BLINK))
-    OUTPUT1_IF (TS_enter_blink_mode);
-
-  if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (NC_UNDERLINE))
-    OUTPUT1_IF (TS_enter_underline_mode);
-
-  if (TN_max_colors > 0)
+      && MAY_USE_WITH_COLORS_P (tty, NC_BLINK))
+    OUTPUT1_IF (tty, tty->TS_enter_blink_mode);
+
+  if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (tty, NC_UNDERLINE))
+    OUTPUT1_IF (tty, tty->TS_enter_underline_mode);
+
+  if (tty->TN_max_colors > 0)
     {
       char *p;

-      if (fg >= 0 && TS_set_foreground)
+      if (fg >= 0 && tty->TS_set_foreground)
 	{
-	  p = tparam (TS_set_foreground, NULL, 0, (int) fg);
-	  OUTPUT (p);
+	  p = tparam (tty->TS_set_foreground, NULL, 0, (int) fg);
+	  OUTPUT (tty, p);
 	  xfree (p);
 	}

-      if (bg >= 0 && TS_set_background)
+      if (bg >= 0 && tty->TS_set_background)
 	{
-	  p = tparam (TS_set_background, NULL, 0, (int) bg);
-	  OUTPUT (p);
+	  p = tparam (tty->TS_set_background, NULL, 0, (int) bg);
+	  OUTPUT (tty, p);
 	  xfree (p);
 	}
     }
@@ -2010,10 +1857,11 @@
      int face_id;
 {
   struct face *face = FACE_FROM_ID (f, face_id);
+  struct tty_display_info *tty = FRAME_TTY (f);

   xassert (face != NULL);

-  if (TS_exit_attribute_mode)
+  if (tty->TS_exit_attribute_mode)
     {
       /* Capability "me" will turn off appearance modes double-bright,
 	 half-bright, reverse-video, standout, underline.  It may or
@@ -2025,32 +1873,32 @@
 	  || face->tty_blinking_p
 	  || face->tty_underline_p)
 	{
-	  OUTPUT1_IF (TS_exit_attribute_mode);
-	  if (strcmp (TS_exit_attribute_mode, TS_end_standout_mode) == 0)
-	    standout_mode = 0;
+	  OUTPUT1_IF (tty, tty->TS_exit_attribute_mode);
+	  if (strcmp (tty->TS_exit_attribute_mode, tty->TS_end_standout_mode) == 0)
+	    tty->standout_mode = 0;
 	}

       if (face->tty_alt_charset_p)
-	OUTPUT_IF (TS_exit_alt_charset_mode);
+	OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);
     }
   else
     {
       /* If we don't have "me" we can only have those appearances
 	 that have exit sequences defined.  */
       if (face->tty_alt_charset_p)
-	OUTPUT_IF (TS_exit_alt_charset_mode);
+	OUTPUT_IF (tty, tty->TS_exit_alt_charset_mode);

       if (face->tty_underline_p)
-	OUTPUT_IF (TS_exit_underline_mode);
+	OUTPUT_IF (tty, tty->TS_exit_underline_mode);
     }

   /* Switch back to default colors.  */
-  if (TN_max_colors > 0
+  if (tty->TN_max_colors > 0
       && ((face->foreground != FACE_TTY_DEFAULT_COLOR
 	   && face->foreground != FACE_TTY_DEFAULT_FG_COLOR)
 	  || (face->background != FACE_TTY_DEFAULT_COLOR
 	      && face->background != FACE_TTY_DEFAULT_BG_COLOR)))
-    OUTPUT1_IF (TS_orig_pair);
+    OUTPUT1_IF (tty, tty->TS_orig_pair);
 }


@@ -2059,46 +1907,53 @@
    colors FG and BG.  */

 int
-tty_capable_p (f, caps, fg, bg)
-     struct frame *f;
+tty_capable_p (tty, caps, fg, bg)
+     struct tty_display_info *tty;
      unsigned caps;
      unsigned long fg, bg;
 {
-#define TTY_CAPABLE_P_TRY(cap, TS, NC_bit)				\
-  if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(NC_bit)))	\
+#define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit)				\
+  if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit)))	\
     return 0;

-  TTY_CAPABLE_P_TRY (TTY_CAP_INVERSE,	TS_standout_mode, 	 NC_REVERSE);
-  TTY_CAPABLE_P_TRY (TTY_CAP_UNDERLINE, TS_enter_underline_mode, NC_UNDERLINE);
-  TTY_CAPABLE_P_TRY (TTY_CAP_BOLD, 	TS_enter_bold_mode, 	 NC_BOLD);
-  TTY_CAPABLE_P_TRY (TTY_CAP_DIM, 	TS_enter_dim_mode, 	 NC_DIM);
-  TTY_CAPABLE_P_TRY (TTY_CAP_BLINK, 	TS_enter_blink_mode, 	 NC_BLINK);
-  TTY_CAPABLE_P_TRY (TTY_CAP_ALT_CHARSET, TS_enter_alt_charset_mode, NC_ALT_CHARSET);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_INVERSE,	tty->TS_standout_mode, 	 	NC_REVERSE);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_UNDERLINE, 	tty->TS_enter_underline_mode, 	NC_UNDERLINE);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_BOLD, 	tty->TS_enter_bold_mode, 	NC_BOLD);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_DIM, 		tty->TS_enter_dim_mode, 	NC_DIM);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_BLINK, 	tty->TS_enter_blink_mode, 	NC_BLINK);
+  TTY_CAPABLE_P_TRY (tty, TTY_CAP_ALT_CHARSET, 	tty->TS_enter_alt_charset_mode, NC_ALT_CHARSET);

   /* We can do it!  */
   return 1;
 }

-
 /* Return non-zero if the terminal is capable to display colors.  */

 DEFUN ("tty-display-color-p", Ftty_display_color_p, Stty_display_color_p,
        0, 1, 0,
-       doc: /* Return non-nil if TTY can display colors on DISPLAY.  */)
+       doc: /* Return non-nil if the tty device that DISPLAY uses can display colors. */)
      (display)
      Lisp_Object display;
 {
-  return TN_max_colors > 0 ? Qt : Qnil;
+  struct display *d = get_tty_display (display);
+  if (!d)
+    return Qnil;
+  else
+    return d->display_info.tty->TN_max_colors > 0 ? Qt : Qnil;
 }

 /* Return the number of supported colors.  */
 DEFUN ("tty-display-color-cells", Ftty_display_color_cells,
        Stty_display_color_cells, 0, 1, 0,
-       doc: /* Return the number of colors supported by TTY on DISPLAY.  */)
+       doc: /* Return the number of colors supported by the tty device that DISPLAY uses.  */)
      (display)
      Lisp_Object display;
 {
-  return make_number (TN_max_colors);
+  struct display *d = get_tty_display (display);
+  if (!d)
+    return make_number (0);
+  else
+    return make_number (d->display_info.tty->TN_max_colors);
 }

 #ifndef WINDOWSNT
@@ -2106,8 +1961,7 @@
 /* Save or restore the default color-related capabilities of this
    terminal.  */
 static void
-tty_default_color_capabilities (save)
-     int save;
+tty_default_color_capabilities (struct tty_display_info *tty, int save)
 {
   static char
     *default_orig_pair, *default_set_foreground, *default_set_background;
@@ -2117,30 +1971,30 @@
     {
       if (default_orig_pair)
 	xfree (default_orig_pair);
-      default_orig_pair = TS_orig_pair ? xstrdup (TS_orig_pair) : NULL;
+      default_orig_pair = tty->TS_orig_pair ? xstrdup (tty->TS_orig_pair) : NULL;

       if (default_set_foreground)
 	xfree (default_set_foreground);
-      default_set_foreground = TS_set_foreground ? xstrdup (TS_set_foreground)
+      default_set_foreground = tty->TS_set_foreground ? xstrdup (tty->TS_set_foreground)
 			       : NULL;

       if (default_set_background)
 	xfree (default_set_background);
-      default_set_background = TS_set_background ? xstrdup (TS_set_background)
+      default_set_background = tty->TS_set_background ? xstrdup (tty->TS_set_background)
 			       : NULL;

-      default_max_colors = TN_max_colors;
-      default_max_pairs = TN_max_pairs;
-      default_no_color_video = TN_no_color_video;
+      default_max_colors = tty->TN_max_colors;
+      default_max_pairs = tty->TN_max_pairs;
+      default_no_color_video = tty->TN_no_color_video;
     }
   else
     {
-      TS_orig_pair = default_orig_pair;
-      TS_set_foreground = default_set_foreground;
-      TS_set_background = default_set_background;
-      TN_max_colors = default_max_colors;
-      TN_max_pairs = default_max_pairs;
-      TN_no_color_video = default_no_color_video;
+      tty->TS_orig_pair = default_orig_pair;
+      tty->TS_set_foreground = default_set_foreground;
+      tty->TS_set_background = default_set_background;
+      tty->TN_max_colors = default_max_colors;
+      tty->TN_max_pairs = default_max_pairs;
+      tty->TN_no_color_video = default_no_color_video;
     }
 }

@@ -2149,8 +2003,7 @@
    support; zero means set up for the default capabilities, the ones
    we saw at term_init time; -1 means turn off color support.  */
 void
-tty_setup_colors (mode)
-     int mode;
+tty_setup_colors (struct tty_display_info *tty, int mode)
 {
   /* Canonicalize all negative values of MODE.  */
   if (mode < -1)
@@ -2159,27 +2012,27 @@
   switch (mode)
     {
       case -1:	 /* no colors at all */
-	TN_max_colors = 0;
-	TN_max_pairs = 0;
-	TN_no_color_video = 0;
-	TS_set_foreground = TS_set_background = TS_orig_pair = NULL;
+	tty->TN_max_colors = 0;
+	tty->TN_max_pairs = 0;
+	tty->TN_no_color_video = 0;
+	tty->TS_set_foreground = tty->TS_set_background = tty->TS_orig_pair = NULL;
 	break;
       case 0:	 /* default colors, if any */
       default:
-	tty_default_color_capabilities (0);
+	tty_default_color_capabilities (tty, 0);
 	break;
       case 8:	/* 8 standard ANSI colors */
-	TS_orig_pair = "\033[0m";
+	tty->TS_orig_pair = "\033[0m";
 #ifdef TERMINFO
-	TS_set_foreground = "\033[3%p1%dm";
-	TS_set_background = "\033[4%p1%dm";
+	tty->TS_set_foreground = "\033[3%p1%dm";
+	tty->TS_set_background = "\033[4%p1%dm";
 #else
-	TS_set_foreground = "\033[3%dm";
-	TS_set_background = "\033[4%dm";
+	tty->TS_set_foreground = "\033[3%dm";
+	tty->TS_set_background = "\033[4%dm";
 #endif
-	TN_max_colors = 8;
-	TN_max_pairs = 64;
-	TN_no_color_video = 0;
+	tty->TN_max_colors = 8;
+	tty->TN_max_pairs = 64;
+	tty->TN_no_color_video = 0;
 	break;
     }
 }
@@ -2230,7 +2083,7 @@

   if (mode != old_mode)
     {
-      tty_setup_colors (mode);
+      tty_setup_colors (FRAME_TTY (f), mode);
       /*  This recomputes all the faces given the new color
 	  definitions.  */
       call0 (intern ("tty-set-up-initial-frame-faces"));
@@ -2241,13 +2094,223 @@
 #endif /* !WINDOWSNT */


+
+/* Return the display object specified by DISPLAY.  DISPLAY may be a
+   display id, a frame, or nil for the display device of the current
+   frame. */
+
+struct display *
+get_display (Lisp_Object display)
+{
+  if (NILP (display))
+    display = selected_frame;
+
+  if (! INTEGERP (display) && ! FRAMEP (display))
+    return NULL;
+
+  if (INTEGERP (display))
+    {
+      struct display *d;
+
+      for (d = display_list; d; d = d->next_display)
+        {
+          if (d->id == XINT (display))
+            return d;
+        }
+      return NULL;
+    }
+  else if (FRAMEP (display))
+    {
+      return FRAME_DISPLAY (XFRAME (display));
+    }
+  return NULL;
+}
+
+/* Return the tty display object specified by DISPLAY. */
+
+static struct display *
+get_tty_display (Lisp_Object display)
+{
+  struct display *d = get_display (display);
+
+  if (d && d->type == output_initial)
+    d = NULL;
+
+  if (d && d->type != output_termcap)
+    {
+#if 0   /* XXX We need a predicate as the first argument; find one. */
+      wrong_type_argument ("Not a termcap display", display);
+#else /* Until we fix the wrong_type_argument call above, simply throw
+         a dumb error. */
+      error ("DISPLAY is not a termcap display");
+#endif
+    }
+
+  return d;
+}
+
+/* Return the active termcap display that uses the tty device with the
+   given name.  If NAME is NULL, return the display corresponding to
+   our controlling terminal.
+
+   This function ignores suspended displays.
+
+   Returns NULL if the named terminal device is not opened.  */
+
+struct display *
+get_named_tty_display (name)
+     char *name;
+{
+  struct display *d;
+
+  for (d = display_list; d; d = d->next_display) {
+    if (d->type == output_termcap
+        && ((d->display_info.tty->name == 0 && name == 0)
+            || (name && d->display_info.tty->name
+                && !strcmp (d->display_info.tty->name, name)))
+        && DISPLAY_ACTIVE_P (d))
+      return d;
+  };
+
+  return 0;
+}
+
+
+
+DEFUN ("display-name", Fdisplay_name, Sdisplay_name, 0, 1, 0,
+       doc: /* Return the name of the device that DISPLAY uses.
+It is not guaranteed that the returned value is unique among opened displays.
+
+DISPLAY can be a display, a frame, or nil (meaning the selected
+frame's display). */)
+  (display)
+     Lisp_Object display;
+{
+  struct display *d = get_display (display);
+
+  if (!d)
+    wrong_type_argument (Qdisplay_live_p, display);
+
+  if (d->name)
+    return build_string (d->name);
+  else
+    return Qnil;
+}
+
+DEFUN ("display-tty-type", Fdisplay_tty_type, Sdisplay_tty_type, 0, 1, 0,
+       doc: /* Return the type of the TTY device that DISPLAY uses. */)
+  (display)
+     Lisp_Object display;
+{
+  struct display *d = get_display (display);
+
+  if (!d)
+    wrong_type_argument (Qdisplay_live_p, display);
+  if (d->type != output_termcap)
+    error ("Display %d is not a termcap display", d->id);
+
+  if (d->display_info.tty->type)
+    return build_string (d->display_info.tty->type);
+  else
+    return Qnil;
+}
+
+DEFUN ("display-controlling-tty-p", Fdisplay_controlling_tty_p, Sdisplay_controlling_tty_p, 0, 1, 0,
+       doc: /* Return non-nil if DISPLAY is on the controlling tty of the Emacs process. */)
+  (display)
+     Lisp_Object display;
+{
+  struct display *d = get_display (display);
+
+  if (!d)
+    wrong_type_argument (Qdisplay_live_p, display);
+
+  if (d->type != output_termcap || d->display_info.tty->name)
+    return Qnil;
+  else
+    return Qt;
+}
+
+
 /***********************************************************************
 			    Initialization
  ***********************************************************************/

+/* Create the bootstrap display device for the initial frame.
+   Returns a display of type output_initial. */
+
+struct display *
+init_initial_display (void)
+{
+  if (initialized || display_list || tty_list)
+    abort ();
+
+  initial_display = create_display ();
+  initial_display->type = output_initial;
+  initial_display->name = xstrdup ("initial_display");
+
+  initial_display->delete_display_hook = &delete_initial_display;
+  /* All other hooks are NULL. */
+
+  return initial_display;
+}
+
+/* Deletes the bootstrap display device.
+   Called through delete_display_hook. */
+
 void
-term_init (terminal_type)
-     char *terminal_type;
+delete_initial_display (struct display *display)
+{
+  if (display != initial_display)
+    abort ();
+
+  delete_display (display);
+  initial_display = NULL;
+}
+
+/* Drop the controlling terminal if fd is the same device. */
+void
+dissociate_if_controlling_tty (int fd)
+{
+  int pgid;
+  EMACS_GET_TTY_PGRP (fd, &pgid); /* If tcgetpgrp succeeds, fd is the ctty. */
+  if (pgid != -1)
+    {
+#if defined (USG) && !defined (BSD_PGRPS)
+      setpgrp ();
+      no_controlling_tty = 1;
+#else
+#ifdef TIOCNOTTY                /* Try BSD ioctls. */
+      sigblock (sigmask (SIGTTOU));
+      fd = emacs_open ("/dev/tty", O_RDWR, 0);
+      if (fd != -1 && ioctl (fd, TIOCNOTTY, 0) != -1)
+        {
+          no_controlling_tty = 1;
+        }
+      if (fd != -1)
+        emacs_close (fd);
+      sigunblock (sigmask (SIGTTOU));
+#else
+      /* Unknown system. */
+      croak ();
+#endif  /* ! TIOCNOTTY */
+#endif  /* ! USG */
+    }
+}
+
+/* Create a termcap display on the tty device with the given name and
+   type.
+
+   If NAME is NULL, then use the controlling tty, i.e., stdin/stdout.
+   Otherwise NAME should be a path to the tty device file,
+   e.g. "/dev/pts/7".
+
+   TERMINAL_TYPE is the termcap type of the device, e.g. "vt100".
+
+   If MUST_SUCCEED is true, then all errors are fatal. */
+
+struct display *
+term_init (char *name, char *terminal_type, int must_succeed)
 {
   char *area;
   char **address = &area;
@@ -2255,69 +2318,207 @@
   int buffer_size = 4096;
   register char *p;
   int status;
-  struct frame *sf = XFRAME (selected_frame);
+  struct tty_display_info *tty;
+  struct display *display;
+
+  static void maybe_fatal();
+
+  if (!terminal_type)
+    maybe_fatal (must_succeed, 0, 0,
+                 "Unknown terminal type",
+                 "Unknown terminal type");
+
+  /* If we already have an active display on the given device, use that.
+     If all displays are suspended, create a new one instead.  */
+  /* XXX Perhaps this should be made explicit by having term_init
+     always create a new display and separating display and frame
+     creation on Lisp level.  */
+  display = get_named_tty_display (name);
+  if (display)
+    return display;
+
+  display = create_display ();
+  tty = (struct tty_display_info *) xmalloc (sizeof (struct tty_display_info));
+  bzero (tty, sizeof (struct tty_display_info));
+  tty->next = tty_list;
+  tty_list = tty;
+
+  display->type = output_termcap;
+  display->display_info.tty = tty;
+  tty->display = display;
+
+  tty->Wcm = (struct cm *) xmalloc (sizeof (struct cm));
+  Wcm_clear (tty);
+
+  display->rif = 0; /* ttys don't support window-based redisplay. */
+
+  display->cursor_to_hook = &tty_cursor_to;
+  display->raw_cursor_to_hook = &tty_raw_cursor_to;
+
+  display->clear_to_end_hook = &tty_clear_to_end;
+  display->clear_frame_hook = &tty_clear_frame;
+  display->clear_end_of_line_hook = &tty_clear_end_of_line;
+
+  display->ins_del_lines_hook = &tty_ins_del_lines;
+
+  display->insert_glyphs_hook = &tty_insert_glyphs;
+  display->write_glyphs_hook = &tty_write_glyphs;
+  display->delete_glyphs_hook = &tty_delete_glyphs;
+
+  display->ring_bell_hook = &tty_ring_bell;
+
+  display->reset_terminal_modes_hook = &tty_reset_terminal_modes;
+  display->set_terminal_modes_hook = &tty_set_terminal_modes;
+  display->update_begin_hook = 0; /* Not needed. */
+  display->update_end_hook = &tty_update_end;
+  display->set_terminal_window_hook = &tty_set_terminal_window;
+
+  display->mouse_position_hook = 0; /* Not needed. */
+  display->frame_rehighlight_hook = 0; /* Not needed. */
+  display->frame_raise_lower_hook = 0; /* Not needed. */
+
+  display->set_vertical_scroll_bar_hook = 0; /* Not needed. */
+  display->condemn_scroll_bars_hook = 0; /* Not needed. */
+  display->redeem_scroll_bar_hook = 0; /* Not needed. */
+  display->judge_scroll_bars_hook = 0; /* Not needed. */
+
+  display->read_socket_hook = &tty_read_avail_input; /* keyboard.c */
+  display->frame_up_to_date_hook = 0; /* Not needed. */
+
+  display->delete_frame_hook = &delete_tty_output;
+  display->delete_display_hook = &delete_tty;
+
+  if (name)
+    {
+      int fd;
+      FILE *file;
+
+#ifdef O_IGNORE_CTTY
+      /* Open the terminal device.  Don't recognize it as our
+         controlling terminal, and don't make it the controlling tty
+         if we don't have one at the moment.  */
+      fd = emacs_open (name, O_RDWR | O_IGNORE_CTTY | O_NOCTTY, 0);
+#else
+      /* Alas, O_IGNORE_CTTY is a GNU extension that seems to be only
+         defined on Hurd.  On other systems, we need to dissociate
+         ourselves from the controlling tty when we want to open a
+         frame on the same terminal.  */
+
+      fd = emacs_open (name, O_RDWR | O_NOCTTY, 0);
+
+#endif /* O_IGNORE_CTTY */
+
+      if (fd < 0)
+        {
+          delete_tty (display);
+          error ("Could not open file: %s", name);
+        }
+      if (! isatty (fd))
+        {
+          close (fd);
+          error ("Not a tty device: %s", name);
+        }
+
+      dissociate_if_controlling_tty (fd);
+
+      file = fdopen (fd, "w+");
+      tty->name = xstrdup (name);
+      display->name = xstrdup (name);
+      tty->input = file;
+      tty->output = file;
+    }
+  else
+    {
+      if (no_controlling_tty)
+        {
+          /* Opening a frame on stdout is unsafe if we have
+             disconnected our controlling terminal. */
+          error ("There is no controlling terminal any more");
+        }
+      tty->name = 0;
+      display->name = xstrdup (ttyname (0));
+      tty->input = stdin;
+      tty->output = stdout;
+    }
+
+  tty->type = xstrdup (terminal_type);
+
+  add_keyboard_wait_descriptor (fileno (tty->input));

 #ifdef WINDOWSNT
   initialize_w32_display ();

-  Wcm_clear ();
+  Wcm_clear (tty);

   area = (char *) xmalloc (2044);

-  FrameRows = FRAME_LINES (sf);
-  FrameCols = FRAME_COLS (sf);
-  specified_window = FRAME_LINES (sf);
-
-  delete_in_insert_mode = 1;
-
-  UseTabs = 0;
-  scroll_region_ok = 0;
+  FrameRows (tty) = FRAME_LINES (f); /* XXX */
+  FrameCols (tty) = FRAME_COLS (f);  /* XXX */
+  tty->specified_window = FRAME_LINES (f); /* XXX */
+
+  tty->display->delete_in_insert_mode = 1;
+
+  UseTabs (tty) = 0;
+  display->scroll_region_ok = 0;

   /* Seems to insert lines when it's not supposed to, messing
      up the display.  In doing a trace, it didn't seem to be
      called much, so I don't think we're losing anything by
      turning it off.  */
-
-  line_ins_del_ok = 0;
-  char_ins_del_ok = 1;
+  display->line_ins_del_ok = 0;
+  display->char_ins_del_ok = 1;

   baud_rate = 19200;

-  FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
-  FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
+  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0; /* XXX */
+  FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none; /* XXX */
   TN_max_colors = 16;  /* Required to be non-zero for tty-display-color-p */

-  return;
+  return display;
 #else  /* not WINDOWSNT */

-  Wcm_clear ();
+  Wcm_clear (tty);

   buffer = (char *) xmalloc (buffer_size);
+
+  /* On some systems, tgetent tries to access the controlling
+     terminal. */
+  sigblock (sigmask (SIGTTOU));
   status = tgetent (buffer, terminal_type);
+  sigunblock (sigmask (SIGTTOU));
+
   if (status < 0)
     {
 #ifdef TERMINFO
-      fatal ("Cannot open terminfo database file");
+      maybe_fatal (must_succeed, buffer, display,
+                   "Cannot open terminfo database file",
+                   "Cannot open terminfo database file");
 #else
-      fatal ("Cannot open termcap database file");
+      maybe_fatal (must_succeed, buffer, display,
+                   "Cannot open termcap database file",
+                   "Cannot open termcap database file");
 #endif
     }
   if (status == 0)
     {
 #ifdef TERMINFO
-      fatal ("Terminal type %s is not defined.\n\
+      maybe_fatal (must_succeed, buffer, display,
+                   "Terminal type %s is not defined",
+                   "Terminal type %s is not defined.\n\
 If that is not the actual type of terminal you have,\n\
 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 `setenv TERM ...') to specify the correct type.  It may be necessary\n\
 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
-	     terminal_type);
+                   terminal_type);
 #else
-      fatal ("Terminal type %s is not defined.\n\
+      maybe_fatal (must_succeed, buffer, display,
+                   "Terminal type %s is not defined",
+                   "Terminal type %s is not defined.\n\
 If that is not the actual type of terminal you have,\n\
 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 `setenv TERM ...') to specify the correct type.  It may be necessary\n\
 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
-	     terminal_type);
+                   terminal_type);
 #endif
     }

@@ -2328,219 +2529,221 @@
 #endif
   area = (char *) xmalloc (buffer_size);

-  TS_ins_line = tgetstr ("al", address);
-  TS_ins_multi_lines = tgetstr ("AL", address);
-  TS_bell = tgetstr ("bl", address);
-  BackTab = tgetstr ("bt", address);
-  TS_clr_to_bottom = tgetstr ("cd", address);
-  TS_clr_line = tgetstr ("ce", address);
-  TS_clr_frame = tgetstr ("cl", address);
-  ColPosition = NULL; /* tgetstr ("ch", address); */
-  AbsPosition = tgetstr ("cm", address);
-  CR = tgetstr ("cr", address);
-  TS_set_scroll_region = tgetstr ("cs", address);
-  TS_set_scroll_region_1 = tgetstr ("cS", address);
-  RowPosition = tgetstr ("cv", address);
-  TS_del_char = tgetstr ("dc", address);
-  TS_del_multi_chars = tgetstr ("DC", address);
-  TS_del_line = tgetstr ("dl", address);
-  TS_del_multi_lines = tgetstr ("DL", address);
-  TS_delete_mode = tgetstr ("dm", address);
-  TS_end_delete_mode = tgetstr ("ed", address);
-  TS_end_insert_mode = tgetstr ("ei", address);
-  Home = tgetstr ("ho", address);
-  TS_ins_char = tgetstr ("ic", address);
-  TS_ins_multi_chars = tgetstr ("IC", address);
-  TS_insert_mode = tgetstr ("im", address);
-  TS_pad_inserted_char = tgetstr ("ip", address);
-  TS_end_keypad_mode = tgetstr ("ke", address);
-  TS_keypad_mode = tgetstr ("ks", address);
-  LastLine = tgetstr ("ll", address);
-  Right = tgetstr ("nd", address);
-  Down = tgetstr ("do", address);
-  if (!Down)
-    Down = tgetstr ("nl", address); /* Obsolete name for "do" */
+  tty->TS_ins_line = tgetstr ("al", address);
+  tty->TS_ins_multi_lines = tgetstr ("AL", address);
+  tty->TS_bell = tgetstr ("bl", address);
+  BackTab (tty) = tgetstr ("bt", address);
+  tty->TS_clr_to_bottom = tgetstr ("cd", address);
+  tty->TS_clr_line = tgetstr ("ce", address);
+  tty->TS_clr_frame = tgetstr ("cl", address);
+  ColPosition (tty) = NULL; /* tgetstr ("ch", address); */
+  AbsPosition (tty) = tgetstr ("cm", address);
+  CR (tty) = tgetstr ("cr", address);
+  tty->TS_set_scroll_region = tgetstr ("cs", address);
+  tty->TS_set_scroll_region_1 = tgetstr ("cS", address);
+  RowPosition (tty) = tgetstr ("cv", address);
+  tty->TS_del_char = tgetstr ("dc", address);
+  tty->TS_del_multi_chars = tgetstr ("DC", address);
+  tty->TS_del_line = tgetstr ("dl", address);
+  tty->TS_del_multi_lines = tgetstr ("DL", address);
+  tty->TS_delete_mode = tgetstr ("dm", address);
+  tty->TS_end_delete_mode = tgetstr ("ed", address);
+  tty->TS_end_insert_mode = tgetstr ("ei", address);
+  Home (tty) = tgetstr ("ho", address);
+  tty->TS_ins_char = tgetstr ("ic", address);
+  tty->TS_ins_multi_chars = tgetstr ("IC", address);
+  tty->TS_insert_mode = tgetstr ("im", address);
+  tty->TS_pad_inserted_char = tgetstr ("ip", address);
+  tty->TS_end_keypad_mode = tgetstr ("ke", address);
+  tty->TS_keypad_mode = tgetstr ("ks", address);
+  LastLine (tty) = tgetstr ("ll", address);
+  Right (tty) = tgetstr ("nd", address);
+  Down (tty) = tgetstr ("do", address);
+  if (!Down (tty))
+    Down (tty) = tgetstr ("nl", address); /* Obsolete name for "do" */
 #ifdef VMS
   /* VMS puts a carriage return before each linefeed,
      so it is not safe to use linefeeds.  */
-  if (Down && Down[0] == '\n' && Down[1] == '\0')
-    Down = 0;
+  if (Down (tty) && Down (tty)[0] == '\n' && Down (tty)[1] == '\0')
+    Down (tty) = 0;
 #endif /* VMS */
   if (tgetflag ("bs"))
-    Left = "\b";		  /* can't possibly be longer! */
+    Left (tty) = "\b";		  /* can't possibly be longer! */
   else				  /* (Actually, "bs" is obsolete...) */
-    Left = tgetstr ("le", address);
-  if (!Left)
-    Left = tgetstr ("bc", address); /* Obsolete name for "le" */
-  TS_pad_char = tgetstr ("pc", address);
-  TS_repeat = tgetstr ("rp", address);
-  TS_end_standout_mode = tgetstr ("se", address);
-  TS_fwd_scroll = tgetstr ("sf", address);
-  TS_standout_mode = tgetstr ("so", address);
-  TS_rev_scroll = tgetstr ("sr", address);
-  Wcm.cm_tab = tgetstr ("ta", address);
-  TS_end_termcap_modes = tgetstr ("te", address);
-  TS_termcap_modes = tgetstr ("ti", address);
-  Up = tgetstr ("up", address);
-  TS_visible_bell = tgetstr ("vb", address);
-  TS_cursor_normal = tgetstr ("ve", address);
-  TS_cursor_visible = tgetstr ("vs", address);
-  TS_cursor_invisible = tgetstr ("vi", address);
-  TS_set_window = tgetstr ("wi", address);
-
-  TS_enter_underline_mode = tgetstr ("us", address);
-  TS_exit_underline_mode = tgetstr ("ue", address);
-  TS_enter_bold_mode = tgetstr ("md", address);
-  TS_enter_dim_mode = tgetstr ("mh", address);
-  TS_enter_blink_mode = tgetstr ("mb", address);
-  TS_enter_reverse_mode = tgetstr ("mr", address);
-  TS_enter_alt_charset_mode = tgetstr ("as", address);
-  TS_exit_alt_charset_mode = tgetstr ("ae", address);
-  TS_exit_attribute_mode = tgetstr ("me", address);
-
-  MultiUp = tgetstr ("UP", address);
-  MultiDown = tgetstr ("DO", address);
-  MultiLeft = tgetstr ("LE", address);
-  MultiRight = tgetstr ("RI", address);
+    Left (tty) = tgetstr ("le", address);
+  if (!Left (tty))
+    Left (tty) = tgetstr ("bc", address); /* Obsolete name for "le" */
+  tty->TS_pad_char = tgetstr ("pc", address);
+  tty->TS_repeat = tgetstr ("rp", address);
+  tty->TS_end_standout_mode = tgetstr ("se", address);
+  tty->TS_fwd_scroll = tgetstr ("sf", address);
+  tty->TS_standout_mode = tgetstr ("so", address);
+  tty->TS_rev_scroll = tgetstr ("sr", address);
+  tty->Wcm->cm_tab = tgetstr ("ta", address);
+  tty->TS_end_termcap_modes = tgetstr ("te", address);
+  tty->TS_termcap_modes = tgetstr ("ti", address);
+  Up (tty) = tgetstr ("up", address);
+  tty->TS_visible_bell = tgetstr ("vb", address);
+  tty->TS_cursor_normal = tgetstr ("ve", address);
+  tty->TS_cursor_visible = tgetstr ("vs", address);
+  tty->TS_cursor_invisible = tgetstr ("vi", address);
+  tty->TS_set_window = tgetstr ("wi", address);
+
+  tty->TS_enter_underline_mode = tgetstr ("us", address);
+  tty->TS_exit_underline_mode = tgetstr ("ue", address);
+  tty->TS_enter_bold_mode = tgetstr ("md", address);
+  tty->TS_enter_dim_mode = tgetstr ("mh", address);
+  tty->TS_enter_blink_mode = tgetstr ("mb", address);
+  tty->TS_enter_reverse_mode = tgetstr ("mr", address);
+  tty->TS_enter_alt_charset_mode = tgetstr ("as", address);
+  tty->TS_exit_alt_charset_mode = tgetstr ("ae", address);
+  tty->TS_exit_attribute_mode = tgetstr ("me", address);
+
+  MultiUp (tty) = tgetstr ("UP", address);
+  MultiDown (tty) = tgetstr ("DO", address);
+  MultiLeft (tty) = tgetstr ("LE", address);
+  MultiRight (tty) = tgetstr ("RI", address);

   /* SVr4/ANSI color suppert.  If "op" isn't available, don't support
      color because we can't switch back to the default foreground and
      background.  */
-  TS_orig_pair = tgetstr ("op", address);
-  if (TS_orig_pair)
+  tty->TS_orig_pair = tgetstr ("op", address);
+  if (tty->TS_orig_pair)
     {
-      TS_set_foreground = tgetstr ("AF", address);
-      TS_set_background = tgetstr ("AB", address);
-      if (!TS_set_foreground)
+      tty->TS_set_foreground = tgetstr ("AF", address);
+      tty->TS_set_background = tgetstr ("AB", address);
+      if (!tty->TS_set_foreground)
 	{
 	  /* SVr4.  */
-	  TS_set_foreground = tgetstr ("Sf", address);
-	  TS_set_background = tgetstr ("Sb", address);
+	  tty->TS_set_foreground = tgetstr ("Sf", address);
+	  tty->TS_set_background = tgetstr ("Sb", address);
 	}

-      TN_max_colors = tgetnum ("Co");
-      TN_max_pairs = tgetnum ("pa");
-
-      TN_no_color_video = tgetnum ("NC");
-      if (TN_no_color_video == -1)
-	TN_no_color_video = 0;
+      tty->TN_max_colors = tgetnum ("Co");
+      tty->TN_max_pairs = tgetnum ("pa");
+
+      tty->TN_no_color_video = tgetnum ("NC");
+      if (tty->TN_no_color_video == -1)
+        tty->TN_no_color_video = 0;
     }

-  tty_default_color_capabilities (1);
-
-  MagicWrap = tgetflag ("xn");
+  tty_default_color_capabilities (tty, 1);
+
+  MagicWrap (tty) = tgetflag ("xn");
   /* Since we make MagicWrap terminals look like AutoWrap, we need to have
      the former flag imply the latter.  */
-  AutoWrap = MagicWrap || tgetflag ("am");
-  memory_below_frame = tgetflag ("db");
-  TF_hazeltine = tgetflag ("hz");
-  must_write_spaces = tgetflag ("in");
-  meta_key = tgetflag ("km") || tgetflag ("MT");
-  TF_insmode_motion = tgetflag ("mi");
-  TF_standout_motion = tgetflag ("ms");
-  TF_underscore = tgetflag ("ul");
-  TF_teleray = tgetflag ("xt");
+  AutoWrap (tty) = MagicWrap (tty) || tgetflag ("am");
+  display->memory_below_frame = tgetflag ("db");
+  tty->TF_hazeltine = tgetflag ("hz");
+  display->must_write_spaces = tgetflag ("in");
+  tty->meta_key = tgetflag ("km") || tgetflag ("MT");
+  tty->TF_insmode_motion = tgetflag ("mi");
+  tty->TF_standout_motion = tgetflag ("ms");
+  tty->TF_underscore = tgetflag ("ul");
+  tty->TF_teleray = tgetflag ("xt");

   term_get_fkeys (address);

   /* Get frame size from system, or else from termcap.  */
   {
     int height, width;
-    get_frame_size (&width, &height);
-    FRAME_COLS (sf) = width;
-    FRAME_LINES (sf) = height;
+    get_tty_size (fileno (tty->input), &width, &height);
+    FrameCols (tty) = width;
+    FrameRows (tty) = height;
   }

-  if (FRAME_COLS (sf) <= 0)
-    SET_FRAME_COLS (sf, tgetnum ("co"));
-  else
-    /* Keep width and external_width consistent */
-    SET_FRAME_COLS (sf, FRAME_COLS (sf));
-  if (FRAME_LINES (sf) <= 0)
-    FRAME_LINES (sf) = tgetnum ("li");
-
-  if (FRAME_LINES (sf) < 3 || FRAME_COLS (sf) < 3)
-    fatal ("Screen size %dx%d is too small",
-	   FRAME_LINES (sf), FRAME_COLS (sf));
-
-  min_padding_speed = tgetnum ("pb");
-  TabWidth = tgetnum ("tw");
+  if (FrameCols (tty) <= 0)
+    FrameCols (tty) = tgetnum ("co");
+  if (FrameRows (tty) <= 0)
+    FrameRows (tty) = tgetnum ("li");
+
+  if (FrameRows (tty) < 3 || FrameCols (tty) < 3)
+    maybe_fatal (must_succeed, NULL, display,
+                 "Screen size %dx%d is too small"
+                 "Screen size %dx%d is too small",
+                 FrameCols (tty), FrameRows (tty));
+
+#if 0  /* This is not used anywhere. */
+  tty->display->min_padding_speed = tgetnum ("pb");
+#endif
+
+  TabWidth (tty) = tgetnum ("tw");

 #ifdef VMS
   /* These capabilities commonly use ^J.
      I don't know why, but sending them on VMS does not work;
      it causes following spaces to be lost, sometimes.
      For now, the simplest fix is to avoid using these capabilities ever.  */
-  if (Down && Down[0] == '\n')
-    Down = 0;
+  if (Down (tty) && Down (tty)[0] == '\n')
+    Down (tty) = 0;
 #endif /* VMS */

-  if (!TS_bell)
-    TS_bell = "\07";
-
-  if (!TS_fwd_scroll)
-    TS_fwd_scroll = Down;
-
-  PC = TS_pad_char ? *TS_pad_char : 0;
-
-  if (TabWidth < 0)
-    TabWidth = 8;
+  if (!tty->TS_bell)
+    tty->TS_bell = "\07";
+
+  if (!tty->TS_fwd_scroll)
+    tty->TS_fwd_scroll = Down (tty);
+
+  PC = tty->TS_pad_char ? *tty->TS_pad_char : 0;
+
+  if (TabWidth (tty) < 0)
+    TabWidth (tty) = 8;

 /* Turned off since /etc/termcap seems to have :ta= for most terminals
    and newer termcap doc does not seem to say there is a default.
-  if (!Wcm.cm_tab)
-    Wcm.cm_tab = "\t";
+  if (!tty->Wcm->cm_tab)
+    tty->Wcm->cm_tab = "\t";
 */

   /* We don't support standout modes that use `magic cookies', so
      turn off any that do.  */
-  if (TS_standout_mode && tgetnum ("sg") >= 0)
+  if (tty->TS_standout_mode && tgetnum ("sg") >= 0)
     {
-      TS_standout_mode = 0;
-      TS_end_standout_mode = 0;
+      tty->TS_standout_mode = 0;
+      tty->TS_end_standout_mode = 0;
     }
-  if (TS_enter_underline_mode && tgetnum ("ug") >= 0)
+  if (tty->TS_enter_underline_mode && tgetnum ("ug") >= 0)
     {
-      TS_enter_underline_mode = 0;
-      TS_exit_underline_mode = 0;
+      tty->TS_enter_underline_mode = 0;
+      tty->TS_exit_underline_mode = 0;
     }

   /* If there's no standout mode, try to use underlining instead.  */
-  if (TS_standout_mode == 0)
+  if (tty->TS_standout_mode == 0)
     {
-      TS_standout_mode = TS_enter_underline_mode;
-      TS_end_standout_mode = TS_exit_underline_mode;
+      tty->TS_standout_mode = tty->TS_enter_underline_mode;
+      tty->TS_end_standout_mode = tty->TS_exit_underline_mode;
     }

   /* If no `se' string, try using a `me' string instead.
      If that fails, we can't use standout mode at all.  */
-  if (TS_end_standout_mode == 0)
+  if (tty->TS_end_standout_mode == 0)
     {
       char *s = tgetstr ("me", address);
       if (s != 0)
-	TS_end_standout_mode = s;
+        tty->TS_end_standout_mode = s;
       else
-	TS_standout_mode = 0;
+        tty->TS_standout_mode = 0;
     }

-  if (TF_teleray)
+  if (tty->TF_teleray)
     {
-      Wcm.cm_tab = 0;
+      tty->Wcm->cm_tab = 0;
       /* We can't support standout mode, because it uses magic cookies.  */
-      TS_standout_mode = 0;
+      tty->TS_standout_mode = 0;
       /* But that means we cannot rely on ^M to go to column zero! */
-      CR = 0;
+      CR (tty) = 0;
       /* LF can't be trusted either -- can alter hpos */
       /* if move at column 0 thru a line with TS_standout_mode */
-      Down = 0;
+      Down (tty) = 0;
     }

   /* Special handling for certain terminal types known to need it */

   if (!strcmp (terminal_type, "supdup"))
     {
-      memory_below_frame = 1;
-      Wcm.cm_losewrap = 1;
+      display->memory_below_frame = 1;
+      tty->Wcm->cm_losewrap = 1;
     }
   if (!strncmp (terminal_type, "c10", 3)
       || !strcmp (terminal_type, "perq"))
@@ -2557,102 +2760,152 @@
 	 It would be simpler if the :wi string could go in the termcap
 	 entry, but it can't because it is not fully valid.
 	 If it were in the termcap entry, it would confuse other programs.  */
-      if (!TS_set_window)
+      if (!tty->TS_set_window)
 	{
-	  p = TS_termcap_modes;
+	  p = tty->TS_termcap_modes;
 	  while (*p && strcmp (p, "\033v  "))
 	    p++;
 	  if (*p)
-	    TS_set_window = "\033v%C %C %C %C ";
+	    tty->TS_set_window = "\033v%C %C %C %C ";
 	}
       /* Termcap entry often fails to have :in: flag */
-      must_write_spaces = 1;
+      display->must_write_spaces = 1;
       /* :ti string typically fails to have \E^G! in it */
       /* This limits scope of insert-char to one line.  */
-      strcpy (area, TS_termcap_modes);
+      strcpy (area, tty->TS_termcap_modes);
       strcat (area, "\033\007!");
-      TS_termcap_modes = area;
+      tty->TS_termcap_modes = area;
       area += strlen (area) + 1;
-      p = AbsPosition;
+      p = AbsPosition (tty);
       /* Change all %+ parameters to %C, to handle
-	 values above 96 correctly for the C100.  */
+         values above 96 correctly for the C100.  */
       while (*p)
-	{
-	  if (p[0] == '%' && p[1] == '+')
-	    p[1] = 'C';
-	  p++;
-	}
+        {
+          if (p[0] == '%' && p[1] == '+')
+            p[1] = 'C';
+          p++;
+        }
     }

-  FrameRows = FRAME_LINES (sf);
-  FrameCols = FRAME_COLS (sf);
-  specified_window = FRAME_LINES (sf);
-
-  if (Wcm_init () == -1)	/* can't do cursor motion */
+  tty->specified_window = FrameRows (tty);
+
+  if (Wcm_init (tty) == -1)	/* can't do cursor motion */
+    {
+      maybe_fatal (must_succeed, NULL, display,
+                   "Terminal type \"%s\" is not powerful enough to run Emacs",
 #ifdef VMS
-    fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
+                   "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
 It lacks the ability to position the cursor.\n\
 If that is not the actual type of terminal you have, use either the\n\
 DCL command `SET TERMINAL/DEVICE= ...' for DEC-compatible terminals,\n\
 or `define EMACS_TERM \"terminal type\"' for non-DEC terminals.",
-           terminal_type);
 #else /* not VMS */
 # ifdef TERMINFO
-    fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
+                   "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
 It lacks the ability to position the cursor.\n\
 If that is not the actual type of terminal you have,\n\
 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 `setenv TERM ...') to specify the correct type.  It may be necessary\n\
 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
-	   terminal_type);
 # else /* TERMCAP */
-    fatal ("Terminal type \"%s\" is not powerful enough to run Emacs.\n\
+                   "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
 It lacks the ability to position the cursor.\n\
 If that is not the actual type of terminal you have,\n\
 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 `setenv TERM ...') to specify the correct type.  It may be necessary\n\
 to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
-	   terminal_type);
 # endif /* TERMINFO */
 #endif /*VMS */
-  if (FRAME_LINES (sf) <= 0
-      || FRAME_COLS (sf) <= 0)
-    fatal ("The frame size has not been specified");
-
-  delete_in_insert_mode
-    = TS_delete_mode && TS_insert_mode
-      && !strcmp (TS_delete_mode, TS_insert_mode);
-
-  se_is_so = (TS_standout_mode
-	      && TS_end_standout_mode
-	      && !strcmp (TS_standout_mode, TS_end_standout_mode));
-
-  UseTabs = tabs_safe_p () && TabWidth == 8;
-
-  scroll_region_ok
-    = (Wcm.cm_abs
-       && (TS_set_window || TS_set_scroll_region || TS_set_scroll_region_1));
-
-  line_ins_del_ok = (((TS_ins_line || TS_ins_multi_lines)
-		      && (TS_del_line || TS_del_multi_lines))
-		     || (scroll_region_ok && TS_fwd_scroll && TS_rev_scroll));
-
-  char_ins_del_ok = ((TS_ins_char || TS_insert_mode
-		      || TS_pad_inserted_char || TS_ins_multi_chars)
-		     && (TS_del_char || TS_del_multi_chars));
-
-  fast_clear_end_of_line = TS_clr_line != 0;
-
-  init_baud_rate ();
-  if (read_socket_hook)		/* Baudrate is somewhat */
-				/* meaningless in this case */
-    baud_rate = 9600;
-
-  FRAME_CAN_HAVE_SCROLL_BARS (sf) = 0;
-  FRAME_VERTICAL_SCROLL_BAR_TYPE (sf) = vertical_scroll_bar_none;
-#endif /* WINDOWSNT */
-
-  xfree (buffer);
+                   terminal_type);
+    }
+
+  if (FrameRows (tty) <= 0 || FrameCols (tty) <= 0)
+    maybe_fatal (must_succeed, NULL, display,
+                 "Could not determine the frame size",
+                 "Could not determine the frame size");
+
+  tty->delete_in_insert_mode
+    = tty->TS_delete_mode && tty->TS_insert_mode
+    && !strcmp (tty->TS_delete_mode, tty->TS_insert_mode);
+
+  tty->se_is_so = (tty->TS_standout_mode
+              && tty->TS_end_standout_mode
+              && !strcmp (tty->TS_standout_mode, tty->TS_end_standout_mode));
+
+  UseTabs (tty) = tabs_safe_p (fileno (tty->input)) && TabWidth (tty) == 8;
+
+  display->scroll_region_ok
+    = (tty->Wcm->cm_abs
+       && (tty->TS_set_window || tty->TS_set_scroll_region || tty->TS_set_scroll_region_1));
+
+  display->line_ins_del_ok
+    = (((tty->TS_ins_line || tty->TS_ins_multi_lines)
+        && (tty->TS_del_line || tty->TS_del_multi_lines))
+       || (display->scroll_region_ok
+           && tty->TS_fwd_scroll && tty->TS_rev_scroll));
+
+  display->char_ins_del_ok
+    = ((tty->TS_ins_char || tty->TS_insert_mode
+        || tty->TS_pad_inserted_char || tty->TS_ins_multi_chars)
+       && (tty->TS_del_char || tty->TS_del_multi_chars));
+
+  display->fast_clear_end_of_line = tty->TS_clr_line != 0;
+
+  init_baud_rate (fileno (tty->input));
+
+#ifdef AIXHFT
+  /* The HFT system on AIX doesn't optimize for scrolling, so it's
+     really ugly at times.  */
+  display->line_ins_del_ok = 0;
+  display->char_ins_del_ok = 0;
+#endif
+
+#ifdef MULTI_KBOARD
+  tty->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
+  init_kboard (tty->kboard);
+  tty->kboard->next_kboard = all_kboards;
+  all_kboards = tty->kboard;
+  /* Don't let the initial kboard remain current longer than necessary.
+     That would cause problems if a file loaded on startup tries to
+     prompt in the mini-buffer.  */
+  if (current_kboard == initial_kboard)
+    current_kboard = tty->kboard;
+  tty->kboard->reference_count++;
+#endif
+
+  /* Don't do this.  I think termcap may still need the buffer. */
+  /* xfree (buffer); */
+
+  /* Init system terminal modes (RAW or CBREAK, etc.).  */
+  init_sys_modes (tty);
+
+  return display;
+#endif /* not WINDOWSNT */
+}
+
+/* Auxiliary error-handling function for term_init.
+   Free BUFFER and delete DISPLAY, then call error or fatal
+   with str1 or str2, respectively, according to MUST_SUCCEED.  */
+
+static void
+maybe_fatal (must_succeed, buffer, display, str1, str2, arg1, arg2)
+     int must_succeed;
+     char *buffer;
+     struct display *display;
+     char *str1, *str2, *arg1, *arg2;
+{
+  if (buffer)
+    xfree (buffer);
+
+  if (display)
+    delete_tty (display);
+
+  if (must_succeed)
+    fatal (str2, arg1, arg2);
+  else
+    error (str1, arg1, arg2);
+
+  abort ();
 }

 /* VARARGS 1 */
@@ -2667,6 +2920,430 @@
   exit (1);
 }

+
+
+static int deleting_tty = 0;
+
+
+/* Delete the given terminal device, closing all frames on it. */
+
+void
+delete_tty (struct display *display)
+{
+  struct tty_display_info *tty;
+  Lisp_Object tail, frame;
+  char *tty_name;
+  int last_display;
+
+  if (deleting_tty)
+    /* We get a recursive call when we delete the last frame on this
+       display. */
+    return;
+
+  if (display->type != output_termcap)
+    abort ();
+
+  tty = display->display_info.tty;
+
+  last_display = 1;
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
+      if (FRAME_LIVE_P (f) && (!FRAME_TERMCAP_P (f) || FRAME_TTY (f) != tty))
+        {
+          last_display = 0;
+          break;
+        }
+    }
+  if (last_display)
+      error ("Attempt to delete the sole display with live frames");
+
+  if (tty == tty_list)
+    tty_list = tty->next;
+  else
+    {
+      struct tty_display_info *p;
+      for (p = tty_list; p && p->next != tty; p = p->next)
+        ;
+
+      if (! p)
+        /* This should not happen. */
+        abort ();
+
+      p->next = tty->next;
+      tty->next = 0;
+    }
+
+  deleting_tty = 1;
+
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
+      if (FRAME_TERMCAP_P (f) && FRAME_LIVE_P (f) && FRAME_TTY (f) == tty)
+        {
+          Fdelete_frame (frame, Qt);
+        }
+    }
+
+  /* reset_sys_modes needs a valid display, so this call needs to be
+     before delete_display. */
+  reset_sys_modes (tty);
+
+  delete_display (display);
+
+  tty_name = tty->name;
+  if (tty->type)
+    xfree (tty->type);
+
+  if (tty->input)
+    {
+      delete_keyboard_wait_descriptor (fileno (tty->input));
+      if (tty->input != stdin)
+        fclose (tty->input);
+    }
+  if (tty->output && tty->output != stdout && tty->output != tty->input)
+    fclose (tty->output);
+  if (tty->termscript)
+    fclose (tty->termscript);
+
+  if (tty->old_tty)
+    xfree (tty->old_tty);
+
+  if (tty->Wcm)
+    xfree (tty->Wcm);
+
+#ifdef MULTI_KBOARD
+  if (tty->kboard && --tty->kboard->reference_count > 0)
+    abort ();
+  if (tty->kboard)
+    delete_kboard (tty->kboard);
+#endif
+
+  bzero (tty, sizeof (struct tty_display_info));
+  xfree (tty);
+  deleting_tty = 0;
+}
+
+
+
+/* Initialize the tty-dependent part of frame F.  The frame must
+   already have its display initialized. */
+
+void
+create_tty_output (struct frame *f)
+{
+  struct tty_output *t;
+
+  if (! FRAME_TERMCAP_P (f))
+    abort ();
+
+  t = xmalloc (sizeof (struct tty_output));
+  bzero (t, sizeof (struct tty_output));
+
+  t->display_info = FRAME_DISPLAY (f)->display_info.tty;
+
+  f->output_data.tty = t;
+}
+
+/* Delete the tty-dependent part of frame F. */
+
+void
+delete_tty_output (struct frame *f)
+{
+  if (! FRAME_TERMCAP_P (f))
+    abort ();
+
+  xfree (f->output_data.tty);
+}
+
+
+
+
+/* Mark the pointers in the tty_display_info objects.
+   Called by the Fgarbage_collector.  */
+
+void
+mark_ttys ()
+{
+  struct tty_display_info *tty;
+
+  for (tty = tty_list; tty; tty = tty->next)
+    {
+      if (tty->top_frame)
+        mark_object (tty->top_frame);
+    }
+}
+
+
+
+/* Create a new display object and add it to the display list. */
+
+struct display *
+create_display (void)
+{
+  struct display *display = (struct display *) xmalloc (sizeof (struct display));
+
+  bzero (display, sizeof (struct display));
+  display->next_display = display_list;
+  display_list = display;
+
+  display->id = next_display_id++;
+
+  display->keyboard_coding =
+    (struct coding_system *) xmalloc (sizeof (struct coding_system));
+  display->terminal_coding =
+    (struct coding_system *) xmalloc (sizeof (struct coding_system));
+
+  setup_coding_system (Qnil, display->keyboard_coding);
+  setup_coding_system (Qnil, display->terminal_coding);
+
+  return display;
+}
+
+/* Remove a display from the display list and free its memory. */
+
+void
+delete_display (struct display *display)
+{
+  struct display **dp;
+  Lisp_Object tail, frame;
+
+  /* Check for and close live frames that are still on this
+     display. */
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
+      if (FRAME_LIVE_P (f) && f->display == display)
+        {
+          Fdelete_frame (frame, Qt);
+        }
+    }
+
+  for (dp = &display_list; *dp != display; dp = &(*dp)->next_display)
+    if (! *dp)
+      abort ();
+  *dp = display->next_display;
+
+  if (display->keyboard_coding)
+    xfree (display->keyboard_coding);
+  if (display->terminal_coding)
+    xfree (display->terminal_coding);
+  if (display->name)
+    xfree (display->name);
+
+  bzero (display, sizeof (struct display));
+  xfree (display);
+}
+
+DEFUN ("delete-display", Fdelete_display, Sdelete_display, 0, 2, 0,
+       doc: /* Delete DISPLAY by deleting all frames on it and closing the device.
+DISPLAY may be a display id, a frame, or nil for the display
+device of the current frame.
+
+Normally, you may not delete a display if all other displays are suspended,
+but if the second argument FORCE is non-nil, you may do so. */)
+  (display, force)
+     Lisp_Object display, force;
+{
+  struct display *d, *p;
+
+  d = get_display (display);
+
+  if (!d)
+    return Qnil;
+
+  p = display_list;
+  while (p && (p == d || !DISPLAY_ACTIVE_P (p)))
+    p = p->next_display;
+
+  if (NILP (force) && !p)
+    error ("Attempt to delete the sole active display");
+
+  if (d->delete_display_hook)
+    (*d->delete_display_hook) (d);
+  else
+    delete_display (d);
+
+  return Qnil;
+}
+
+DEFUN ("display-live-p", Fdisplay_live_p, Sdisplay_live_p, 1, 1, 0,
+       doc: /* Return non-nil if OBJECT is a display which has not been deleted.
+Value is nil if OBJECT is not a live display.
+If object is a live display, the return value indicates what sort of
+output device it uses.  See the documentation of `framep' for possible
+return values.
+
+Displays are represented by their integer identifiers. */)
+  (object)
+     Lisp_Object object;
+{
+  struct display *d;
+
+  if (!INTEGERP (object))
+    return Qnil;
+
+  d = get_display (object);
+
+  if (!d)
+    return Qnil;
+
+  switch (d->type)
+    {
+    case output_initial: /* The initial frame is like a termcap frame. */
+    case output_termcap:
+      return Qt;
+    case output_x_window:
+      return Qx;
+    case output_w32:
+      return Qw32;
+    case output_msdos_raw:
+      return Qpc;
+    case output_mac:
+      return Qmac;
+    default:
+      abort ();
+    }
+}
+
+DEFUN ("display-list", Fdisplay_list, Sdisplay_list, 0, 0, 0,
+       doc: /* Return a list of all displays.
+Displays are represented by their integer identifiers. */)
+  ()
+{
+  Lisp_Object displays = Qnil;
+  struct display *d;
+
+  for (d = display_list; d; d = d->next_display)
+    displays = Fcons (make_number (d->id), displays);
+
+  return displays;
+}
+
+
+
+
+DEFUN ("suspend-tty", Fsuspend_tty, Ssuspend_tty, 0, 1, 0,
+       doc: /* Suspend the terminal device TTY.
+The terminal is restored to its default state, and Emacs ceases all
+access to the terminal device.  Frames that use the device are not
+deleted, but input is not read from them and if they change, their
+display is not updated.
+
+TTY may be a display id, a frame, or nil for the display device of the
+currently selected frame.
+
+This function runs `suspend-tty-functions' after suspending the
+device.  The functions are run with one arg, the id of the suspended
+display device.
+
+`suspend-tty' does nothing if it is called on an already suspended
+device.
+
+A suspended terminal device may be resumed by calling `resume-tty' on
+it. */)
+  (tty)
+     Lisp_Object tty;
+{
+  struct display *d = get_tty_display (tty);
+  FILE *f;
+
+  if (!d)
+    error ("Unknown tty device");
+
+  f = d->display_info.tty->input;
+
+  if (f)
+    {
+      reset_sys_modes (d->display_info.tty);
+
+      delete_keyboard_wait_descriptor (fileno (f));
+
+      fclose (f);
+      if (f != d->display_info.tty->output)
+        fclose (d->display_info.tty->output);
+
+      d->display_info.tty->input = 0;
+      d->display_info.tty->output = 0;
+
+      if (FRAMEP (d->display_info.tty->top_frame))
+        FRAME_SET_VISIBLE (XFRAME (d->display_info.tty->top_frame), 0);
+
+      /* Run `suspend-tty-functions'.  */
+      if (!NILP (Vrun_hooks))
+        {
+          Lisp_Object args[2];
+          args[0] = intern ("suspend-tty-functions");
+          args[1] = make_number (d->id);
+          Frun_hook_with_args (2, args);
+        }
+    }
+
+  return Qnil;
+}
+
+
+DEFUN ("resume-tty", Fresume_tty, Sresume_tty, 0, 1, 0,
+       doc: /* Resume the previously suspended terminal device TTY.
+The terminal is opened and reinitialized.  Frames that are on the
+suspended display are revived.
+
+It is an error to resume a display while another display is active on
+the same device.
+
+This function runs `resume-tty-functions' after resuming the device.
+The functions are run with one arg, the id of the resumed display
+device.
+
+`resume-tty' does nothing if it is called on a device that is not
+suspended.
+
+TTY may be a display id, a frame, or nil for the display device of the
+currently selected frame. */)
+  (tty)
+     Lisp_Object tty;
+{
+  struct display *d = get_tty_display (tty);
+  int fd;
+
+  if (!d)
+    error ("Unknown tty device");
+
+  if (!d->display_info.tty->input)
+    {
+      if (get_named_tty_display (d->display_info.tty->name))
+        error ("Cannot resume display while another display is active on the same device");
+
+      fd = emacs_open (d->display_info.tty->name, O_RDWR | O_NOCTTY, 0);
+
+      /* XXX What if open fails? */
+
+      dissociate_if_controlling_tty (fd);
+
+      d->display_info.tty->output = fdopen (fd, "w+");
+      d->display_info.tty->input = d->display_info.tty->output;
+
+      add_keyboard_wait_descriptor (fd);
+
+      if (FRAMEP (d->display_info.tty->top_frame))
+        FRAME_SET_VISIBLE (XFRAME (d->display_info.tty->top_frame), 1);
+
+      init_sys_modes (d->display_info.tty);
+
+      /* Run `suspend-tty-functions'.  */
+      if (!NILP (Vrun_hooks))
+        {
+          Lisp_Object args[2];
+          args[0] = intern ("resume-tty-functions");
+          args[1] = make_number (d->id);
+          Frun_hook_with_args (2, args);
+        }
+    }
+
+  return Qnil;
+}
+
+
 void
 syms_of_term ()
 {
@@ -2684,9 +3361,35 @@
 The function should accept no arguments.  */);
   Vring_bell_function = Qnil;

+  DEFVAR_LISP ("suspend-tty-functions", &Vsuspend_tty_functions,
+    doc: /* Functions to be run after suspending a tty.
+The functions are run with one argument, the name of the tty to be suspended.
+See `suspend-tty'.  */);
+  Vsuspend_tty_functions = Qnil;
+
+
+  DEFVAR_LISP ("resume-tty-functions", &Vresume_tty_functions,
+    doc: /* Functions to be run after resuming a tty.
+The functions are run with one argument, the name of the tty that was revived.
+See `resume-tty'.  */);
+  Vresume_tty_functions = Qnil;
+
   defsubr (&Stty_display_color_p);
   defsubr (&Stty_display_color_cells);
+  defsubr (&Sdisplay_name);
+  defsubr (&Sdisplay_tty_type);
+  defsubr (&Sdisplay_controlling_tty_p);
+  defsubr (&Sdelete_display);
+  defsubr (&Sdisplay_live_p);
+  defsubr (&Sdisplay_list);
+  defsubr (&Ssuspend_tty);
+  defsubr (&Sresume_tty);
+
+  Fprovide (intern ("multi-tty"), Qnil);
+
 }

+
+
 /* arch-tag: 498e7449-6f2e-45e2-91dd-b7d4ca488193
    (do not change this comment) */
--- a/src/termchar.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/termchar.h	Mon Oct 25 18:17:28 2004 +0000
@@ -1,5 +1,5 @@
 /* Flags and parameters describing terminal's characteristics.
-   Copyright (C) 1985, 1986 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 2003 Free Software Foundation, Inc.

 This file is part of GNU Emacs.

@@ -18,32 +18,190 @@
 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */

+/* Each termcap frame points to its own struct tty_output object in
+   the output_data.tty field.  The tty_output structure contains the
+   information that is specific to termcap frames. */

-/* extern EMACS_INT baud_rate; */		/* Output speed in baud */
-extern int must_write_spaces;	/* Nonzero means spaces in the text
-				   must actually be output; can't just skip
-				   over some columns to leave them blank.  */
-extern int min_padding_speed;	/* Speed below which no padding necessary */
-extern int fast_clear_end_of_line; /* Nonzero means terminal has
-				      command for this */
+struct tty_output
+{
+  /* The Emacs structure for the tty device this frame is on. */
+  struct tty_display_info *display_info;
+
+  /* There is nothing else here at the moment... */
+};
+
+/* Parameters that are shared between frames on the same tty device. */
+
+struct tty_display_info
+{
+  struct tty_display_info *next; /* Chain of all tty devices. */
+
+  char *name;                   /* The name of the device file or 0 if
+                                   stdin/stdout. */
+  char *type;                   /* The type of the tty. */
+
+  /* Input/output */
+
+  FILE *input;                  /* The stream to be used for terminal input.
+                                   NULL if the terminal is suspended. */
+  FILE *output;                 /* The stream to be used for terminal output.
+                                   NULL if the terminal is suspended. */
+
+  FILE *termscript;             /* If nonzero, send all terminal output
+                                   characters to this stream also.  */
+
+  struct emacs_tty *old_tty;    /* The initial tty mode bits */
+
+  int term_initted;             /* 1 if we have been through init_sys_modes. */
+
+
+  int reference_count;          /* Number of frames that are on this display. */
+
+  struct display *display;      /* Points back to the generic display
+                                   structure.  This is sometimes handy. */
+
+  /* Info on cursor positioning.  */
+  struct cm *Wcm;
+
+  /* Redisplay. */
+
+  Lisp_Object top_frame;        /* The topmost frame on this tty. */
+
+  /* The previous terminal frame we displayed on this tty.  */
+  struct frame *previous_terminal_frame;
+
+#ifdef MULTI_KBOARD
+  /* The terminal's keyboard object. */
+  struct kboard *kboard;
+#endif
+
+  /* Strings, numbers and flags taken from the termcap entry.  */

-extern int line_ins_del_ok;	/* Terminal can insert and delete lines */
-extern int char_ins_del_ok;	/* Terminal can insert and delete chars */
-extern int scroll_region_ok;	/* Terminal supports setting the scroll
-				   window */
-extern int scroll_region_cost;	/* Cost of setting the scroll window,
-				   measured in characters */
-extern int memory_below_frame;	/* Terminal remembers lines scrolled
-				   off bottom */
-extern int fast_clear_end_of_line; /* Terminal has a `ce' string */
+  char *TS_ins_line;		/* "al" */
+  char *TS_ins_multi_lines;	/* "AL" (one parameter, # lines to insert) */
+  char *TS_bell;                /* "bl" */
+  char *TS_clr_to_bottom;       /* "cd" */
+  char *TS_clr_line;		/* "ce", clear to end of line */
+  char *TS_clr_frame;		/* "cl" */
+  char *TS_set_scroll_region;	/* "cs" (2 params, first line and last line) */
+  char *TS_set_scroll_region_1; /* "cS" (4 params: total lines,
+                                   lines above scroll region, lines below it,
+                                   total lines again) */
+  char *TS_del_char;		/* "dc" */
+  char *TS_del_multi_chars;	/* "DC" (one parameter, # chars to delete) */
+  char *TS_del_line;		/* "dl" */
+  char *TS_del_multi_lines;	/* "DL" (one parameter, # lines to delete) */
+  char *TS_delete_mode;		/* "dm", enter character-delete mode */
+  char *TS_end_delete_mode;	/* "ed", leave character-delete mode */
+  char *TS_end_insert_mode;	/* "ei", leave character-insert mode */
+  char *TS_ins_char;		/* "ic" */
+  char *TS_ins_multi_chars;	/* "IC" (one parameter, # chars to insert) */
+  char *TS_insert_mode;		/* "im", enter character-insert mode */
+  char *TS_pad_inserted_char;	/* "ip".  Just padding, no commands.  */
+  char *TS_end_keypad_mode;	/* "ke" */
+  char *TS_keypad_mode;		/* "ks" */
+  char *TS_pad_char;		/* "pc", char to use as padding */
+  char *TS_repeat;		/* "rp" (2 params, # times to repeat
+				   and character to be repeated) */
+  char *TS_end_standout_mode;	/* "se" */
+  char *TS_fwd_scroll;		/* "sf" */
+  char *TS_standout_mode;       /* "so" */
+  char *TS_rev_scroll;          /* "sr" */
+  char *TS_end_termcap_modes;   /* "te" */
+  char *TS_termcap_modes;       /* "ti" */
+  char *TS_visible_bell;        /* "vb" */
+  char *TS_cursor_normal;       /* "ve" */
+  char *TS_cursor_visible;      /* "vs" */
+  char *TS_cursor_invisible;    /* "vi" */
+  char *TS_set_window;          /* "wi" (4 params, start and end of window,
+                                   each as vpos and hpos) */
+
+  char *TS_enter_bold_mode;     /* "md" -- turn on bold (extra bright mode).  */
+  char *TS_enter_dim_mode;      /* "mh" -- turn on half-bright mode.  */
+  char *TS_enter_blink_mode;    /* "mb" -- enter blinking mode.  */
+  char *TS_enter_reverse_mode;  /* "mr" -- enter reverse video mode.  */
+  char *TS_exit_underline_mode; /* "us" -- start underlining.  */
+  char *TS_enter_underline_mode; /* "ue" -- end underlining.  */
+
+  /* "as"/"ae" -- start/end alternate character set.  Not really
+     supported, yet.  */
+  char *TS_enter_alt_charset_mode;
+  char *TS_exit_alt_charset_mode;
+
+  char *TS_exit_attribute_mode; /* "me" -- switch appearances off.  */
+
+  /* Value of the "NC" (no_color_video) capability, or 0 if not present.  */
+  int TN_no_color_video;
+
+  int TN_max_colors;            /* "Co" -- number of colors.  */
+
+  /* "pa" -- max. number of color pairs on screen.  Not handled yet.
+     Could be a problem if not equal to TN_max_colors * TN_max_colors.  */
+  int TN_max_pairs;

-extern int dont_calculate_costs; /* Nonzero means don't bother computing
-				    various cost tables; we won't use them. */
+  /* "op" -- SVr4 set default pair to its original value.  */
+  char *TS_orig_pair;
+
+  /* "AF"/"AB" or "Sf"/"Sb"-- set ANSI or SVr4 foreground/background color.
+     1 param, the color index.  */
+  char *TS_set_foreground;
+  char *TS_set_background;
+
+  int TF_hazeltine;             /* termcap hz flag. */
+  int TF_insmode_motion;        /* termcap mi flag: can move while in insert mode. */
+  int TF_standout_motion;       /* termcap mi flag: can move while in standout mode. */
+  int TF_underscore;            /* termcap ul flag: _ underlines if over-struck on
+                                   non-blank position.  Must clear before writing _.  */
+  int TF_teleray;               /* termcap xt flag: many weird consequences.
+                                   For t1061. */
+
+  int RPov;                     /* # chars to start a TS_repeat */
+
+  int delete_in_insert_mode;    /* delete mode == insert mode */
+
+  int se_is_so;                 /* 1 if same string both enters and leaves
+                                   standout mode */
+
+  int costs_set;                /* Nonzero if costs have been calculated. */
+
+  int insert_mode;              /* Nonzero when in insert mode.  */
+  int standout_mode;            /* Nonzero when in standout mode.  */
+
+

-/* Nonzero means no need to redraw the entire frame on resuming
-   a suspended Emacs.  This is useful on terminals with multiple pages,
-   where one page is used for Emacs and another for all else. */
-extern int no_redraw_on_reenter;
+  /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
+     keep 0200 bit in input chars.  0 to ignore the 0200 bit.  */
+
+  int meta_key;
+
+  /* Size of window specified by higher levels.
+   This is the number of lines, from the top of frame downwards,
+   which can participate in insert-line/delete-line operations.
+
+   Effectively it excludes the bottom frame_lines - specified_window_size
+   lines from those operations.  */
+
+  int specified_window;
+
+  /* Flag used in tty_show/hide_cursor.  */
+
+  int cursor_hidden;
+
+  /* Nonzero means use ^S/^Q for flow control.  */
+  int flow_control;
+
+};
+
+/* A chain of structures for all tty devices currently in use. */
+extern struct tty_display_info *tty_list;
+
+
+#define FRAME_TTY(f)                            \
+  ((f)->output_method == output_termcap         \
+   ? (f)->display->display_info.tty             \
+   : (abort(), (struct tty_display_info *) 0))
+
+#define CURTTY() FRAME_TTY (SELECTED_FRAME())

 /* arch-tag: bf9f0d49-842b-42fb-9348-ec8759b27193
    (do not change this comment) */
--- a/src/termhooks.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/termhooks.h	Mon Oct 25 18:17:28 2004 +0000
@@ -1,5 +1,4 @@
-/* Hooks by which low level terminal operations
-   can be made to call other routines.
+/* Parameters and display hooks for output devices
    Copyright (C) 1985,86,93,94,2003  Free Software Foundation, Inc.

 This file is part of GNU Emacs.
@@ -25,40 +24,11 @@
 struct glyph;
 struct frame;

-/* If nonzero, send all terminal output characters to this stream also.  */
-extern FILE *termscript;
-
 /* Only use prototypes when lisp.h has been included.  */
 #ifndef P_
 #define P_(X) ()
 #endif

-/* Text display hooks.  */
-
-extern void (*cursor_to_hook) P_ ((int vpos, int hpos));
-extern void (*raw_cursor_to_hook) P_ ((int, int));
-
-extern void (*clear_to_end_hook) P_ ((void));
-extern void (*clear_frame_hook) P_ ((void));
-extern void (*clear_end_of_line_hook) P_ ((int));
-
-extern void (*ins_del_lines_hook) P_ ((int, int));
-
-extern void (*insert_glyphs_hook) P_ ((struct glyph *s, int n));
-extern void (*write_glyphs_hook) P_ ((struct glyph *s, int n));
-extern void (*delete_glyphs_hook) P_ ((int));
-
-extern void (*ring_bell_hook) P_ ((void));
-
-extern void (*reset_terminal_modes_hook) P_ ((void));
-extern void (*set_terminal_modes_hook) P_ ((void));
-extern void (*update_begin_hook) P_ ((struct frame *));
-extern void (*update_end_hook) P_ ((struct frame *));
-extern void (*set_terminal_window_hook) P_ ((int));
-
-
-
-/* Multi-frame and mouse support hooks.  */

 enum scroll_bar_part {
   scroll_bar_above_handle,
@@ -72,125 +42,6 @@
   scroll_bar_move_ratio
 };

-/* Return the current position of the mouse.
-
-   Set *f to the frame the mouse is in, or zero if the mouse is in no
-   Emacs frame.  If it is set to zero, all the other arguments are
-   garbage.
-
-   If the motion started in a scroll bar, set *bar_window to the
-   scroll bar's window, *part to the part the mouse is currently over,
-   *x to the position of the mouse along the scroll bar, and *y to the
-   overall length of the scroll bar.
-
-   Otherwise, set *bar_window to Qnil, and *x and *y to the column and
-   row of the character cell the mouse is over.
-
-   Set *time to the time the mouse was at the returned position.
-
-   This should clear mouse_moved until the next motion
-   event arrives.  */
-extern void (*mouse_position_hook) P_ ((struct frame **f, int,
-					Lisp_Object *bar_window,
-					enum scroll_bar_part *part,
-					Lisp_Object *x,
-					Lisp_Object *y,
-					unsigned long *time));
-
-/* The window system handling code should set this if the mouse has
-   moved since the last call to the mouse_position_hook.  Calling that
-   hook should clear this.  */
-extern int mouse_moved;
-
-/* When a frame's focus redirection is changed, this hook tells the
-   window system code to re-decide where to put the highlight.  Under
-   X, this means that Emacs lies about where the focus is.  */
-extern void (*frame_rehighlight_hook) P_ ((struct frame *));
-
-/* If we're displaying frames using a window system that can stack
-   frames on top of each other, this hook allows you to bring a frame
-   to the front, or bury it behind all the other windows.  If this
-   hook is zero, that means the device we're displaying on doesn't
-   support overlapping frames, so there's no need to raise or lower
-   anything.
-
-   If RAISE is non-zero, F is brought to the front, before all other
-   windows.  If RAISE is zero, F is sent to the back, behind all other
-   windows.  */
-extern void (*frame_raise_lower_hook) P_ ((struct frame *f, int raise));
-
-
-/* Scroll bar hooks.  */
-
-/* The representation of scroll bars is determined by the code which
-   implements them, except for one thing: they must be represented by
-   lisp objects.  This allows us to place references to them in
-   Lisp_Windows without worrying about those references becoming
-   dangling references when the scroll bar is destroyed.
-
-   The window-system-independent portion of Emacs just refers to
-   scroll bars via their windows, and never looks inside the scroll bar
-   representation; it always uses hook functions to do all the
-   scroll bar manipulation it needs.
-
-   The `vertical_scroll_bar' field of a Lisp_Window refers to that
-   window's scroll bar, or is nil if the window doesn't have a
-   scroll bar.
-
-   The `scroll_bars' and `condemned_scroll_bars' fields of a Lisp_Frame
-   are free for use by the scroll bar implementation in any way it sees
-   fit.  They are marked by the garbage collector.  */
-
-
-/* Set the vertical scroll bar for WINDOW to have its upper left corner
-   at (TOP, LEFT), and be LENGTH rows high.  Set its handle to
-   indicate that we are displaying PORTION characters out of a total
-   of WHOLE characters, starting at POSITION.  If WINDOW doesn't yet
-   have a scroll bar, create one for it.  */
-extern void (*set_vertical_scroll_bar_hook)
-            P_ ((struct window *window,
-	         int portion, int whole, int position));
-
-
-/* The following three hooks are used when we're doing a thorough
-   redisplay of the frame.  We don't explicitly know which scroll bars
-   are going to be deleted, because keeping track of when windows go
-   away is a real pain - can you say set-window-configuration?
-   Instead, we just assert at the beginning of redisplay that *all*
-   scroll bars are to be removed, and then save scroll bars from the
-   fiery pit when we actually redisplay their window.  */
-
-/* Arrange for all scroll bars on FRAME to be removed at the next call
-   to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
-   `*redeem_scroll_bar_hook' is applied to its window before the judgement.
-
-   This should be applied to each frame each time its window tree is
-   redisplayed, even if it is not displaying scroll bars at the moment;
-   if the HAS_SCROLL_BARS flag has just been turned off, only calling
-   this and the judge_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-extern void (*condemn_scroll_bars_hook) P_ ((struct frame *frame));
-
-/* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
-   Note that it's okay to redeem a scroll bar that is not condemned.  */
-extern void (*redeem_scroll_bar_hook) P_ ((struct window *window));
-
-/* Remove all scroll bars on FRAME that haven't been saved since the
-   last call to `*condemn_scroll_bars_hook'.
-
-   This should be applied to each frame after each time its window
-   tree is redisplayed, even if it is not displaying scroll bars at the
-   moment; if the HAS_SCROLL_BARS flag has just been turned off, only
-   calling this and condemn_scroll_bars_hook will get rid of them.
-
-   If non-zero, this hook should be safe to apply to any frame,
-   whether or not it can support scroll bars, and whether or not it is
-   currently displaying them.  */
-extern void (*judge_scroll_bars_hook) P_ ((struct frame *FRAME));
-

 /* Input queue declarations and hooks.  */

@@ -373,13 +224,6 @@

 #define EVENT_INIT(event) bzero (&(event), sizeof (struct input_event))

-/* Called to read input events.  */
-extern int (*read_socket_hook) P_ ((int, int, struct input_event *));
-
-/* Called when a frame's display becomes entirely up to date.  */
-extern void (*frame_up_to_date_hook) P_ ((struct frame *));
-
-
 /* Bits in the modifiers member of the input_event structure.
    Note that reorder_modifiers assumes that the bits are in canonical
    order.
@@ -429,7 +273,310 @@
   meta_modifier	=  CHAR_META	/* Under X, the XK_Meta_[LR] keysyms.  */
 };

+#endif /* CONSP */
+
+
+/* Display-local parameters. */
+struct display
+{
+  /* Chain of all displays. */
+  struct display *next_display;
+
+  /* Unique id for this display. */
+  int id;
+
+  /* The number of frames that are on this display. */
+  int reference_count;
+
+  /* The type of the display. */
+  enum output_method type;
+
+  /* The name of the display device.  Do not use this to identify the display. */
+  char *name;
+
+  /* Display-type dependent data shared amongst all frames on this display. */
+  union display_info
+  {
+    struct tty_display_info *tty;     /* termchar.h */
+    struct x_display_info *x;         /* xterm.h */
+  } display_info;
+
+
+  /* Coding-system to be used for encoding terminal output.  This
+     structure contains information of a coding-system specified by
+     the function `set-terminal-coding-system'.  Also see
+     `safe_terminal_coding' in coding.h.  */
+  struct coding_system *terminal_coding;
+
+  /* Coding-system of what is sent from terminal keyboard.  This
+     structure contains information of a coding-system specified by
+     the function `set-keyboard-coding-system'.  */
+  struct coding_system *keyboard_coding;
+
+  /* Terminal characteristics. */
+  /* XXX Are these really used on non-termcap displays? */
+
+  int must_write_spaces;	/* Nonzero means spaces in the text must
+				   actually be output; can't just skip over
+				   some columns to leave them blank.  */
+  int fast_clear_end_of_line;   /* Nonzero means terminal has a `ce' string */
+
+  int line_ins_del_ok;          /* Terminal can insert and delete lines */
+  int char_ins_del_ok;          /* Terminal can insert and delete chars */
+  int scroll_region_ok;         /* Terminal supports setting the scroll
+                                   window */
+  int scroll_region_cost;	/* Cost of setting the scroll window,
+                                   measured in characters. */
+  int memory_below_frame;	/* Terminal remembers lines scrolled
+                                   off bottom */
+
+#if 0  /* These are not used anywhere. */
+  /* EMACS_INT baud_rate; */	/* Output speed in baud */
+  int min_padding_speed;	/* Speed below which no padding necessary. */
+  int dont_calculate_costs;     /* Nonzero means don't bother computing
+                                   various cost tables; we won't use them. */
 #endif

+
+  /* Window-based redisplay interface for this device (0 for tty
+     devices). */
+  struct redisplay_interface *rif;
+
+  /* Frame-based redisplay interface. */
+
+  /* Text display hooks.  */
+
+  void (*cursor_to_hook) P_ ((struct frame *f, int vpos, int hpos));
+  void (*raw_cursor_to_hook) P_ ((struct frame *, int, int));
+
+  void (*clear_to_end_hook) P_ ((struct frame *));
+  void (*clear_frame_hook) P_ ((struct frame *));
+  void (*clear_end_of_line_hook) P_ ((struct frame *, int));
+
+  void (*ins_del_lines_hook) P_ ((struct frame *f, int, int));
+
+  void (*insert_glyphs_hook) P_ ((struct frame *f, struct glyph *s, int n));
+  void (*write_glyphs_hook) P_ ((struct frame *f, struct glyph *s, int n));
+  void (*delete_glyphs_hook) P_ ((struct frame *, int));
+
+  void (*ring_bell_hook) P_ ((struct frame *f));
+
+  void (*reset_terminal_modes_hook) P_ ((struct display *));
+  void (*set_terminal_modes_hook) P_ ((struct display *));
+
+  void (*update_begin_hook) P_ ((struct frame *));
+  void (*update_end_hook) P_ ((struct frame *));
+  void (*set_terminal_window_hook) P_ ((struct frame *, int));
+
+  /* Multi-frame and mouse support hooks.  */
+
+  /* Return the current position of the mouse.
+
+     Set *f to the frame the mouse is in, or zero if the mouse is in no
+     Emacs frame.  If it is set to zero, all the other arguments are
+     garbage.
+
+     If the motion started in a scroll bar, set *bar_window to the
+     scroll bar's window, *part to the part the mouse is currently over,
+     *x to the position of the mouse along the scroll bar, and *y to the
+     overall length of the scroll bar.
+
+     Otherwise, set *bar_window to Qnil, and *x and *y to the column and
+     row of the character cell the mouse is over.
+
+     Set *time to the time the mouse was at the returned position.
+
+     This should clear mouse_moved until the next motion
+     event arrives.  */
+  void (*mouse_position_hook) P_ ((struct frame **f, int,
+                                   Lisp_Object *bar_window,
+                                   enum scroll_bar_part *part,
+                                   Lisp_Object *x,
+                                   Lisp_Object *y,
+                                   unsigned long *time));
+
+  /* The window system handling code should set this if the mouse has
+     moved since the last call to the mouse_position_hook.  Calling that
+     hook should clear this.  */
+  int mouse_moved;
+
+  /* When a frame's focus redirection is changed, this hook tells the
+     window system code to re-decide where to put the highlight.  Under
+     X, this means that Emacs lies about where the focus is.  */
+  void (*frame_rehighlight_hook) P_ ((struct frame *));
+
+  /* If we're displaying frames using a window system that can stack
+     frames on top of each other, this hook allows you to bring a frame
+     to the front, or bury it behind all the other windows.  If this
+     hook is zero, that means the device we're displaying on doesn't
+     support overlapping frames, so there's no need to raise or lower
+     anything.
+
+     If RAISE is non-zero, F is brought to the front, before all other
+     windows.  If RAISE is zero, F is sent to the back, behind all other
+     windows.  */
+  void (*frame_raise_lower_hook) P_ ((struct frame *f, int raise));
+
+
+  /* Scroll bar hooks.  */
+
+  /* The representation of scroll bars is determined by the code which
+     implements them, except for one thing: they must be represented by
+     lisp objects.  This allows us to place references to them in
+     Lisp_Windows without worrying about those references becoming
+     dangling references when the scroll bar is destroyed.
+
+     The window-system-independent portion of Emacs just refers to
+     scroll bars via their windows, and never looks inside the scroll bar
+     representation; it always uses hook functions to do all the
+     scroll bar manipulation it needs.
+
+     The `vertical_scroll_bar' field of a Lisp_Window refers to that
+     window's scroll bar, or is nil if the window doesn't have a
+     scroll bar.
+
+     The `scroll_bars' and `condemned_scroll_bars' fields of a Lisp_Frame
+     are free for use by the scroll bar implementation in any way it sees
+     fit.  They are marked by the garbage collector.  */
+
+
+  /* Set the vertical scroll bar for WINDOW to have its upper left corner
+     at (TOP, LEFT), and be LENGTH rows high.  Set its handle to
+     indicate that we are displaying PORTION characters out of a total
+     of WHOLE characters, starting at POSITION.  If WINDOW doesn't yet
+     have a scroll bar, create one for it.  */
+  void (*set_vertical_scroll_bar_hook) P_ ((struct window *window,
+                                            int portion, int whole,
+                                            int position));
+
+
+  /* The following three hooks are used when we're doing a thorough
+     redisplay of the frame.  We don't explicitly know which scroll bars
+     are going to be deleted, because keeping track of when windows go
+     away is a real pain - can you say set-window-configuration?
+     Instead, we just assert at the beginning of redisplay that *all*
+     scroll bars are to be removed, and then save scroll bars from the
+     fiery pit when we actually redisplay their window.  */
+
+  /* Arrange for all scroll bars on FRAME to be removed at the next call
+     to `*judge_scroll_bars_hook'.  A scroll bar may be spared if
+     `*redeem_scroll_bar_hook' is applied to its window before the judgement.
+
+     This should be applied to each frame each time its window tree is
+     redisplayed, even if it is not displaying scroll bars at the moment;
+     if the HAS_SCROLL_BARS flag has just been turned off, only calling
+     this and the judge_scroll_bars_hook will get rid of them.
+
+     If non-zero, this hook should be safe to apply to any frame,
+     whether or not it can support scroll bars, and whether or not it is
+     currently displaying them.  */
+  void (*condemn_scroll_bars_hook) P_ ((struct frame *frame));
+
+  /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
+     Note that it's okay to redeem a scroll bar that is not condemned.  */
+  void (*redeem_scroll_bar_hook) P_ ((struct window *window));
+
+  /* Remove all scroll bars on FRAME that haven't been saved since the
+     last call to `*condemn_scroll_bars_hook'.
+
+     This should be applied to each frame after each time its window
+     tree is redisplayed, even if it is not displaying scroll bars at the
+     moment; if the HAS_SCROLL_BARS flag has just been turned off, only
+     calling this and condemn_scroll_bars_hook will get rid of them.
+
+     If non-zero, this hook should be safe to apply to any frame,
+     whether or not it can support scroll bars, and whether or not it is
+     currently displaying them.  */
+  void (*judge_scroll_bars_hook) P_ ((struct frame *FRAME));
+
+
+  /* Called to read input events.
+
+     DISPLAY indicates which display to read from.  Input events
+     should be read into BUF, the size of which is given in SIZE.
+     EXPECTED is non-zero if the caller suspects that new input is
+     available.
+
+     A positive return value indicates that that many input events
+     where read into BUF.
+     Zero means no events were immediately available.
+     A value of -1 means a transient read error, while -2 indicates
+     that the display was closed (hangup), and it should be deleted.
+
+     XXX Please note that a non-zero value of EXPECTED only means that
+     there is available input on at least one of the currently opened
+     display devices -- but not necessarily on this device.
+     Therefore, in most cases EXPECTED should be simply ignored.
+
+     XXX This documentation needs to be updated.  */
+  int (*read_socket_hook) P_ ((struct display *display,
+                               int expected,
+                               struct input_event *hold_quit));
+
+  /* Called when a frame's display becomes entirely up to date.  */
+  void (*frame_up_to_date_hook) P_ ((struct frame *));
+
+
+  /* Called to delete the device-specific portions of a frame that is
+     on this display. */
+  void (*delete_frame_hook) P_ ((struct frame *));
+
+  /* Called after the last frame on this display is deleted, or when
+     the display device was closed (hangup).
+
+     If this is NULL, then the generic delete_display is called
+     instead.  Otherwise the hook must call delete_display itself.
+
+     The hook must check for and close any live frames that are still
+     on the display.  Fdelete_frame ensures that there are no live
+     frames on the display when it calls this hook, so infinite
+     recursion is prevented.  */
+  void (*delete_display_hook) P_ ((struct display *));
+};
+
+
+/* Chain of all displays currently in use. */
+extern struct display *display_list;
+
+#define FRAME_MUST_WRITE_SPACES(f) ((f)->display->must_write_spaces)
+#define FRAME_FAST_CLEAR_END_OF_LINE(f) ((f)->display->fast_clear_end_of_line)
+#define FRAME_LINE_INS_DEL_OK(f) ((f)->display->line_ins_del_ok)
+#define FRAME_CHAR_INS_DEL_OK(f) ((f)->display->char_ins_del_ok)
+#define FRAME_SCROLL_REGION_OK(f) ((f)->display->scroll_region_ok)
+#define FRAME_SCROLL_REGION_COST(f) ((f)->display->scroll_region_cost)
+#define FRAME_MEMORY_BELOW_FRAME(f) ((f)->display->memory_below_frame)
+
+#define FRAME_TERMINAL_CODING(f) ((f)->display->terminal_coding)
+#define FRAME_KEYBOARD_CODING(f) ((f)->display->keyboard_coding)
+
+#define FRAME_RIF(f) ((f)->display->rif)
+
+#define FRAME_DISPLAY(f) ((f)->display)
+
+/* FRAME_WINDOW_P tests whether the frame is a window, and is
+   defined to be the predicate for the window system being used.  */
+
+#ifdef HAVE_X_WINDOWS
+#define FRAME_WINDOW_P(f) FRAME_X_P (f)
+#endif
+#ifdef HAVE_NTGUI
+#define FRAME_WINDOW_P(f) FRAME_W32_P (f)
+#endif
+#ifdef MAC_OS
+#define FRAME_WINDOW_P(f) FRAME_MAC_P (f)
+#endif
+#ifndef FRAME_WINDOW_P
+#define FRAME_WINDOW_P(f) (0)
+#endif
+
+/* Return true if the display is not suspended. */
+#define DISPLAY_ACTIVE_P(d) ((d)->type != output_termcap || (d)->display_info.tty->input)
+
+extern struct display *create_display P_ ((void));
+extern void delete_display P_ ((struct display *));
+
+/* The initial display device, created by initial_term_init. */
+extern struct display *initial_display;
+
 /* arch-tag: 33a00ecc-52b5-4186-a410-8801ac9f087d
    (do not change this comment) */
--- a/src/termopts.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/termopts.h	Mon Oct 25 18:17:28 2004 +0000
@@ -40,5 +40,10 @@
 /* Nonzero means truncate lines in all windows less wide than the frame */
 extern int truncate_partial_width_windows;

+/* Nonzero means no need to redraw the entire frame on resuming a suspended
+   Emacs.  This is useful on terminals with multiple pages, where one page is
+   used for Emacs and another for all else. */
+extern int no_redraw_on_reenter;
+
 /* arch-tag: 35d4d284-dc1a-4fff-97fa-0154a21aebdb
    (do not change this comment) */
--- a/src/w32term.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/w32term.c	Mon Oct 25 18:17:28 2004 +0000
@@ -6372,12 +6372,13 @@
   redeem_scroll_bar_hook = w32_redeem_scroll_bar;
   judge_scroll_bars_hook = w32_judge_scroll_bars;

-  scroll_region_ok = 1;         /* we'll scroll partial frames */
-  char_ins_del_ok = 1;
-  line_ins_del_ok = 1;          /* we'll just blt 'em */
-  fast_clear_end_of_line = 1;   /* X does this well */
-  memory_below_frame = 0;       /* we don't remember what scrolls
-				   off the bottom */
+  TTY_SCROLL_REGION_OK (CURTTY ()) = 1; /* we'll scroll partial frames */
+  TTY_CHAR_INS_DEL_OK (CURTTY ()) = 1;
+  TTY_LINE_INS_DEL_OK (CURTTY ()) = 1; /* we'll just blt 'em */
+  TTY_FAST_CLEAR_END_OF_LINE (CURTTY ()) = 1; /* X does this well */
+  TTY_MEMORY_BELOW_FRAME (CURTTY ()) = 0; /* we don't remember what
+                                                            scrolls off the
+                                                            bottom */
   baud_rate = 19200;

   w32_system_caret_hwnd = NULL;
--- a/src/w32term.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/w32term.h	Mon Oct 25 18:17:28 2004 +0000
@@ -393,8 +393,6 @@
 #define FRAME_W32_WINDOW(f) ((f)->output_data.w32->window_desc)
 #define FRAME_X_WINDOW(f) ((f)->output_data.w32->window_desc)

-#define FRAME_FOREGROUND_PIXEL(f) ((f)->output_data.x->foreground_pixel)
-#define FRAME_BACKGROUND_PIXEL(f) ((f)->output_data.x->background_pixel)
 #define FRAME_FONT(f) ((f)->output_data.w32->font)
 #define FRAME_FONTSET(f) ((f)->output_data.w32->fontset)
 #define FRAME_BASELINE_OFFSET(f) ((f)->output_data.w32->baseline_offset)
--- a/src/window.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/window.c	Mon Oct 25 18:17:28 2004 +0000
@@ -21,6 +21,8 @@
 Boston, MA 02111-1307, USA.  */

 #include <config.h>
+#include <stdio.h>
+
 #include "lisp.h"
 #include "buffer.h"
 #include "keyboard.h"
@@ -6454,7 +6456,7 @@
 void
 init_window_once ()
 {
-  struct frame *f = make_terminal_frame ();
+  struct frame *f = make_initial_frame ();
   XSETFRAME (selected_frame, f);
   Vterminal_frame = selected_frame;
   minibuf_window = f->minibuffer_window;
--- a/src/window.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/window.h	Mon Oct 25 18:17:28 2004 +0000
@@ -752,7 +752,7 @@
 /* Nil or a symbol naming the window system under which emacs is
    running ('x is the only current possibility) */

-extern Lisp_Object Vwindow_system;
+extern Lisp_Object Vinitial_window_system;

 /* Version number of X windows: 10, 11 or nil.  */
--- a/src/xdisp.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xdisp.c	Mon Oct 25 18:17:28 2004 +0000
@@ -769,10 +769,6 @@
 #define CLEAR_FACE_CACHE_COUNT	500
 static int clear_face_cache_count;

-/* Record the previous terminal frame we displayed.  */
-
-static struct frame *previous_terminal_frame;
-
 /* Non-zero while redisplay_internal is in progress.  */

 int redisplaying_p;
@@ -2063,7 +2059,7 @@
   XSETWINDOW (it->window, w);
   it->w = w;
   it->f = XFRAME (w->frame);
-
+
   /* Extra space between lines (on window systems only).  */
   if (base_face_id == DEFAULT_FACE_ID
       && FRAME_WINDOW_P (it->f))
@@ -2079,9 +2075,9 @@

   /* If realized faces have been removed, e.g. because of face
      attribute changes of named faces, recompute them.  When running
-     in batch mode, the face cache of Vterminal_frame is null.  If
+     in batch mode, the face cache of the initial frame is null.  If
      we happen to get called, make a dummy face cache.  */
-  if (noninteractive && FRAME_FACE_CACHE (it->f) == NULL)
+  if (FRAME_FACE_CACHE (it->f) == NULL)
     init_frame_faces (it->f);
   if (FRAME_FACE_CACHE (it->f)->used == 0)
     recompute_basic_faces (it->f);
@@ -3533,7 +3529,7 @@
 	   && CONSP (XCDR (prop)))
     {
       /* `(raise FACTOR)'.  */
-      if (FRAME_TERMCAP_P (it->f) || FRAME_MSDOS_P (it->f))
+      if (!FRAME_WINDOW_P (it->f))
 	return 0;

 #ifdef HAVE_WINDOW_SYSTEM
@@ -3576,7 +3572,7 @@
 	     when we are finished with the glyph property value.  */

 	  /* `(left-fringe BITMAP FACE)'.  */
-	  if (FRAME_TERMCAP_P (it->f) || FRAME_MSDOS_P (it->f))
+	  if (!FRAME_WINDOW_P (it->f))
 	    return 0;

 #ifdef HAVE_WINDOW_SYSTEM
@@ -3650,7 +3646,7 @@

       valid_p = (STRINGP (value)
 #ifdef HAVE_WINDOW_SYSTEM
-		 || (!FRAME_TERMCAP_P (it->f) && valid_image_p (value))
+		 || (FRAME_WINDOW_P (it->f) && valid_image_p (value))
 #endif /* not HAVE_WINDOW_SYSTEM */
 		 || (CONSP (value) && EQ (XCAR (value), Qspace)));

@@ -3697,11 +3693,14 @@
 #ifdef HAVE_WINDOW_SYSTEM
 	  else
 	    {
-	      it->what = IT_IMAGE;
-	      it->image_id = lookup_image (it->f, value);
-	      it->position = start_pos;
-	      it->object = NILP (object) ? it->w->buffer : object;
-	      it->method = next_element_from_image;
+              if (FRAME_WINDOW_P (it->f))
+                {
+                  it->what = IT_IMAGE;
+                  it->image_id = lookup_image (it->f, value);
+                  it->position = start_pos;
+                  it->object = NILP (object) ? it->w->buffer : object;
+                  it->method = next_element_from_image;
+                }

 	      /* Say that we haven't consumed the characters with
 		 `display' property yet.  The call to pop_it in
@@ -6668,8 +6667,8 @@
       do_pending_window_change (0);
       echo_area_display (1);
       do_pending_window_change (0);
-      if (frame_up_to_date_hook != 0 && ! gc_in_progress)
-	(*frame_up_to_date_hook) (f);
+      if (FRAME_DISPLAY (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+	(*FRAME_DISPLAY (f)->frame_up_to_date_hook) (f);
     }
 }

@@ -6754,8 +6753,8 @@
       do_pending_window_change (0);
       echo_area_display (1);
       do_pending_window_change (0);
-      if (frame_up_to_date_hook != 0 && ! gc_in_progress)
-	(*frame_up_to_date_hook) (f);
+      if (FRAME_DISPLAY (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+	(*FRAME_DISPLAY (f)->frame_up_to_date_hook) (f);
     }
 }

@@ -7778,11 +7777,11 @@
     {
       Lisp_Object tail, frame;
       int changed_count = 0;
-
+
       FOR_EACH_FRAME (tail, frame)
 	{
 	  struct frame *f = XFRAME (frame);
-
+
 	  if (FRAME_VISIBLE_P (f) && FRAME_GARBAGED_P (f))
 	    {
 	      if (f->resized_p)
@@ -7796,7 +7795,7 @@
 	      f->resized_p = 0;
 	    }
 	}
-
+
       frame_garbaged = 0;
       if (changed_count)
 	++windows_or_buffers_changed;
@@ -7829,11 +7828,10 @@
 /* The terminal frame is used as the first Emacs frame on the Mac OS.  */
 #ifndef MAC_OS8
 #ifdef HAVE_WINDOW_SYSTEM
-  /* When Emacs starts, selected_frame may be a visible terminal
-     frame, even if we run under a window system.  If we let this
-     through, a message would be displayed on the terminal.  */
-  if (EQ (selected_frame, Vterminal_frame)
-      && !NILP (Vwindow_system))
+  /* When Emacs starts, selected_frame may be the initial terminal
+     frame.  If we let this through, a message would be displayed on
+     the terminal.  */
+  if (FRAME_INITIAL_P (XFRAME (selected_frame)))
     return 0;
 #endif /* HAVE_WINDOW_SYSTEM */
 #endif
@@ -7884,7 +7882,7 @@
 		 Can do with a display update of the echo area,
 		 unless we displayed some mode lines.  */
 	      update_single_window (w, 1);
-	      rif->flush_display (f);
+	      FRAME_RIF (f)->flush_display (f);
 	    }
 	  else
 	    update_frame (f, 1, 1);
@@ -8345,8 +8343,8 @@
     {
       BLOCK_INPUT;
       display_and_set_cursor (w, 1, hpos, vpos, x, y);
-      if (rif->flush_display_optional)
-	rif->flush_display_optional (SELECTED_FRAME ());
+      if (FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
+	FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (SELECTED_FRAME ());
       UNBLOCK_INPUT;
     }
 }
@@ -9770,17 +9768,16 @@
   if (face_change_count)
     ++windows_or_buffers_changed;

-  if (! FRAME_WINDOW_P (sf)
-      && previous_terminal_frame != sf)
-    {
-      /* Since frames on an ASCII terminal share the same display
-	 area, displaying a different frame means redisplay the whole
-	 thing.  */
+  if (FRAME_TERMCAP_P (sf)
+      && FRAME_TTY (sf)->previous_terminal_frame != sf)
+    {
+      /* Since frames on a single ASCII terminal share the same
+	 display area, displaying a different frame means redisplay
+	 the whole thing.  */
       windows_or_buffers_changed++;
       SET_FRAME_GARBAGED (sf);
-      XSETFRAME (Vterminal_frame, sf);
-    }
-  previous_terminal_frame = sf;
+      FRAME_TTY (sf)->previous_terminal_frame = sf;
+    }

   /* Set the visible flags for all frames.  Do this before checking
      for resized or garbaged frames; they want to know if their frames
@@ -9802,6 +9799,7 @@
       }
   }

+
   /* Notice any pending interrupt request to change frame size.  */
   do_pending_window_change (1);

@@ -10161,7 +10159,7 @@
 	{
 	  struct frame *f = XFRAME (frame);

-	  if (FRAME_WINDOW_P (f) || f == sf)
+	  if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
 	    {
 	      if (! EQ (frame, selected_frame))
 		/* Select the frame, for the sake of frame-local
@@ -10176,16 +10174,16 @@

 	      /* Mark all the scroll bars to be removed; we'll redeem
 		 the ones we want when we redisplay their windows.  */
-	      if (condemn_scroll_bars_hook)
-		condemn_scroll_bars_hook (f);
+	      if (FRAME_DISPLAY (f)->condemn_scroll_bars_hook)
+		FRAME_DISPLAY (f)->condemn_scroll_bars_hook (f);

 	      if (FRAME_VISIBLE_P (f) && !FRAME_OBSCURED_P (f))
 		redisplay_windows (FRAME_ROOT_WINDOW (f));

 	      /* Any scroll bars which redisplay_windows should have
 		 nuked should now go away.  */
-	      if (judge_scroll_bars_hook)
-		judge_scroll_bars_hook (f);
+	      if (FRAME_DISPLAY (f)->judge_scroll_bars_hook)
+		FRAME_DISPLAY (f)->judge_scroll_bars_hook (f);

 	      /* If fonts changed, display again.  */
 	      /* ??? rms: I suspect it is a mistake to jump all the way
@@ -10237,8 +10235,8 @@
 	    {
 	      struct frame *f = updated[i];
 	      mark_window_display_accurate (f->root_window, 1);
-	      if (frame_up_to_date_hook)
-		frame_up_to_date_hook (f);
+	      if (FRAME_DISPLAY (f)->frame_up_to_date_hook)
+		FRAME_DISPLAY (f)->frame_up_to_date_hook (f);
 	    }
 	}
     }
@@ -10323,8 +10321,8 @@
 	  /* Say overlay arrows are up to date.  */
 	  update_overlay_arrows (1);

-	  if (frame_up_to_date_hook != 0)
-	    frame_up_to_date_hook (sf);
+	  if (FRAME_DISPLAY (sf)->frame_up_to_date_hook != 0)
+	    FRAME_DISPLAY (sf)->frame_up_to_date_hook (sf);
 	}

       update_mode_lines = 0;
@@ -10411,8 +10409,9 @@
   else
     redisplay_internal (1);

-  if (rif != NULL && rif->flush_display_optional)
-    rif->flush_display_optional (NULL);
+  if (FRAME_RIF (SELECTED_FRAME ()) != NULL
+      && FRAME_RIF (SELECTED_FRAME ())->flush_display_optional)
+    FRAME_RIF (SELECTED_FRAME ())->flush_display_optional (NULL);
 }


@@ -11527,7 +11526,9 @@
     start = end = whole = 0;

   /* Indicate what this scroll bar ought to be displaying now.  */
-  set_vertical_scroll_bar_hook (w, end - start, whole, start);
+  if (FRAME_DISPLAY (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
+    (*FRAME_DISPLAY (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
+      (w, end - start, whole, start);
 }


@@ -12205,17 +12206,19 @@
         display_menu_bar (w);

 #ifdef HAVE_WINDOW_SYSTEM
+      if (FRAME_WINDOW_P (f))
+        {
 #ifdef USE_GTK
-      redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
+          redisplay_tool_bar_p = FRAME_EXTERNAL_TOOL_BAR (f);
 #else
-      redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
-        && (FRAME_TOOL_BAR_LINES (f) > 0
-            || auto_resize_tool_bars_p);
-
-#endif
-
-      if (redisplay_tool_bar_p)
-        redisplay_tool_bar (f);
+          redisplay_tool_bar_p = WINDOWP (f->tool_bar_window)
+            && (FRAME_TOOL_BAR_LINES (f) > 0
+                || auto_resize_tool_bars_p);
+#endif
+
+          if (redisplay_tool_bar_p)
+            redisplay_tool_bar (f);
+        }
 #endif
     }

@@ -12250,7 +12253,8 @@

       /* Note that we actually used the scroll bar attached to this
 	 window, so it shouldn't be deleted at the end of redisplay.  */
-      redeem_scroll_bar_hook (w);
+      if (FRAME_DISPLAY (f)->redeem_scroll_bar_hook)
+        (*FRAME_DISPLAY (f)->redeem_scroll_bar_hook) (w);
     }

   /* Restore current_buffer and value of point in it.  */
@@ -12485,10 +12489,10 @@
 	  if (run.height > 0 && run.current_y != run.desired_y)
 	    {
 	      update_begin (f);
-	      rif->update_window_begin_hook (w);
-	      rif->clear_window_mouse_face (w);
-	      rif->scroll_run_hook (w, &run);
-	      rif->update_window_end_hook (w, 0, 0);
+	      FRAME_RIF (f)->update_window_begin_hook (w);
+	      FRAME_RIF (f)->clear_window_mouse_face (w);
+	      FRAME_RIF (f)->scroll_run_hook (w, &run);
+	      FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
 	      update_end (f);
 	    }

@@ -12657,10 +12661,10 @@
       if (run.height)
 	{
 	  update_begin (f);
-	  rif->update_window_begin_hook (w);
-	  rif->clear_window_mouse_face (w);
-	  rif->scroll_run_hook (w, &run);
-	  rif->update_window_end_hook (w, 0, 0);
+	  FRAME_RIF (f)->update_window_begin_hook (w);
+	  FRAME_RIF (f)->clear_window_mouse_face (w);
+	  FRAME_RIF (f)->scroll_run_hook (w, &run);
+	  FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
 	  update_end (f);
 	}

@@ -13108,7 +13112,7 @@

   /* Window must either use window-based redisplay or be full width.  */
   if (!FRAME_WINDOW_P (f)
-      && (!line_ins_del_ok
+      && (!FRAME_LINE_INS_DEL_OK (f)
 	  || !WINDOW_FULL_WIDTH_P (w)))
     GIVE_UP (4);

@@ -13515,10 +13519,10 @@

       if (FRAME_WINDOW_P (f))
 	{
-	  rif->update_window_begin_hook (w);
-	  rif->clear_window_mouse_face (w);
-	  rif->scroll_run_hook (w, &run);
-	  rif->update_window_end_hook (w, 0, 0);
+	  FRAME_RIF (f)->update_window_begin_hook (w);
+	  FRAME_RIF (f)->clear_window_mouse_face (w);
+	  FRAME_RIF (f)->scroll_run_hook (w, &run);
+	  FRAME_RIF (f)->update_window_end_hook (w, 0, 0);
 	}
       else
 	{
@@ -13536,36 +13540,36 @@
 	    {
 	      /* Scroll last_unchanged_at_beg_row to the end of the
 		 window down dvpos lines.  */
-	      set_terminal_window (end);
+	      set_terminal_window (f, end);

 	      /* On dumb terminals delete dvpos lines at the end
 		 before inserting dvpos empty lines.  */
-	      if (!scroll_region_ok)
-		ins_del_lines (end - dvpos, -dvpos);
+	      if (!FRAME_SCROLL_REGION_OK (f))
+		ins_del_lines (f, end - dvpos, -dvpos);

 	      /* Insert dvpos empty lines in front of
                  last_unchanged_at_beg_row.  */
-	      ins_del_lines (from, dvpos);
+	      ins_del_lines (f, from, dvpos);
 	    }
 	  else if (dvpos < 0)
 	    {
 	      /* Scroll up last_unchanged_at_beg_vpos to the end of
 		 the window to last_unchanged_at_beg_vpos - |dvpos|.  */
-	      set_terminal_window (end);
+	      set_terminal_window (f, end);

 	      /* Delete dvpos lines in front of
 		 last_unchanged_at_beg_vpos.  ins_del_lines will set
 		 the cursor to the given vpos and emit |dvpos| delete
 		 line sequences.  */
-	      ins_del_lines (from + dvpos, dvpos);
+	      ins_del_lines (f, from + dvpos, dvpos);

 	      /* On a dumb terminal insert dvpos empty lines at the
                  end.  */
-	      if (!scroll_region_ok)
-		ins_del_lines (end + dvpos, -dvpos);
-	    }
-
-	  set_terminal_window (0);
+	      if (!FRAME_SCROLL_REGION_OK (f))
+		ins_del_lines (f, end + dvpos, -dvpos);
+	    }
+
+	  set_terminal_window (f, 0);
 	}

       update_end (f);
@@ -14916,12 +14920,10 @@
 		{
 		  if (!get_next_display_element (it))
 		    {
-#ifdef HAVE_WINDOW_SYSTEM
 		      it->continuation_lines_width = 0;
 		      row->ends_at_zv_p = 1;
 		      row->exact_window_width_line_p = 1;
 		      break;
-#endif /* HAVE_WINDOW_SYSTEM */
 		    }
 		  if (ITERATOR_AT_END_OF_LINE_P (it))
 		    {
@@ -16521,8 +16523,8 @@
 	  {
 	    /* No need to mention EOL here--the terminal never needs
 	       to do EOL conversion.  */
-	    p = decode_mode_spec_coding (keyboard_coding.symbol, p, 0);
-	    p = decode_mode_spec_coding (terminal_coding.symbol, p, 0);
+	    p = decode_mode_spec_coding (FRAME_KEYBOARD_CODING (f)->symbol, p, 0);
+	    p = decode_mode_spec_coding (FRAME_TERMINAL_CODING (f)->symbol, p, 0);
 	  }
 	p = decode_mode_spec_coding (b->buffer_file_coding_system,
 				     p, eol_flag);
@@ -17359,7 +17361,7 @@
 	    = FONT_INFO_FROM_ID (f, face->font_info_id);
 	  if (font_info)
 	    glyph->font_type
-	      = rif->encode_char (glyph->u.ch, char2b, font_info, two_byte_p);
+	      = FRAME_RIF (f)->encode_char (glyph->u.ch, char2b, font_info, two_byte_p);
 	}
     }

@@ -17590,7 +17592,7 @@
       font = face->font;
       font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
       if (font  /* ++KFS: Should this be font_info ?  */
-	  && (pcm = rif->per_char_metric (font, &char2b, glyph->font_type)))
+	  && (pcm = FRAME_RIF (f)->per_char_metric (font, &char2b, glyph->font_type)))
 	{
 	  if (pcm->rbearing > pcm->width)
 	    *right = pcm->rbearing - pcm->width;
@@ -17758,7 +17760,7 @@
 	  struct font_info *font_info
 	    = FONT_INFO_FROM_ID (f, face->font_info_id);
 	  if (font_info)
-	    rif->encode_char (c, char2b, font_info, 0);
+	    FRAME_RIF (f)->encode_char (c, char2b, font_info, 0);
 	}
     }

@@ -17825,8 +17827,8 @@
     {
       while (s)
 	{
-	  if (rif->compute_glyph_string_overhangs)
-	    rif->compute_glyph_string_overhangs (s);
+	  if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
+	    FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 	  x -= s->width;
 	  s->x = x;
 	  s = s->prev;
@@ -17836,8 +17838,8 @@
     {
       while (s)
 	{
-	  if (rif->compute_glyph_string_overhangs)
-	    rif->compute_glyph_string_overhangs (s);
+	  if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
+	    FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 	  s->x = x;
 	  x += s->width;
 	  s = s->next;
@@ -18118,9 +18120,9 @@
       struct glyph_string *h, *t;

       /* Compute overhangs for all glyph strings.  */
-      if (rif->compute_glyph_string_overhangs)
+      if (FRAME_RIF (f)->compute_glyph_string_overhangs)
 	for (s = head; s; s = s->next)
-	  rif->compute_glyph_string_overhangs (s);
+	  FRAME_RIF (f)->compute_glyph_string_overhangs (s);

       /* Prepend glyph strings for glyphs in front of the first glyph
 	 string that are overwritten because of the first glyph
@@ -18188,7 +18190,7 @@

   /* Draw all strings.  */
   for (s = head; s; s = s->next)
-    rif->draw_glyph_string (s);
+    FRAME_RIF (f)->draw_glyph_string (s);

   if (area == TEXT_AREA
       && !row->full_width_p
@@ -18877,20 +18879,20 @@

 	  it->nglyphs = 1;

-	  pcm = rif->per_char_metric (font, &char2b,
-				      FONT_TYPE_FOR_UNIBYTE (font, it->char_to_display));
-
-	  if (it->override_ascent >= 0)
-	    {
-	      it->ascent = it->override_ascent;
-	      it->descent = it->override_descent;
-	      boff = it->override_boff;
-	    }
-	  else
-	    {
-	      it->ascent = FONT_BASE (font) + boff;
-	      it->descent = FONT_DESCENT (font) - boff;
-	    }
+          pcm = FRAME_RIF (it->f)->per_char_metric
+            (font, &char2b, FONT_TYPE_FOR_UNIBYTE (font, it->char_to_display));
+
+ 	  if (it->override_ascent >= 0)
+ 	    {
+ 	      it->ascent = it->override_ascent;
+ 	      it->descent = it->override_descent;
+ 	      boff = it->override_boff;
+ 	    }
+ 	  else
+ 	    {
+ 	      it->ascent = FONT_BASE (font) + boff;
+ 	      it->descent = FONT_DESCENT (font) - boff;
+ 	    }

 	  if (pcm)
 	    {
@@ -19093,8 +19095,8 @@
 	     from the charset width; this is what old redisplay code
 	     did.  */

-	  pcm = rif->per_char_metric (font, &char2b,
-				      FONT_TYPE_FOR_MULTIBYTE (font, it->c));
+	  pcm = FRAME_RIF (it->f)->per_char_metric (font, &char2b,
+                                                    FONT_TYPE_FOR_MULTIBYTE (font, it->c));

 	  if (font_not_found_p || !pcm)
 	    {
@@ -19225,8 +19227,8 @@

 	  /* Initialize the bounding box.  */
 	  if (font_info
-	      && (pcm = rif->per_char_metric (font, &char2b,
-					      FONT_TYPE_FOR_MULTIBYTE (font, it->c))))
+	      && (pcm = FRAME_RIF (it->f)->per_char_metric (font, &char2b,
+                                                            FONT_TYPE_FOR_MULTIBYTE (font, it->c))))
 	    {
 	      width = pcm->width;
 	      ascent = pcm->ascent;
@@ -19284,8 +19286,8 @@
 		}

 	      if (font_info
-		  && (pcm = rif->per_char_metric (font, &char2b,
-						  FONT_TYPE_FOR_MULTIBYTE (font, ch))))
+		  && (pcm = FRAME_RIF (it->f)->per_char_metric (font, &char2b,
+                                                                FONT_TYPE_FOR_MULTIBYTE (font, ch))))
 		{
 		  width = pcm->width;
 		  ascent = pcm->ascent;
@@ -19521,8 +19523,8 @@
   frame_x = window_box_left (w, updated_area) + output_cursor.x;
   frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);

-  rif->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
-				line_height, shift_by_width);
+  FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
+                                          line_height, shift_by_width);

   /* Write the glyphs.  */
   hpos = start - row->glyphs[updated_area];
@@ -19604,8 +19606,8 @@
   if (to_x > from_x && to_y > from_y)
     {
       BLOCK_INPUT;
-      rif->clear_frame_area (f, from_x, from_y,
-			     to_x - from_x, to_y - from_y);
+      FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
+                                       to_x - from_x, to_y - from_y);
       UNBLOCK_INPUT;
     }
 }
@@ -20067,8 +20069,8 @@
       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));

-      rif->clear_frame_area (f, x, y,
-			     cursor_glyph->pixel_width, cursor_row->visible_height);
+      FRAME_RIF (f)->clear_frame_area (f, x, y,
+                                       cursor_glyph->pixel_width, cursor_row->visible_height);
     }

   /* Erase the cursor by redrawing the character underneath it.  */
@@ -20165,9 +20167,9 @@
       w->phys_cursor.vpos = vpos;
     }

-  rif->draw_window_cursor (w, glyph_row, x, y,
-			   new_cursor_type, new_cursor_width,
-			   on, active_cursor);
+  FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
+                                     new_cursor_type, new_cursor_width,
+                                     on, active_cursor);
 }


@@ -20312,11 +20314,11 @@

   /* Change the mouse cursor.  */
   if (draw == DRAW_NORMAL_TEXT)
-    rif->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
+    FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->text_cursor);
   else if (draw == DRAW_MOUSE_FACE)
-    rif->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
-  else
-    rif->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
+    FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->hand_cursor);
+  else
+    FRAME_RIF (f)->define_frame_cursor (f, FRAME_X_OUTPUT (f)->nontext_cursor);
 }

 /* EXPORT:
@@ -20730,7 +20732,6 @@
 	  return inside;
 	}
     }
-  /* If we don't understand the format, pretend we're not in the hot-spot.  */
   return 0;
 }

@@ -20810,7 +20811,7 @@
     }

   if (cursor != No_Cursor)
-    rif->define_frame_cursor (f, cursor);
+    FRAME_RIF (f)->define_frame_cursor (f, cursor);
 }

 /* Take proper action when mouse has moved to the mode or header line
@@ -21627,8 +21628,8 @@
 	 I assume the effect is the same -- and this is portable.  */
       return x_intersect_rectangles (&cr, r, &result);
     }
-  else
-    return 0;
+  /* If we don't understand the format, pretend we're not in the hot-spot.  */
+  return 0;
 }


@@ -21640,6 +21641,8 @@
 x_draw_vertical_border (w)
      struct window *w;
 {
+  struct frame *f = XFRAME (WINDOW_FRAME (w));
+
   /* We could do better, if we knew what type of scroll-bar the adjacent
      windows (on either side) have...  But we don't :-(
      However, I think this works ok.  ++KFS 2003-04-25 */
@@ -21659,7 +21662,7 @@
       window_box_edges (w, -1, &x0, &y0, &x1, &y1);
       y1 -= 1;

-      rif->draw_vertical_window_border (w, x1, y0, y1);
+      FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
     }
   else if (!WINDOW_LEFTMOST_P (w)
 	   && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
@@ -21669,7 +21672,7 @@
       window_box_edges (w, -1, &x0, &y0, &x1, &y1);
       y1 -= 1;

-      rif->draw_vertical_window_border (w, x0, y0, y1);
+      FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
     }
 }
--- a/src/xfaces.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xfaces.c	Mon Oct 25 18:17:28 2004 +0000
@@ -195,11 +195,13 @@
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <stdio.h>              /* This needs to be before termchar.h */

 #include "lisp.h"
 #include "charset.h"
 #include "keyboard.h"
 #include "frame.h"
+#include "termhooks.h"

 #ifdef HAVE_WINDOW_SYSTEM
 #include "fontset.h"
@@ -242,6 +244,7 @@
 #include "blockinput.h"
 #include "window.h"
 #include "intervals.h"
+#include "termchar.h"

 #ifdef HAVE_X_WINDOWS

@@ -6056,7 +6059,7 @@
   /* See if the capabilities we selected above are supported, with the
      given colors.  */
   if (test_caps != 0 &&
-      ! tty_capable_p (f, test_caps, fg_tty_color.pixel, bg_tty_color.pixel))
+      ! tty_capable_p (FRAME_TTY (f), test_caps, fg_tty_color.pixel, bg_tty_color.pixel))
     return 0;


@@ -6849,7 +6852,8 @@
 	{
 	  FRAME_FACE_CACHE (f)->menu_face_changed_p = 0;
 #ifdef USE_X_TOOLKIT
-	  x_update_menu_appearance (f);
+          if (FRAME_WINDOW_P (f))
+            x_update_menu_appearance (f);
 #endif
 	}

@@ -6936,7 +6940,7 @@
 	LFACE_FOREGROUND (lface) = XCDR (color);
       else if (FRAME_WINDOW_P (f))
 	return 0;
-      else if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
+      else if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 	LFACE_FOREGROUND (lface) = build_string (unspecified_fg);
       else
 	abort ();
@@ -6951,7 +6955,7 @@
 	LFACE_BACKGROUND (lface) = XCDR (color);
       else if (FRAME_WINDOW_P (f))
 	return 0;
-      else if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
+      else if (FRAME_INITIAL_P (f) || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 	LFACE_BACKGROUND (lface) = build_string (unspecified_bg);
       else
 	abort ();
@@ -7040,6 +7044,11 @@
     face = realize_x_face (cache, attrs, c, base_face);
   else if (FRAME_TERMCAP_P (cache->f) || FRAME_MSDOS_P (cache->f))
     face = realize_tty_face (cache, attrs, c);
+  else if (FRAME_INITIAL_P (cache->f))
+    {
+      /* Create a dummy face. */
+      face = make_realized_face (attrs);
+    }
   else
     abort ();
--- a/src/xfns.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xfns.c	Mon Oct 25 18:17:28 2004 +0000
@@ -48,6 +48,7 @@
 #include "systime.h"
 #include "termhooks.h"
 #include "atimer.h"
+#include "termchar.h"

 #ifdef HAVE_X_WINDOWS

@@ -256,6 +257,17 @@
       else
 	error ("X windows are not in use or not initialized");
     }
+  else if (INTEGERP (frame))
+    {
+      struct display *d = get_display (XINT (frame));
+
+      if (!d)
+        wrong_type_argument (Qdisplay_live_p, frame);
+      if (d->type != output_x_window)
+        error ("Display %d is not an X display", XINT (frame));
+
+      dpyinfo = d->display_info.x;
+    }
   else if (STRINGP (frame))
     dpyinfo = x_display_info_for_name (frame);
   else
@@ -1379,10 +1391,8 @@
      below the menu bar.  */
   if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
     {
-      updating_frame = f;
-      clear_frame ();
+      clear_frame (f);
       clear_current_matrices (f);
-      updating_frame = NULL;
     }

   /* If the tool bar gets smaller, the internal border below it
@@ -1429,10 +1439,10 @@
   if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
     {
       /* Remove all scroll bars because they have wrong colors.  */
-      if (condemn_scroll_bars_hook)
-	(*condemn_scroll_bars_hook) (f);
-      if (judge_scroll_bars_hook)
-	(*judge_scroll_bars_hook) (f);
+      if (FRAME_DISPLAY (f)->condemn_scroll_bars_hook)
+	(*FRAME_DISPLAY (f)->condemn_scroll_bars_hook) (f);
+      if (FRAME_DISPLAY (f)->judge_scroll_bars_hook)
+	(*FRAME_DISPLAY (f)->judge_scroll_bars_hook) (f);

       update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
       redraw_frame (f);
@@ -1478,10 +1488,10 @@
   if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
     {
       /* Remove all scroll bars because they have wrong colors.  */
-      if (condemn_scroll_bars_hook)
-	(*condemn_scroll_bars_hook) (f);
-      if (judge_scroll_bars_hook)
-	(*judge_scroll_bars_hook) (f);
+      if (FRAME_DISPLAY (f)->condemn_scroll_bars_hook)
+	(*FRAME_DISPLAY (f)->condemn_scroll_bars_hook) (f);
+      if (FRAME_DISPLAY (f)->judge_scroll_bars_hook)
+	(*FRAME_DISPLAY (f)->judge_scroll_bars_hook) (f);

       update_face_from_frame_parameter (f, Qscroll_bar_background, value);
       redraw_frame (f);
@@ -2895,13 +2905,13 @@
   Lisp_Object parent;
   struct kboard *kb;

-  check_x ();
-
   /* Use this general default value to start with
      until we know if this frame has a specified name.  */
   Vx_resource_name = Vinvocation_name;

-  display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
+  display = x_get_arg (dpyinfo, parms, Qdisplay_id, 0, 0, RES_TYPE_NUMBER);
+  if (EQ (display, Qunbound))
+    display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
   if (EQ (display, Qunbound))
     display = Qnil;
   dpyinfo = check_x_display_info (display);
@@ -2951,6 +2961,9 @@
   /* Note that X Windows does support scroll bars.  */
   FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;

+  f->display = dpyinfo->frame_display;
+  f->display->reference_count++;
+
   f->output_method = output_x_window;
   f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
   bzero (f->output_data.x, sizeof (struct x_output));
@@ -3040,6 +3053,8 @@
       specbind (Qx_resource_name, name);
     }

+  Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qx), Qnil));
+
   /* Extract the window parameters from the supplied values
      that are needed to determine window geometry.  */
   {
@@ -3839,8 +3854,10 @@

   CHECK_STRING (name);

-  if (! EQ (Vwindow_system, intern ("x")))
-    error ("Not using X Windows");
+#if 0
+  if (! EQ (Vinitial_window_system, intern ("x")))
+    error ("Not using X Windows"); /* That doesn't stop us anymore. */
+#endif

   for (dpyinfo = x_display_list, names = x_display_name_list;
        dpyinfo;
@@ -3887,8 +3904,10 @@
   if (! NILP (xrm_string))
     CHECK_STRING (xrm_string);

-  if (! EQ (Vwindow_system, intern ("x")))
-    error ("Not using X Windows");
+#if 0
+  if (! EQ (Vinitial_window_system, intern ("x")))
+    error ("Not using X Windows"); /* That doesn't stop us anymore. */
+#endif

   if (! NILP (xrm_string))
     xrm_option = (unsigned char *) SDATA (xrm_string);
@@ -4501,6 +4520,9 @@
   FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
   record_unwind_protect (unwind_create_tip_frame, frame);

+  f->display = dpyinfo->frame_display;
+  f->display->reference_count++;
+
   /* By setting the output method, we're essentially saying that
      the frame is live, as per FRAME_LIVE_P.  If we get a signal
      from this point on, x_destroy_window might screw up reference
@@ -4724,6 +4746,8 @@
 					      Qnil));
   }

+  Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qx), Qnil));
+
   f->no_split = 1;

   UNGCPRO;
--- a/src/xmenu.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xmenu.c	Mon Oct 25 18:17:28 2004 +0000
@@ -39,10 +39,10 @@
 #include <stdio.h>

 #include "lisp.h"
-#include "termhooks.h"
 #include "keyboard.h"
 #include "keymap.h"
 #include "frame.h"
+#include "termhooks.h"
 #include "window.h"
 #include "blockinput.h"
 #include "buffer.h"
--- a/src/xselect.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xselect.c	Mon Oct 25 18:17:28 2004 +0000
@@ -308,13 +308,20 @@
      Lisp_Object selection_name, selection_value;
 {
   struct frame *sf = SELECTED_FRAME ();
-  Window selecting_window = FRAME_X_WINDOW (sf);
-  Display *display = FRAME_X_DISPLAY (sf);
+  Window selecting_window;
+  Display *display;
   Time time = last_event_timestamp;
   Atom selection_atom;
-  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (sf);
+  struct x_display_info *dpyinfo;
   int count;

+  if (! FRAME_X_P (sf))
+    return;
+
+  selecting_window = FRAME_X_WINDOW (sf);
+  display = FRAME_X_DISPLAY (sf);
+  dpyinfo = FRAME_X_DISPLAY_INFO (sf);
+
   CHECK_SYMBOL (selection_name);
   selection_atom = symbol_to_x_atom (dpyinfo, display, selection_name);

@@ -578,7 +585,8 @@

   FOR_EACH_FRAME (list, frame)
     {
-      if (FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
+      if (FRAME_X_P (XFRAME (frame))
+          && FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
 	return frame;
     }

@@ -1234,17 +1242,26 @@
      Lisp_Object selection_symbol, target_type, time_stamp;
 {
   struct frame *sf = SELECTED_FRAME ();
-  Window requestor_window = FRAME_X_WINDOW (sf);
-  Display *display = FRAME_X_DISPLAY (sf);
-  struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (sf);
+  Window requestor_window;
+  Display *display;
+  struct x_display_info *dpyinfo;
   Time requestor_time = last_event_timestamp;
-  Atom target_property = dpyinfo->Xatom_EMACS_TMP;
-  Atom selection_atom = symbol_to_x_atom (dpyinfo, display, selection_symbol);
+  Atom target_property;
+  Atom selection_atom;
   Atom type_atom;
   int secs, usecs;
   int count;
   Lisp_Object frame;

+  if (! FRAME_X_P (sf))
+    return Qnil;
+
+  requestor_window = FRAME_X_WINDOW (sf);
+  display = FRAME_X_DISPLAY (sf);
+  dpyinfo = FRAME_X_DISPLAY_INFO (sf);
+  target_property = dpyinfo->Xatom_EMACS_TMP;
+  selection_atom = symbol_to_x_atom (dpyinfo, display, selection_symbol);
+
   if (CONSP (target_type))
     type_atom = symbol_to_x_atom (dpyinfo, display, XCAR (target_type));
   else
@@ -2019,6 +2036,9 @@
   struct frame *sf = SELECTED_FRAME ();

   check_x ();
+  if (! FRAME_X_P (sf))
+    return Qnil;
+
   display = FRAME_X_DISPLAY (sf);
   dpyinfo = FRAME_X_DISPLAY_INFO (sf);
   CHECK_SYMBOL (selection);
@@ -2182,6 +2202,10 @@
   struct frame *sf = SELECTED_FRAME ();

   check_x ();
+
+  if (! FRAME_X_P (sf))
+    return Qnil;
+
   display = FRAME_X_DISPLAY (sf);
   dpyinfo = FRAME_X_DISPLAY_INFO (sf);
   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
@@ -2223,6 +2247,10 @@
   struct frame *sf = SELECTED_FRAME ();

   check_x ();
+
+  if (! FRAME_X_P (sf))
+    return Qnil;
+
   display = FRAME_X_DISPLAY (sf);
   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */

@@ -2279,8 +2307,12 @@
   Atom props[8];
   Display *display;
   struct frame *sf = SELECTED_FRAME ();
-
+
   check_x ();
+
+  if (! FRAME_X_P (sf))
+    return Qnil;
+
   display = FRAME_X_DISPLAY (sf);
   window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
   CHECK_NUMBER (n);
--- a/src/xsmfns.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xsmfns.c	Mon Oct 25 18:17:28 2004 +0000
@@ -48,6 +48,7 @@
 #include "systime.h"
 #include "sysselect.h"
 #include "lisp.h"
+#include "frame.h"
 #include "termhooks.h"
 #include "termopts.h"
 #include "xterm.h"
--- a/src/xterm.c	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xterm.c	Mon Oct 25 18:17:28 2004 +0000
@@ -54,7 +54,6 @@
 #include <sys/ioctl.h>
 #endif /* ! defined (BSD_SYSTEM) */

-#include "systty.h"
 #include "systime.h"

 #ifndef INCLUDED_FCNTL
@@ -336,14 +335,16 @@
 void x_set_window_size P_ ((struct frame *, int, int, int));
 void x_wm_set_window_state P_ ((struct frame *, int));
 void x_wm_set_icon_pixmap P_ ((struct frame *, int));
+struct display *x_create_frame_display P_ ((struct x_display_info *));
+void x_delete_frame_display P_ ((struct display *));
 void x_initialize P_ ((void));
 static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
 static int x_compute_min_glyph_bounds P_ ((struct frame *));
 static void x_update_end P_ ((struct frame *));
 static void XTframe_up_to_date P_ ((struct frame *));
-static void XTset_terminal_modes P_ ((void));
-static void XTreset_terminal_modes P_ ((void));
-static void x_clear_frame P_ ((void));
+static void XTset_terminal_modes P_ ((struct display *));
+static void XTreset_terminal_modes P_ ((struct display *));
+static void x_clear_frame P_ ((struct frame *));
 static void frame_highlight P_ ((struct frame *));
 static void frame_unhighlight P_ ((struct frame *));
 static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
@@ -384,7 +385,8 @@
     {
       Lisp_Object rest, frame;
       FOR_EACH_FRAME (rest, frame)
-	x_flush (XFRAME (frame));
+        if (FRAME_X_P (XFRAME (frame)))
+          x_flush (XFRAME (frame));
     }
   else if (FRAME_X_P (f))
     XFlush (FRAME_X_DISPLAY (f));
@@ -471,7 +473,6 @@
   /* Nothing to do.  */
 }

-
 /* Start update of window W.  Set the global variable updated_window
    to the window being updated and set output_cursor to the cursor
    position of W.  */
@@ -790,7 +791,7 @@
    rarely happens).  */

 static void
-XTset_terminal_modes ()
+XTset_terminal_modes (struct display *display)
 {
 }

@@ -798,7 +799,7 @@
    the X-windows go away, and suspending requires no action.  */

 static void
-XTreset_terminal_modes ()
+XTreset_terminal_modes (struct display *display)
 {
 }

@@ -1410,7 +1411,8 @@
   for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
     if (GC_FRAMEP (XCAR (tail))
 	&& (f = XFRAME (XCAR (tail)),
-	    (f->output_data.nothing != 1
+	    (FRAME_X_P (f)
+             && f->output_data.nothing != 1
 	     && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
 	&& f->output_data.x->widget == widget)
       return f;
@@ -2770,7 +2772,8 @@
    for X frames.  */

 static void
-x_delete_glyphs (n)
+x_delete_glyphs (f, n)
+     struct frame *f;
      register int n;
 {
   abort ();
@@ -2797,15 +2800,8 @@
    frame.  Otherwise clear the selected frame.  */

 static void
-x_clear_frame ()
-{
-  struct frame *f;
-
-  if (updating_frame)
-    f = updating_frame;
-  else
-    f = SELECTED_FRAME ();
-
+x_clear_frame (struct frame *f)
+{
   /* Clearing the frame will erase any cursor, so mark them all as no
      longer visible.  */
   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
@@ -3051,7 +3047,8 @@
    lines or deleting -N lines at vertical position VPOS.  */

 static void
-x_ins_del_lines (vpos, n)
+x_ins_del_lines (f, vpos, n)
+     struct frame *f;
      int vpos, n;
 {
   abort ();
@@ -3725,7 +3722,8 @@

       /* Clear the mouse-moved flag for every frame on this display.  */
       FOR_EACH_FRAME (tail, frame)
-	if (FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
+	if (FRAME_X_P (XFRAME (frame))
+            && FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
 	  XFRAME (frame)->mouse_moved = 0;

       last_mouse_scroll_bar = Qnil;
@@ -3939,6 +3937,9 @@
       if (! GC_FRAMEP (frame))
 	abort ();

+      if (! FRAME_X_P (XFRAME (frame)))
+        continue;
+
       /* Scan this frame's scroll bar list for a scroll bar with the
          right window ID.  */
       condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
@@ -3973,11 +3974,14 @@
        XGCTYPE (tail) == Lisp_Cons;
        tail = XCDR (tail))
     {
-      Lisp_Object frame = XCAR (tail);
-      Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
-
-      if (menu_bar && xlwmenu_window_p (menu_bar, window))
-	return menu_bar;
+      if (FRAME_X_P (XFRAME (XCAR (tail))))
+        {
+          Lisp_Object frame = XCAR (tail);
+          Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
+
+          if (menu_bar && xlwmenu_window_p (menu_bar, window))
+            return menu_bar;
+        }
     }

   return NULL;
@@ -6364,37 +6368,37 @@

           orig_keysym = keysym;

-	  /* Common for all keysym input events.  */
-	  XSETFRAME (inev.frame_or_window, f);
-	  inev.modifiers
-	    = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f), modifiers);
-	  inev.timestamp = event.xkey.time;
-
-	  /* First deal with keysyms which have defined
-	     translations to characters.  */
-	  if (keysym >= 32 && keysym < 128)
-	    /* Avoid explicitly decoding each ASCII character.  */
-	    {
-	      inev.kind = ASCII_KEYSTROKE_EVENT;
-	      inev.code = keysym;
-	      goto done_keysym;
-	    }
-
-	  /* Now non-ASCII.  */
-	  if (HASH_TABLE_P (Vx_keysym_table)
-	      && (NATNUMP (c = Fgethash (make_number (keysym),
-					 Vx_keysym_table,
-					 Qnil))))
-	    {
-	      inev.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
-			    ? ASCII_KEYSTROKE_EVENT
-			    : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
-	      inev.code = XFASTINT (c);
-	      goto done_keysym;
-	    }
-
-	  /* Random non-modifier sorts of keysyms.  */
-	  if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
+ 	  /* Common for all keysym input events.  */
+ 	  XSETFRAME (inev.frame_or_window, f);
+ 	  inev.modifiers
+ 	    = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f), modifiers);
+ 	  inev.timestamp = event.xkey.time;
+
+ 	  /* First deal with keysyms which have defined
+ 	     translations to characters.  */
+ 	  if (keysym >= 32 && keysym < 128)
+ 	    /* Avoid explicitly decoding each ASCII character.  */
+ 	    {
+ 	      inev.kind = ASCII_KEYSTROKE_EVENT;
+ 	      inev.code = keysym;
+ 	      goto done_keysym;
+ 	    }
+
+ 	  /* Now non-ASCII.  */
+ 	  if (HASH_TABLE_P (Vx_keysym_table)
+ 	      && (NATNUMP (c = Fgethash (make_number (keysym),
+ 					 Vx_keysym_table,
+ 					 Qnil))))
+ 	    {
+ 	      inev.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
+ 			    ? ASCII_KEYSTROKE_EVENT
+ 			    : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
+ 	      inev.code = XFASTINT (c);
+ 	      goto done_keysym;
+ 	    }
+
+ 	  /* Random non-modifier sorts of keysyms.  */
+ 	  if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
                         || keysym == XK_Delete
 #ifdef XK_ISO_Left_Tab
                         || (keysym >= XK_ISO_Left_Tab
@@ -7027,8 +7031,8 @@
    EXPECTED is nonzero if the caller knows input is available.  */

 static int
-XTread_socket (sd, expected, hold_quit)
-     register int sd;
+XTread_socket (display, expected, hold_quit)
+     struct display *display;
      int expected;
      struct input_event *hold_quit;
 {
@@ -7615,7 +7619,7 @@
 {
   Lisp_Object first = XCAR (old_val);
   Display *dpy = XSAVE_VALUE (first)->pointer;
-
+
   /* The display may have been closed before this function is called.
      Check if it is still open before calling XSync.  */
   if (x_display_info_for_display (dpy) != 0)
@@ -7733,6 +7737,7 @@
   struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
   Lisp_Object frame, tail;
   int count;
+  int index = SPECPDL_INDEX ();

   error_msg = (char *) alloca (strlen (error_message) + 1);
   strcpy (error_msg, error_message);
@@ -7780,6 +7785,9 @@
   if (dpyinfo)
     dpyinfo->display = 0;

+  /* Inhibit redisplay while frames are being deleted. */
+  specbind (Qinhibit_redisplay, Qt);
+
   /* First delete frames whose mini-buffers are on frames
      that are on the dead display.  */
   FOR_EACH_FRAME (tail, frame)
@@ -7812,7 +7820,7 @@

   x_uncatch_errors (dpy, count);

-  if (x_display_list == 0)
+  if (display_list == 0)
     {
       fprintf (stderr, "%s\n", error_msg);
       shut_down_emacs (0, 0, Qnil);
@@ -7826,6 +7834,7 @@
   sigunblock (sigmask (SIGALRM));
   TOTALLY_UNBLOCK_INPUT;

+  unbind_to (index, Qnil);
   clear_waiting_for_input ();
   error ("%s", error_msg);
 }
@@ -8009,7 +8018,7 @@
   FOR_EACH_FRAME (tail, frame)
     {
       struct frame *f = XFRAME (frame);
-      if (FRAME_X_DISPLAY_INFO (f) == dpyinfo)
+      if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
 	{
 	  FRAME_XIC (f) = NULL;
           xic_free_xfontset (f);
@@ -8108,7 +8117,8 @@
 	{
 	  struct frame *f = XFRAME (frame);

-	  if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
+	  if (FRAME_X_P (f)
+              && FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
 	    if (FRAME_XIC (f) == NULL)
 	      {
 		create_frame_xic (f);
@@ -10148,6 +10158,7 @@
 {
   int connection;
   Display *dpy;
+  struct display *display;
   struct x_display_info *dpyinfo;
   XrmDatabase xrdb;

@@ -10282,6 +10293,8 @@
   dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
   bzero (dpyinfo, sizeof *dpyinfo);

+  display = x_create_frame_display (dpyinfo);
+
 #ifdef MULTI_KBOARD
   {
     struct x_display_info *share;
@@ -10331,6 +10344,11 @@

   dpyinfo->display = dpy;

+  /* Set the name of the display. */
+  display->name = (char *) xmalloc (SBYTES (display_name) + 1);
+  strncpy (display->name, SDATA (display_name), SBYTES (display_name));
+  display->name[SBYTES (display_name)] = 0;
+
 #if 0
   XSetAfterFunction (x_current_display, x_trace_wire);
 #endif /* ! 0 */
@@ -10634,7 +10652,18 @@
      struct x_display_info *dpyinfo;
 {
   int i;
-
+
+  {
+    /* Delete the generic struct display for this X display. */
+    struct display *d;
+    for (d = display_list; d; d = d->next_display)
+      if (d->type == output_x_window && d->display_info.x == dpyinfo)
+        {
+          delete_display (d);
+          break;
+        }
+  }
+
   delete_keyboard_wait_descriptor (dpyinfo->connection);

   /* Discard this display from x_display_name_list and x_display_list.
@@ -10695,10 +10724,11 @@
 	xfree (dpyinfo->font_table[i].name);
       }

-  if (dpyinfo->font_table->font_encoder)
+  if (dpyinfo->font_table && dpyinfo->font_table->font_encoder)
     xfree (dpyinfo->font_table->font_encoder);

-  xfree (dpyinfo->font_table);
+  if (dpyinfo->font_table)
+    xfree (dpyinfo->font_table);
   xfree (dpyinfo->x_id_name);
   xfree (dpyinfo->color_cells);
   xfree (dpyinfo);
@@ -10732,70 +10762,97 @@
 extern frame_parm_handler x_frame_parm_handlers[];

 static struct redisplay_interface x_redisplay_interface =
-{
-  x_frame_parm_handlers,
-  x_produce_glyphs,
-  x_write_glyphs,
-  x_insert_glyphs,
-  x_clear_end_of_line,
-  x_scroll_run,
-  x_after_update_window_line,
-  x_update_window_begin,
-  x_update_window_end,
-  x_cursor_to,
-  x_flush,
+  {
+    x_frame_parm_handlers,
+    x_produce_glyphs,
+    x_write_glyphs,
+    x_insert_glyphs,
+    x_clear_end_of_line,
+    x_scroll_run,
+    x_after_update_window_line,
+    x_update_window_begin,
+    x_update_window_end,
+    x_cursor_to,
+    x_flush,
 #ifdef XFlush
-  x_flush,
+    x_flush,
 #else
-  0,  /* flush_display_optional */
-#endif
-  x_clear_window_mouse_face,
-  x_get_glyph_overhangs,
-  x_fix_overlapping_area,
-  x_draw_fringe_bitmap,
-  0, /* define_fringe_bitmap */
-  0, /* destroy_fringe_bitmap */
-  x_per_char_metric,
-  x_encode_char,
-  x_compute_glyph_string_overhangs,
-  x_draw_glyph_string,
-  x_define_frame_cursor,
-  x_clear_frame_area,
-  x_draw_window_cursor,
-  x_draw_vertical_window_border,
-  x_shift_glyphs_for_insert
-};
+    0,  /* flush_display_optional */
+#endif
+    x_clear_window_mouse_face,
+    x_get_glyph_overhangs,
+    x_fix_overlapping_area,
+    x_draw_fringe_bitmap,
+    0, /* define_fringe_bitmap */
+    0, /* destroy_fringe_bitmap */
+    x_per_char_metric,
+    x_encode_char,
+    x_compute_glyph_string_overhangs,
+    x_draw_glyph_string,
+    x_define_frame_cursor,
+    x_clear_frame_area,
+    x_draw_window_cursor,
+    x_draw_vertical_window_border,
+    x_shift_glyphs_for_insert
+  };
+
+
+/* This function is called when the last frame on a display is deleted. */
+void
+x_delete_frame_display (struct display *display)
+{
+  /* We don't do anything, the connection to the X server must remain
+     open. */
+}
+
+
+struct display *
+x_create_frame_display (struct x_display_info *dpyinfo)
+{
+  struct display *display;
+
+  display = create_display ();
+
+  display->type = output_x_window;
+  display->display_info.x = dpyinfo;
+  dpyinfo->frame_display = display;
+
+  display->clear_frame_hook = x_clear_frame;
+  display->ins_del_lines_hook = x_ins_del_lines;
+  display->delete_glyphs_hook = x_delete_glyphs;
+  display->ring_bell_hook = XTring_bell;
+  display->reset_terminal_modes_hook = XTreset_terminal_modes;
+  display->set_terminal_modes_hook = XTset_terminal_modes;
+  display->update_begin_hook = x_update_begin;
+  display->update_end_hook = x_update_end;
+  display->set_terminal_window_hook = XTset_terminal_window;
+  display->read_socket_hook = XTread_socket;
+  display->frame_up_to_date_hook = XTframe_up_to_date;
+  display->mouse_position_hook = XTmouse_position;
+  display->frame_rehighlight_hook = XTframe_rehighlight;
+  display->frame_raise_lower_hook = XTframe_raise_lower;
+  display->set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
+  display->condemn_scroll_bars_hook = XTcondemn_scroll_bars;
+  display->redeem_scroll_bar_hook = XTredeem_scroll_bar;
+  display->judge_scroll_bars_hook = XTjudge_scroll_bars;
+
+  display->delete_frame_hook = x_destroy_window;
+  display->delete_display_hook = x_delete_frame_display;
+
+  display->rif = &x_redisplay_interface;
+  display->scroll_region_ok = 1; /* We'll scroll partial frames. */
+  display->char_ins_del_ok = 1;
+  display->line_ins_del_ok = 1;        /* We'll just blt 'em. */
+  display->fast_clear_end_of_line = 1; /* X does this well. */
+  display->memory_below_frame = 0; /* We don't remember what scrolls
+                                        off the bottom. */
+
+  return display;
+}

 void
 x_initialize ()
 {
-  rif = &x_redisplay_interface;
-
-  clear_frame_hook = x_clear_frame;
-  ins_del_lines_hook = x_ins_del_lines;
-  delete_glyphs_hook = x_delete_glyphs;
-  ring_bell_hook = XTring_bell;
-  reset_terminal_modes_hook = XTreset_terminal_modes;
-  set_terminal_modes_hook = XTset_terminal_modes;
-  update_begin_hook = x_update_begin;
-  update_end_hook = x_update_end;
-  set_terminal_window_hook = XTset_terminal_window;
-  read_socket_hook = XTread_socket;
-  frame_up_to_date_hook = XTframe_up_to_date;
-  mouse_position_hook = XTmouse_position;
-  frame_rehighlight_hook = XTframe_rehighlight;
-  frame_raise_lower_hook = XTframe_raise_lower;
-  set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
-  condemn_scroll_bars_hook = XTcondemn_scroll_bars;
-  redeem_scroll_bar_hook = XTredeem_scroll_bar;
-  judge_scroll_bars_hook = XTjudge_scroll_bars;
-
-  scroll_region_ok = 1;		/* we'll scroll partial frames */
-  char_ins_del_ok = 1;
-  line_ins_del_ok = 1;		/* we'll just blt 'em */
-  fast_clear_end_of_line = 1;	/* X does this well */
-  memory_below_frame = 0;	/* we don't remember what scrolls
-				   off the bottom */
   baud_rate = 19200;

   x_noop_count = 0;
@@ -10850,9 +10907,11 @@
   XSetIOErrorHandler (x_io_error_quitter);

   /* Disable Window Change signals;  they are handled by X events.  */
+#if 0              /* Don't.  We may want to open tty frames later. */
 #ifdef SIGWINCH
   signal (SIGWINCH, SIG_DFL);
 #endif /* SIGWINCH */
+#endif

   signal (SIGPIPE, x_connection_signal);
 }
--- a/src/xterm.h	Mon Oct 25 02:03:47 2004 +0000
+++ b/src/xterm.h	Mon Oct 25 18:17:28 2004 +0000
@@ -389,6 +389,9 @@
       X_WMTYPE_A,
       X_WMTYPE_B
     } wm_type;
+
+  /* The generic display parameters corresponding to this X display. */
+  struct display *frame_display;
 };

 #ifdef HAVE_X_I18N