29 files changed, 946 insertions, 937 deletions
diff --git a/README.multi-tty b/README.multi-tty
index 346d27102bf..f1a0cde7df4 100644
--- a/README.multi-tty
+++ b/README.multi-tty
@@ -9,7 +9,7 @@ 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.
+support opening a new Emacs frame on the current virtual tty.
 Now, with multi-tty support, it can do that.  (Emacsclient starts up
 faster than vi!)
@@ -86,7 +86,7 @@ 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.
+frames.  It has been changed to open new Emacs frames by default.
 The multi-tty branch has been scheduled for inclusion in the next
 major release of Emacs (version 23).  I expect the merge into the
@@ -250,9 +250,8 @@ 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 (make-frame-command)
-works, and they behave the same way as in previous Emacs versions.  If
+works, and behaves the same way as in previous Emacs versions.  If you
-you exit emacs, all terminals should be restored to their previous
+exit emacs, all terminals should be restored to their previous states.
-states.
 This is work in progress, and probably full of bugs.  It is a good
 idea to run emacs from gdb, so that you'll have a live instance to
@@ -350,49 +349,50 @@ NEWS
 For the NEWS file:  (Needs much, much work)
-** Support for multiple terminal devices has been added.
+** Support for multiple terminal devices and simultaneous graphical
+   and tty frames has been added.  You can test for the presence of
+   this feature in your Lisp code by testing for the `multi-tty'
+   feature.
+*** The `window-system' variable has been made frame-local. The new
+    `initial-window-system' variable contains the `window-system'
+    value for the first frame.
 *** 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
+*** The new function `make-frame-on-tty' allows you to create a new
-    testing for the `multi-tty' feature.
+    frame on another tty device interactively.
+*** The function `make-frame-on-display' now works during a tty
+    session, and `make-frame-on-tty' works during a graphical session.
 *** 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
+*** C-z now invokes `suspend-frame', C-x C-c now invokes
-    create frames on new terminals.
+    `save-buffers-kill-terminal'.
 *** New functions: frame-tty-name, frame-tty-type, delete-tty,
-    terminal-local-value, set-terminal-local-value
+    suspend-tty, resume-tty, terminal-id, terminal-parameters,
+    terminal-parameter, set-terminal-parameter,
+    modify-terminal-parameters, environment, let-environment
-    terminal-id, terminal-parameters, terminal-parameter,
+*** New variables: local-key-translation-map, local-function-key-map
-    set-terminal-parameter
-*** New variables: global-key-translation-map
+*** The `keyboard-translate-table' variable and the terminal and
+    keyboard coding systems have been made terminal-local.
-*** The keymaps key-translation-map and function-key-map are now
+*** In addition to the global key-translation-map and
-    terminal-local.
+    function-key-map, Emacs has terminal-local
+    local-key-translation-map and local-function-key-map variables,
-** Support for simultaneous graphical and terminal frames has been
+    and uses them instead of the global keymaps to set up translations
-   added.
+    and function key sequences relevant to a specific terminal device.
-*** 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.
 *** talk.el has been extended for multiple tty support.
-*** C-z now invokes `suspend-frame', C-x C-c now invokes
-    `save-buffers-kill-frame'.
 * * *
 (The rest of this file consists of my development notes and as such it
@@ -518,15 +518,16 @@ THINGS TO DO
    frames-on-display-list              frames-on-terminal-list
   The following functions were introduced in the multi-tty branch, and
-   can be renamed without aliases:
+   were renamed without aliases:
-    display-controlling-tty-p           terminal-controlling-tty-p
+    delete-display                      delete-terminal
+    display-controlling-tty-p           controlling-tty-p
    display-list                        terminal-list
    display-live-p                      terminal-live-p
    display-name                        terminal-name
-    display-tty-type                    terminal-tty-type
+    display-tty-type                    tty-type
-    frame-display                       terminal-of-frame
+    frame-display                       frame-terminal
-    delete-display                      delete-terminal
+    selected-display                    selected-terminal
 ** The single-keyboard mode of MULTI_KBOARD is extremely confusing
   sometimes; Emacs does not respond to stimuli from other keyboards.
diff --git a/lisp/files.el b/lisp/files.el
index 8b8a1444ba6..12384543fe9 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -4879,7 +4879,7 @@ With prefix arg, silently save all file-visiting buffers, then kill."
           (funcall confirm-kill-emacs "Really exit Emacs? "))
       (kill-emacs)))
-(defun save-buffers-kill-display (&optional arg)
+(defun save-buffers-kill-terminal (&optional arg)
  "Offer to save each buffer, then kill the current connection.
 If the current frame has no client, kill Emacs itself.
@@ -4892,7 +4892,7 @@ only these files will be asked to be saved."
        (frame (selected-frame)))
    (if (null proc)
        (save-buffers-kill-emacs)
-      (server-save-buffers-kill-display proc arg))))
+      (server-save-buffers-kill-terminal proc arg))))
 ;; We use /: as a prefix to "quote" a file name
@@ -4991,7 +4991,7 @@ only these files will be asked to be saved."
 (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-display)
+(define-key ctl-x-map "\C-c" 'save-buffers-kill-terminal)
 (define-key ctl-x-map "\C-q" 'toggle-read-only)
 (define-key ctl-x-4-map "f" 'find-file-other-window)
diff --git a/lisp/frame.el b/lisp/frame.el
index 339100bbff5..818bd9368e1 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -651,7 +651,7 @@ You cannot specify either `width' or `height', you must use neither or both.
 (window-system . nil)  The frame should be displayed on a terminal device.
 (window-system . x)    The frame should be displayed in an X window.
- (device . ID)          The frame should use the display device identified by ID.
+ (terminal . ID)          The frame should use the terminal 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
@@ -664,11 +664,11 @@ instance if the frame appears under the mouse pointer and your
 setup is for focus to follow the pointer."
  (interactive)
  (let* ((w (cond
-             ((assq 'device parameters)
+             ((assq 'terminal parameters)
-              (let ((type (display-live-p (cdr (assq 'device parameters)))))
+              (let ((type (terminal-live-p (cdr (assq 'terminal parameters)))))
                (cond
                 ((eq type t) nil)
-                 ((eq type nil) (error "Display %s does not exist" (cdr (assq 'device parameters))))
+                 ((eq type nil) (error "Terminal %s does not exist" (cdr (assq 'terminal parameters))))
                 (t type))))
             ((assq 'window-system parameters)
              (cdr (assq 'window-system parameters)))
@@ -682,7 +682,7 @@ setup is for focus to follow the pointer."
    (setq frame (funcall frame-creation-function (append parameters (cdr (assq w window-system-default-frame-alist)))))
    (normal-erase-is-backspace-setup-frame frame)
    ;; Set up the frame-local environment, if needed.
-    (when (eq (frame-display frame) (frame-display oldframe))
+    (when (eq (frame-terminal frame) (frame-terminal oldframe))
      (let ((env (frame-parameter oldframe 'environment)))
        (if (not (framep env))
            (setq env oldframe))
@@ -718,7 +718,7 @@ If TERMINAL is omitted or nil, it defaults to the selected
 frame's terminal device."
  (let* ((terminal (terminal-id terminal))
         (func #'(lambda (frame)
-                   (eq (frame-display frame) terminal))))
+                   (eq (frame-terminal frame) terminal))))
    (filtered-frame-list func)))
 (defun framep-on-display (&optional terminal)
@@ -727,7 +727,7 @@ TERMINAL may be a terminal id, a display name or a frame.  If it
 is a frame, its type is returned.  If TERMINAL is omitted or nil,
 it defaults to the selected frame's terminal device.  All frames
 on a given display are of the same type."
-  (or (display-live-p terminal)
+  (or (terminal-live-p terminal)
      (framep terminal)
      (framep (car (frames-on-display-list terminal)))))
@@ -815,7 +815,7 @@ Calls `suspend-emacs' if invoked from the controlling tty device,
    (cond
     ((eq type 'x) (iconify-or-deiconify-frame))
     ((eq type t)
-      (if (display-controlling-tty-p)
+      (if (controlling-tty-p)
          (suspend-emacs)
        (suspend-tty)))
     (t (suspend-emacs)))))
@@ -1068,9 +1068,9 @@ bars (top, bottom, or nil)."
    (cons vert hor)))
 ;;;; Frame/display capabilities.
-(defun selected-display ()
+(defun selected-terminal ()
-  "Return the display that is now selected."
+  "Return the terminal that is now selected."
-  (frame-display (selected-frame)))
+  (frame-terminal (selected-frame)))
 (defun display-mouse-p (&optional display)
  "Return non-nil if DISPLAY has a mouse available.
diff --git a/lisp/server.el b/lisp/server.el
index f98be109c92..9de88d55896 100644
--- a/lisp/server.el
+++ b/lisp/server.el
@@ -247,7 +247,7 @@ ENV should be in the same format as `process-environment'."
           (setenv (car ,pair) (cdr ,pair)))))))
 (defun server-delete-client (client &optional noframe)
-  "Delete CLIENT, including its buffers, devices and frames.
+  "Delete CLIENT, including its buffers, terminals 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).
@@ -271,9 +271,9 @@ If NOFRAME is non-nil, let the frames live.  (To be used from
              (kill-buffer (current-buffer))))))
      ;; Delete the client's tty.
-      (let ((device (server-client-get client 'device)))
+      (let ((terminal (server-client-get client 'terminal)))
-        (when (eq (display-live-p device) t)
+        (when (eq (terminal-live-p terminal) t)
-          (delete-display device)))
+          (delete-terminal terminal)))
      ;; Delete the client's frames.
      (unless noframe
@@ -323,18 +323,18 @@ message."
                   ;; there are other frames on it.
                   (< 0 (let ((frame-num 0))
                          (mapc (lambda (f)
-                                  (when (eq (frame-display f)
+                                  (when (eq (frame-terminal f)
-                                            (frame-display frame))
+                                            (frame-terminal 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 (device)
+(defun server-handle-suspend-tty (terminal)
  "Notify the emacsclient process to suspend itself when its tty device is suspended."
-  (dolist (proc (server-clients-with 'device device))
+  (dolist (proc (server-clients-with 'terminal terminal))
-    (server-log (format "server-handle-suspend-tty, device %s" device) proc)
+    (server-log (format "server-handle-suspend-tty, terminal %s" terminal) proc)
    (condition-case err
        (server-send-string proc "-suspend \n")
      (file-error (condition-case nil (server-delete-client proc) (error nil))))))
@@ -618,7 +618,7 @@ The following commands are accepted by the client:
                                          ;; Flag frame as client-created, but use a dummy client.
                                          ;; This will prevent the frame from being deleted when
                                          ;; emacsclient quits while also preventing
-                                          ;; `server-save-buffers-kill-display' from unexpectedly
+                                          ;; `server-save-buffers-kill-terminal' from unexpectedly
                                          ;; killing emacs on that frame.
                                          (list (cons 'client 'nowait) (cons 'environment env))
                                        (list (cons 'client proc) (cons 'environment env)))))
@@ -636,7 +636,7 @@ The following commands are accepted by the client:
                          (modify-frame-parameters frame params)
                          (select-frame frame)
                          (server-client-set client 'frame frame)
-                          (server-client-set client 'device (frame-display frame))
+                          (server-client-set client 'terminal (frame-terminal frame))
                          (setq dontkill t))
                      ;; This emacs does not support X.
                      (server-log "Window system unsupported" proc)
@@ -645,19 +645,19 @@ The following commands are accepted by the client:
                 ;; -resume:  Resume a suspended tty frame.
                 ((equal "-resume" arg)
-                  (let ((device (server-client-get client 'device)))
+                  (let ((terminal (server-client-get client 'terminal)))
                    (setq dontkill t)
-                    (when (eq (display-live-p device) t)
+                    (when (eq (terminal-live-p terminal) t)
-                      (resume-tty device))))
+                      (resume-tty terminal))))
                 ;; -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 ((device (server-client-get client 'device)))
+                  (let ((terminal (server-client-get client 'terminal)))
                    (setq dontkill t)
-                    (when (eq (display-live-p device) t)
+                    (when (eq (terminal-live-p terminal) t)
-                      (suspend-tty device))))
+                      (suspend-tty terminal))))
                 ;; -ignore COMMENT:  Noop; useful for debugging emacsclient.
                 ;; (The given comment appears in the server log.)
@@ -687,8 +687,8 @@ The following commands are accepted by the client:
                                                         (environment . ,env)))))
                      (select-frame frame)
                      (server-client-set client 'frame frame)
-                      (server-client-set client 'tty (display-name frame))
+                      (server-client-set client 'tty (terminal-name frame))
-                      (server-client-set client 'device (frame-display frame))
+                      (server-client-set client 'terminal (frame-terminal frame))
                      ;; Reply with our pid.
                      (server-send-string proc (concat "-emacs-pid " (number-to-string (emacs-pid)) "\n"))
@@ -1037,8 +1037,8 @@ done that."
               (get-window-with-predicate
                (lambda (w)
                  (and (not (window-dedicated-p w))
-                       (equal (frame-parameter (window-frame w) 'device)
+                       (equal (frame-terminal (window-frame w))
-                              (frame-parameter (selected-frame) 'device))))
+                              (frame-terminal (selected-frame)))))
                'nomini 'visible (selected-window))))
            (condition-case nil
                (switch-to-buffer next-buffer)
@@ -1047,7 +1047,7 @@ done that."
              (error (pop-to-buffer next-buffer)))))))))
 ;;;###autoload
-(defun server-save-buffers-kill-display (proc &optional arg)
+(defun server-save-buffers-kill-terminal (proc &optional arg)
  "Offer to save each buffer, then kill PROC.
 With prefix arg, silently save all file-visiting buffers, then kill.
diff --git a/lisp/startup.el b/lisp/startup.el
index 155ef1d3e79..cef38411dc9 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -1430,7 +1430,7 @@ Copyright (C) 2005 Free Software Foundation, Inc."))
              ;; use precomputed string to save lots of time.
              (if (and (eq (key-binding "\C-h") 'help-command)
                       (eq (key-binding "\C-xu") 'advertised-undo)
-                       (eq (key-binding "\C-x\C-c") 'save-buffers-kill-display)
+                       (eq (key-binding "\C-x\C-c") 'save-buffers-kill-terminal)
                       (eq (key-binding "\C-ht") 'help-with-tutorial)
                       (eq (key-binding "\C-hi") 'info)
                       (eq (key-binding "\C-hr") 'info-emacs-manual)
@@ -1447,7 +1447,7 @@ Browse manuals     C-h i")
 Get help           %s
 Emacs manual       \\[info-emacs-manual]
 Emacs tutorial     \\[help-with-tutorial]\tUndo changes\t\\[advertised-undo]
-Buy manuals        \\[view-order-manuals]\tExit Emacs\t\\[save-buffers-kill-display]
+Buy manuals        \\[view-order-manuals]\tExit Emacs\t\\[save-buffers-kill-terminal]
 Browse manuals     \\[info]"
                                 (let ((where (where-is-internal
                                               'help-command nil t)))
diff --git a/lisp/talk.el b/lisp/talk.el
index a008a0ef3fd..0807e655703 100644
--- a/lisp/talk.el
+++ b/lisp/talk.el
@@ -50,22 +50,22 @@ Each element has the form (DISPLAY FRAME BUFFER).")
  "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))))
+        (display (frame-terminal (selected-frame))))
    (cond
     ((eq type t)
      (talk-add-display (selected-frame)))
     ((eq type 'x)
-      (talk-add-display (frame-display (selected-frame))))
+      (talk-add-display (frame-terminal (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-terminal frame)
                    frame))
         (elt (assoc display talk-display-alist))
-         (name (concat "*talk-" (display-name display) "*"))
+         (name (concat "*talk-" (terminal-name display) "*"))
         buffer)
    (unless (frame-live-p frame)
      (setq frame (make-frame-on-display display (list (cons 'name name)))))
diff --git a/lisp/termdev.el b/lisp/termdev.el
index 5e12740e11c..c73fe017046 100644
--- a/lisp/termdev.el
+++ b/lisp/termdev.el
@@ -34,17 +34,17 @@ TERMINAL may be the name of an X display
 device (HOST.SERVER.SCREEN) or a tty device file."
  (cond
   ((integerp terminal)
-    (if (display-live-p terminal)
+    (if (terminal-live-p terminal)
        terminal
-      (signal 'wrong-type-argument (list 'display-live-p terminal))))
+      (signal 'wrong-type-argument (list 'terminal-live-p terminal))))
   ((or (null terminal) (framep terminal))
-    (frame-display terminal))
+    (frame-terminal terminal))
   ((stringp terminal)
    (let ((f (car (filtered-frame-list (lambda (frame)
                                         (or (equal (frame-parameter frame 'display) terminal)
                                             (equal (frame-parameter frame 'tty) terminal)))))))
      (or f (error "Display %s does not exist" terminal))
-      (frame-display f)))
+      (frame-terminal f)))
   (t
    (error "Invalid argument %s in `terminal-id'" terminal))))
diff --git a/lisp/xt-mouse.el b/lisp/xt-mouse.el
index 1268994ba89..075ea879270 100644
--- a/lisp/xt-mouse.el
+++ b/lisp/xt-mouse.el
@@ -197,18 +197,18 @@ down the SHIFT key while pressing the mouse button."
 (defun turn-on-xterm-mouse-tracking-on-terminal (terminal)
  "Enable xterm mouse tracking on TERMINAL."
-  (when (and xterm-mouse-mode (eq t (display-live-p terminal)))
+  (when (and xterm-mouse-mode (eq t (terminal-live-p terminal)))
    (send-string-to-terminal "\e[?1000h" terminal)))
 (defun turn-off-xterm-mouse-tracking-on-terminal (terminal)
  "Disable xterm mouse tracking on TERMINAL."
-  (when (and xterm-mouse-mode (eq t (display-live-p terminal)))
+  (when (and xterm-mouse-mode (eq t (terminal-live-p terminal)))
    (send-string-to-terminal "\e[?1000l" terminal)))
 (defun xterm-mouse-handle-delete-frame (frame)
  "Turn off xterm mouse tracking if FRAME is the last frame on its device."
  (when (and (eq t (frame-live-p frame))
-             (<= 1 (length (frames-on-display-list (frame-display frame)))))
+             (<= 1 (length (frames-on-display-list (frame-terminal frame)))))
    (turn-off-xterm-mouse-tracking-on-terminal frame)))
 ;; Frame creation and deletion.
diff --git a/src/alloc.c b/src/alloc.c
index f8ba5f480ab..cf86c80deaf 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -324,7 +324,7 @@ Lisp_Object Vgc_elapsed;	/* accumulated elapsed time in GC  */
 EMACS_INT gcs_done;             /* accumulated GCs  */
 static void mark_buffer P_ ((Lisp_Object));
-extern void mark_devices P_ ((void));
+extern void mark_terminals P_ ((void));
 extern void mark_kboards P_ ((void));
 extern void mark_ttys P_ ((void));
 extern void mark_backtrace P_ ((void));
@@ -4938,7 +4938,7 @@ returns nil, because real GC can't be done.  */)
      mark_object (bind->symbol);
      mark_object (bind->old_value);
    }
-  mark_devices ();
+  mark_terminals ();
  mark_kboards ();
  mark_ttys ();
diff --git a/src/coding.c b/src/coding.c
index 759a97567c1..14f8fd33285 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -7351,11 +7351,11 @@ Return the corresponding character code in Big5.  */)
 DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_internal,
       Sset_terminal_coding_system_internal, 1, 2, 0,
       doc: /* Internal use only.  */)
-     (coding_system, device)
+     (coding_system, terminal)
     Lisp_Object coding_system;
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct coding_system *terminal_coding = DEVICE_TERMINAL_CODING (get_device (device, 1));
+  struct coding_system *terminal_coding = TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1));
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system), terminal_coding);
  /* We had better not send unsafe characters to terminal.  */
@@ -7389,41 +7389,41 @@ DEFUN ("set-safe-terminal-coding-system-internal", Fset_safe_terminal_coding_sys
 DEFUN ("terminal-coding-system", Fterminal_coding_system,
       Sterminal_coding_system, 0, 1, 0,
-       doc: /* Return coding system specified for terminal output on the given device.
+       doc: /* Return coding system specified for terminal output on the given terminal.
-DEVICE may be a display device id, a frame, or nil for the selected
+TERMINAL may be a terminal id, a frame, or nil for the selected
-frame's display device.  */)
+frame's terminal device.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  return DEVICE_TERMINAL_CODING (get_device (device, 1))->symbol;
+  return TERMINAL_TERMINAL_CODING (get_terminal (terminal, 1))->symbol;
 }
 DEFUN ("set-keyboard-coding-system-internal", Fset_keyboard_coding_system_internal,
       Sset_keyboard_coding_system_internal, 1, 2, 0,
       doc: /* Internal use only.  */)
-     (coding_system, device)
+     (coding_system, terminal)
     Lisp_Object coding_system;
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  CHECK_SYMBOL (coding_system);
  setup_coding_system (Fcheck_coding_system (coding_system),
-                       DEVICE_KEYBOARD_CODING (d));
+                       TERMINAL_KEYBOARD_CODING (t));
  /* Character composition should be disabled.  */
-  DEVICE_KEYBOARD_CODING (d)->composing = COMPOSITION_DISABLED;
+  TERMINAL_KEYBOARD_CODING (t)->composing = COMPOSITION_DISABLED;
  return Qnil;
 }
 DEFUN ("keyboard-coding-system", Fkeyboard_coding_system,
       Skeyboard_coding_system, 0, 1, 0,
-       doc: /* Return coding system for decoding keyboard input on DEVICE.
+       doc: /* Return coding system for decoding keyboard input on TERMINAL.
-DEVICE may be a display device id, a frame, or nil for the selected
+TERMINAL may be a terminal id, a frame, or nil for the selected
-frame's display device.  */)
+frame's terminal device.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  return DEVICE_KEYBOARD_CODING (get_device (device, 1))->symbol;
+  return TERMINAL_KEYBOARD_CODING (get_terminal (terminal, 1))->symbol;
 }
diff --git a/src/data.c b/src/data.c
index bd08368c2fb..0b2036395da 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1900,41 +1900,41 @@ If the current binding is global (the default), the value is nil.  */)
 /* This code is disabled now that we use the selected frame to return
   keyboard-local-values. */
 #if 0
-extern struct device *get_device P_ ((Lisp_Object display, int));
+extern struct terminal *get_terminal P_ ((Lisp_Object display, int));
 DEFUN ("terminal-local-value", Fterminal_local_value, Sterminal_local_value, 2, 2, 0,
-       doc: /* Return the terminal-local value of SYMBOL on DEVICE.
+       doc: /* Return the terminal-local value of SYMBOL on TERMINAL.
 If SYMBOL is not a terminal-local variable, then return its normal
 value, like `symbol-value'.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL may be a terminal id, a frame, or nil (meaning the
-selected frame's display device).  */)
+selected frame's terminal device).  */)
-  (symbol, device)
+  (symbol, terminal)
     Lisp_Object symbol;
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
  Lisp_Object result;
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  push_kboard (d->kboard);
+  push_kboard (t->kboard);
  result = Fsymbol_value (symbol);
  pop_kboard ();
  return result;
 }
 DEFUN ("set-terminal-local-value", Fset_terminal_local_value, Sset_terminal_local_value, 3, 3, 0,
-       doc: /* Set the terminal-local binding of SYMBOL on DEVICE to VALUE.
+       doc: /* Set the terminal-local binding of SYMBOL on TERMINAL to VALUE.
 If VARIABLE is not a terminal-local variable, then set its normal
 binding, like `set'.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL may be a terminal id, a frame, or nil (meaning the
-selected frame's display device).  */)
+selected frame's terminal device).  */)
-  (symbol, device, value)
+  (symbol, terminal, value)
     Lisp_Object symbol;
-     Lisp_Object device;
+     Lisp_Object terminal;
     Lisp_Object value;
 {
  Lisp_Object result;
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  push_kboard (d->kboard);
  result = Fset (symbol, value);
  pop_kboard ();
diff --git a/src/dispextern.h b/src/dispextern.h
index 2ae833d46c2..b5a6b21d539 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1350,7 +1350,7 @@ struct glyph_string
        DESCENT = FONT->descent
        HEIGHT = FONT_HEIGHT (FONT)
        F_DESCENT = (FRAME_FONT (F)->descent
-                     - F->device->output_data.x->baseline_offset)
+                     - F->terminal->output_data.x->baseline_offset)
        F_HEIGHT = FRAME_LINE_HEIGHT (F)
 */
@@ -2927,11 +2927,8 @@ extern void update_begin P_ ((struct frame *));
 extern void update_end P_ ((struct frame *));
 extern void set_terminal_window P_ ((struct frame *, int));
 extern void cursor_to P_ ((struct frame *, int, int));
-/* Was not declared before: */
 extern void raw_cursor_to P_ ((struct frame *, int, int));
 extern void clear_to_end P_ ((struct frame *));
 extern void clear_frame P_ ((struct frame *));
 extern void clear_end_of_line P_ ((struct frame *, int));
 extern void write_glyphs P_ ((struct frame *, struct glyph *, int));
@@ -2939,13 +2936,13 @@ extern void insert_glyphs P_ ((struct frame *, struct glyph *, int));
 extern void delete_glyphs P_ ((struct frame *, int));
 extern void ins_del_lines P_ ((struct frame *, int, int));
-extern struct device *init_initial_device P_ ((void));
+extern struct terminal *init_initial_terminal P_ ((void));
 /* Defined in term.c */
-extern void tty_set_terminal_modes P_ ((struct device *));
+extern void tty_set_terminal_modes P_ ((struct terminal *));
-extern void tty_reset_terminal_modes P_ ((struct device *));
+extern void tty_reset_terminal_modes P_ ((struct terminal *));
 extern void tty_turn_off_insert P_ ((struct tty_display_info *));
 extern void tty_turn_off_highlight P_ ((struct tty_display_info *));
 extern int string_cost P_ ((char *));
@@ -2955,11 +2952,11 @@ extern void produce_glyphs P_ ((struct it *));
 extern void produce_special_glyphs P_ ((struct it *, enum display_element_type));
 extern int tty_capable_p P_ ((struct tty_display_info *, unsigned, unsigned long, unsigned long));
 extern void set_tty_color_mode P_ ((struct frame *, Lisp_Object));
-extern struct device *get_tty_device P_ ((Lisp_Object terminal));
+extern struct terminal *get_tty_terminal P_ ((Lisp_Object terminal));
-extern struct device *get_named_tty P_ ((char *));
+extern struct terminal *get_named_tty P_ ((char *));
-EXFUN (Fdisplay_tty_type, 1);
+EXFUN (Ftty_type, 1);
 extern void create_tty_output P_ ((struct frame *));
-extern struct device *init_tty P_ ((char *, char *, int));
+extern struct terminal *init_tty P_ ((char *, char *, int));
 /* Defined in scroll.c */
diff --git a/src/dispnew.c b/src/dispnew.c
index c97e9ea9212..2f3deac5fcc 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -3345,7 +3345,7 @@ DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
  update_begin (f);
 #ifdef MSDOS
  if (FRAME_MSDOS_P (f))
-    set_terminal_modes (FRAME_DEVICE (f));
+    set_terminal_modes (FRAME_TERMINAL (f));
 #endif
  clear_frame (f);
  clear_current_matrices (f);
@@ -6304,23 +6304,23 @@ DEFUN ("send-string-to-terminal", Fsend_string_to_terminal,
       doc: /* Send STRING to the terminal without alteration.
 Control characters in STRING will have terminal-dependent effects.
-Optional parameter TERMINAL specifies the tty display device to use.
+Optional parameter TERMINAL specifies the tty terminal device to use.
 It may be a terminal id, a frame, or nil for the terminal used by the
 currently selected frame.  */)
-  (string, display)
+  (string, terminal)
     Lisp_Object string;
-     Lisp_Object display;
+     Lisp_Object terminal;
 {
-  struct device *d = get_tty_device (display);
+  struct terminal *t = get_tty_terminal (terminal);
  struct tty_display_info *tty;
  /* ??? Perhaps we should do something special for multibyte strings here.  */
  CHECK_STRING (string);
-  if (!d)
+  if (!t)
-    error ("Unknown display device");
+    error ("Unknown terminal device");
-  tty = d->display_info.tty;
+  tty = t->display_info.tty;
  
  if (tty->termscript)
    {
@@ -6783,34 +6783,34 @@ For types not defined in VMS, use  define emacs_term \"TYPE\".\n\
 #endif /* VMS */
  {
-    struct device *d;
+    struct terminal *t;
    struct frame *f = XFRAME (selected_frame);
    /* Open a display on the controlling tty. */
-    d = init_tty (0, terminal_type, 1); /* Errors are fatal. */
+    t = init_tty (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->output_method = t->type;
-    f->device = d;
+    f->terminal = t;
-    d->reference_count++;
+    t->reference_count++;
-    d->display_info.tty->top_frame = selected_frame;
+    t->display_info.tty->top_frame = selected_frame;
    change_frame_size (XFRAME (selected_frame),
-                       FrameRows (d->display_info.tty),
+                       FrameRows (t->display_info.tty),
-                       FrameCols (d->display_info.tty), 0, 0, 1);
+                       FrameCols (t->display_info.tty), 0, 0, 1);
-    /* Delete the initial display. */
+    /* Delete the initial terminal. */
-    if (--initial_device->reference_count == 0
+    if (--initial_terminal->reference_count == 0
-        && initial_device->delete_device_hook)
+        && initial_terminal->delete_terminal_hook)
-      (*initial_device->delete_device_hook) (initial_device);
+      (*initial_terminal->delete_terminal_hook) (initial_terminal);
    /* Update frame parameters to reflect the new type. */
    Fmodify_frame_parameters (selected_frame, Fcons (Fcons (Qwindow_system, Qnil), Qnil));
    Fmodify_frame_parameters
      (selected_frame, Fcons (Fcons (Qtty_type,
-                                     Fdisplay_tty_type (selected_frame)), Qnil));
+                                     Ftty_type (selected_frame)), Qnil));
    Fmodify_frame_parameters (selected_frame, Fcons (Fcons (Qtty, Qnil), Qnil));
  }
  
diff --git a/src/frame.c b/src/frame.c
index f0657975402..bc358c702b3 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -76,8 +76,8 @@ Lisp_Object Qinhibit_default_face_x_resources;
 Lisp_Object Qx_frame_parameter;
 Lisp_Object Qx_resource_name;
-Lisp_Object Qdevice;
+Lisp_Object Qterminal;
-Lisp_Object Qdisplay_live_p;
+Lisp_Object Qterminal_live_p;
 /* Frame parameters (set or reported).  */
@@ -225,7 +225,7 @@ See also `frame-live-p'.  */)
 DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
       doc: /* Return non-nil if OBJECT is a frame which has not been deleted.
 Value is nil if OBJECT is not a live frame.  If object is a live
-frame, the return value indicates what sort of output device it is
+frame, the return value indicates what sort of terminal device it is
 displayed on.  See the documentation of `framep' for possible
 return values.  */)
     (object)
@@ -424,8 +424,8 @@ make_frame_without_minibuffer (mini_window, kb, display)
 #ifdef MULTI_KBOARD
  if (!NILP (mini_window)
-      && XFRAME (XWINDOW (mini_window)->frame)->device->kboard != kb)
+      && FRAME_KBOARD (XFRAME (XWINDOW (mini_window)->frame)) != kb)
-    error ("Frame and minibuffer must be on the same display");
+    error ("Frame and minibuffer must be on the same terminal");
 #endif
  /* Make a frame containing just a root window.  */
@@ -503,13 +503,13 @@ make_minibuffer_frame ()
 /* Construct a frame that refers to a terminal.  */
-static int terminal_frame_count;
+static int tty_frame_count;
 struct frame *
 make_initial_frame (void)
 {
  struct frame *f;
-  struct device *device;
+  struct terminal *terminal;
  Lisp_Object frame;
 #ifdef MULTI_KBOARD
@@ -527,22 +527,22 @@ make_initial_frame (void)
  if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
    Vframe_list = Qnil;
-  device = init_initial_device ();
+  terminal = init_initial_terminal ();
  f = make_frame (1);
  XSETFRAME (frame, f);
  Vframe_list = Fcons (frame, Vframe_list);
-  terminal_frame_count = 1;
+  tty_frame_count = 1;
  f->name = build_string ("F1");
  f->visible = 1;
  f->async_visible = 1;
-  f->output_method = device->type;
+  f->output_method = terminal->type;
-  f->device = device;
+  f->terminal = terminal;
-  f->device->reference_count++;
+  f->terminal->reference_count++;
  f->output_data.nothing = 0;
  
  FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
@@ -556,7 +556,7 @@ make_initial_frame (void)
 struct frame *
-make_terminal_frame (struct device *device)
+make_terminal_frame (struct terminal *terminal)
 {
  register struct frame *f;
  Lisp_Object frame;
@@ -567,8 +567,8 @@ make_terminal_frame (struct device *device)
  XSETFRAME (frame, f);
  Vframe_list = Fcons (frame, Vframe_list);
-  terminal_frame_count++;
+  tty_frame_count++;
-  sprintf (name, "F%d", terminal_frame_count);
+  sprintf (name, "F%d", tty_frame_count);
  f->name = build_string (name);
  f->visible = 1;               /* FRAME_SET_VISIBLE wd set frame_garbaged. */
@@ -607,8 +607,8 @@ make_terminal_frame (struct device *device)
 #else
  {
    f->output_method = output_termcap;
-    f->device = device;
+    f->terminal = terminal;
-    f->device->reference_count++;
+    f->terminal->reference_count++;
    create_tty_output (f);
    
    FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
@@ -687,7 +687,7 @@ affects all frames on the same terminal device.  */)
     Lisp_Object parms;
 {
  struct frame *f;
-  struct device *d = NULL;
+  struct terminal *t = NULL;
  Lisp_Object frame, tem;
  struct frame *sf = SELECTED_FRAME ();
@@ -709,18 +709,17 @@ affects all frames on the same terminal device.  */)
 #endif /* not MSDOS */
  
  {
-    Lisp_Object display_device;
+    Lisp_Object terminal;
-    display_device = Fassq (Qdevice, parms);
+    terminal = Fassq (Qterminal, parms);
-    if (!NILP (display_device))
+    if (!NILP (terminal))
      {
-        display_device = XCDR (display_device);
+        terminal = XCDR (terminal);
-        CHECK_NUMBER (display_device);
+        t = get_terminal (terminal, 1);
-        d = get_device (XINT (display_device), 1);
      }
  }
  
-  if (!d)
+  if (!t)
    { 
      char *name = 0, *type = 0;
      Lisp_Object tty, tty_type;
@@ -747,10 +746,10 @@ affects all frames on the same terminal device.  */)
          type[SBYTES (tty_type)] = 0;
        }
-      d = init_tty (name, type, 0); /* Errors are not fatal. */
+      t = init_tty (name, type, 0); /* Errors are not fatal. */
    }
-  f = make_terminal_frame (d);
+  f = make_terminal_frame (t);
  {
    int width, height;
@@ -765,10 +764,10 @@ affects all frames on the same terminal device.  */)
  Fmodify_frame_parameters (frame, parms);
  Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qnil), Qnil));
  Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty_type,
-                                                 build_string (d->display_info.tty->type)),
+                                                 build_string (t->display_info.tty->type)),
                                          Qnil));
  Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty,
-                                                 build_string (d->display_info.tty->name)),
+                                                 build_string (t->display_info.tty->name)),
                                          Qnil));
  
  /* Make the frame face alist be frame-specific, so that each
@@ -793,7 +792,7 @@ affects all frames on the same terminal device.  */)
   frame's focus to FRAME instead.
   FOR_DELETION non-zero means that the selected frame is being
-   deleted, which includes the possibility that the frame's display
+   deleted, which includes the possibility that the frame's terminal
   is dead.  */
 Lisp_Object
@@ -1060,30 +1059,6 @@ If FRAME is the selected frame, this makes WINDOW the selected window.  */)
  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 device *d;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  d = get_device (frame, 0);
-  if (!d)
-    return Qnil;
-  else
-    return make_number (d->id);
-}
 DEFUN ("frame-list", Fframe_list, Sframe_list,
@@ -1532,32 +1507,33 @@ The functions are run with one arg, the frame to be deleted.  */)
    xfree (FRAME_MESSAGE_BUF (f));
  /* Since some events are handled at the interrupt level, we may get
-     an event for f at any time; if we zero out the frame's display
+     an event for f at any time; if we zero out the frame's terminal
     now, then we may trip up the event-handling code.  Instead, we'll
-     promise that the display of the frame must be valid until we have
+     promise that the terminal of the frame must be valid until we
-     called the window-system-dependent frame destruction routine.  */
+     have called the window-system-dependent frame destruction
+     routine.  */
-  if (FRAME_DEVICE (f)->delete_frame_hook)
+  if (FRAME_TERMINAL (f)->delete_frame_hook)
-    (*FRAME_DEVICE (f)->delete_frame_hook) (f);
+    (*FRAME_TERMINAL (f)->delete_frame_hook) (f);
  {
-    struct device *device = FRAME_DEVICE (f);
+    struct terminal *terminal = FRAME_TERMINAL (f);
    f->output_data.nothing = 0; 
-    f->device = 0;             /* Now the frame is dead. */
+    f->terminal = 0;             /* Now the frame is dead. */
-    /* If needed, delete the device that this frame was on.
+    /* If needed, delete the terminal that this frame was on.
       (This must be done after the frame is killed.) */
-    device->reference_count--;
+    terminal->reference_count--;
-    if (device->reference_count == 0)
+    if (terminal->reference_count == 0)
      {
        kb = NULL;
-        if (device->delete_device_hook)
+        if (terminal->delete_terminal_hook)
-          (*device->delete_device_hook) (device);
+          (*terminal->delete_terminal_hook) (terminal);
        else
-          delete_device (device);
+          delete_terminal (terminal);
      }
    else
-      kb = device->kboard;
+      kb = terminal->kboard;
  }
  /* If we've deleted the last_nonminibuf_frame, then try to find
@@ -1704,11 +1680,11 @@ and returns whatever that function returns.  */)
 #ifdef HAVE_MOUSE
  /* It's okay for the hook to refrain from storing anything.  */
-  if (FRAME_DEVICE (f)->mouse_position_hook)
+  if (FRAME_TERMINAL (f)->mouse_position_hook)
-    (*FRAME_DEVICE (f)->mouse_position_hook) (&f, -1,
+    (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
-                                              &lispy_dummy, &party_dummy,
+                                                &lispy_dummy, &party_dummy,
-                                              &x, &y,
+                                                &x, &y,
-                                              &long_dummy);
+                                                &long_dummy);
  if (! NILP (x))
    {
      col = XINT (x);
@@ -1747,11 +1723,11 @@ and nil for X and Y.  */)
 #ifdef HAVE_MOUSE
  /* It's okay for the hook to refrain from storing anything.  */
-  if (FRAME_DEVICE (f)->mouse_position_hook)
+  if (FRAME_TERMINAL (f)->mouse_position_hook)
-    (*FRAME_DEVICE (f)->mouse_position_hook) (&f, -1,
+    (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
-                                              &lispy_dummy, &party_dummy,
+                                                &lispy_dummy, &party_dummy,
-                                              &x, &y,
+                                                &x, &y,
-                                              &long_dummy);
+                                                &long_dummy);
 #endif
  XSETFRAME (lispy_dummy, f);
  return Fcons (lispy_dummy, Fcons (x, y));
@@ -2028,8 +2004,8 @@ doesn't support multiple overlapping frames, this function does nothing.  */)
  /* Do like the documentation says. */
  Fmake_frame_visible (frame);
-  if (FRAME_DEVICE (f)->frame_raise_lower_hook)
+  if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
-    (*FRAME_DEVICE (f)->frame_raise_lower_hook) (f, 1);
+    (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 1);
  return Qnil;
 }
@@ -2052,8 +2028,8 @@ doesn't support multiple overlapping frames, this function does nothing.  */)
  f = XFRAME (frame);
  
-  if (FRAME_DEVICE (f)->frame_raise_lower_hook)
+  if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
-    (*FRAME_DEVICE (f)->frame_raise_lower_hook) (f, 0);
+    (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
  return Qnil;
 }
@@ -2101,8 +2077,8 @@ The redirection lasts until `redirect-frame-focus' is called to change it.  */)
  
  f->focus_frame = focus_frame;
-  if (FRAME_DEVICE (f)->frame_rehighlight_hook)
+  if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
-    (*FRAME_DEVICE (f)->frame_rehighlight_hook) (f);
+    (*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
  return Qnil;
 }
@@ -2236,8 +2212,8 @@ set_term_frame_name (f, name)
                            SBYTES (f->name)))
        return;
-      terminal_frame_count++;
+      tty_frame_count++;
-      sprintf (namebuf, "F%d", terminal_frame_count);
+      sprintf (namebuf, "F%d", tty_frame_count);
      name = build_string (namebuf);
    }
  else
@@ -4306,10 +4282,10 @@ syms_of_frame ()
  Qx_frame_parameter = intern ("x-frame-parameter");
  staticpro (&Qx_frame_parameter);
-  Qdevice = intern ("device");
+  Qterminal = intern ("terminal");
-  staticpro (&Qdevice);
+  staticpro (&Qterminal);
-  Qdisplay_live_p = intern ("display-live-p");
+  Qterminal_live_p = intern ("terminal-live-p");
-  staticpro (&Qdisplay_live_p);
+  staticpro (&Qterminal_live_p);
  
  {
    int i;
@@ -4449,7 +4425,6 @@ This variable is local to the current terminal and cannot be buffer-local.  */);
  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);
diff --git a/src/frame.h b/src/frame.h
index 6c54c328923..cf0e50ed623 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -70,7 +70,7 @@ enum text_cursor_kinds
 #define FRAME_FOREGROUND_PIXEL(f) ((f)->foreground_pixel)
 #define FRAME_BACKGROUND_PIXEL(f) ((f)->background_pixel)
-struct device;
+struct terminal;
 struct frame
 {
@@ -267,12 +267,12 @@ struct frame
  /* 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 device->type. */
+     This must be the same as the terminal->type. */
  enum output_method output_method;
-  /* The display device that this frame uses.  If this is NULL, then
+  /* The terminal device that this frame uses.  If this is NULL, then
     the frame has been deleted. */
-  struct device *device;
+  struct terminal *terminal;
  
  /* Device-dependent, frame-local auxiliary data used for displaying
     the contents.  When the frame is deleted, this data is deleted as
@@ -458,7 +458,7 @@ struct frame
 };
 #ifdef MULTI_KBOARD
-#define FRAME_KBOARD(f) ((f)->device->kboard)
+#define FRAME_KBOARD(f) ((f)->terminal->kboard)
 #else
 #define FRAME_KBOARD(f) (&the_only_kboard)
 #endif
@@ -496,7 +496,7 @@ typedef struct frame *FRAME_PTR;
 #endif
 /* Nonzero if frame F is still alive (not deleted).  */
-#define FRAME_LIVE_P(f) ((f)->device != 0)
+#define FRAME_LIVE_P(f) ((f)->terminal != 0)
 /* Nonzero if frame F is a minibuffer-only frame.  */
 #define FRAME_MINIBUF_ONLY_P(f) \
@@ -780,13 +780,13 @@ typedef struct frame *FRAME_PTR;
 extern Lisp_Object Qframep, Qframe_live_p;
 extern Lisp_Object Qtty, Qtty_type;
-extern Lisp_Object Qdevice, Qdisplay_live_p;
+extern Lisp_Object Qterminal, Qterminal_live_p;
 extern Lisp_Object Qenvironment;
 extern struct frame *last_nonminibuf_frame;
 extern struct frame *make_initial_frame P_ ((void));
-extern struct frame *make_terminal_frame P_ ((struct device *));
+extern struct frame *make_terminal_frame P_ ((struct terminal *));
 extern struct frame *make_frame P_ ((int));
 #ifdef HAVE_WINDOW_SYSTEM
 extern struct frame *make_minibuffer_frame P_ ((void));
diff --git a/src/keyboard.c b/src/keyboard.c
index c47fda8223c..8cfa4b34371 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1130,19 +1130,19 @@ void
 push_frame_kboard (f)
     FRAME_PTR f;
 {
-  push_kboard (f->device->kboard);
+  push_kboard (f->terminal->kboard);
 }
 void
 pop_kboard ()
 {
 #ifdef MULTI_KBOARD
-  struct device *d;
+  struct terminal *t;
  struct kboard_stack *p = kboard_stack;
  current_kboard = NULL;
-  for (d = device_list; d; d = d->next_device)
+  for (t = terminal_list; t; t = t->next_terminal)
    {
-      if (d->kboard == p->kboard)
+      if (t->kboard == p->kboard)
        {
          current_kboard = p->kboard;
          break;
@@ -1150,7 +1150,7 @@ pop_kboard ()
    }
  if (current_kboard == NULL)
    {
-      /* The display we remembered has been deleted.  */
+      /* The terminal we remembered has been deleted.  */
      current_kboard = FRAME_KBOARD (SELECTED_FRAME ());
    }
  kboard_stack = p->next;
@@ -4205,15 +4205,15 @@ kbd_buffer_get_event (kbp, used_mouse_menu)
      unsigned long time;
      *kbp = current_kboard;
-      /* Note that this uses F to determine which display to look at.
+      /* Note that this uses F to determine which terminal to look at.
         If there is no valid info, it does not store anything
         so x remains nil.  */
      x = Qnil;
      /* XXX Can f or mouse_position_hook be NULL here? */
-      if (f && FRAME_DEVICE (f)->mouse_position_hook)
+      if (f && FRAME_TERMINAL (f)->mouse_position_hook)
-        (*FRAME_DEVICE (f)->mouse_position_hook) (&f, 0, &bar_window,
+        (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, 0, &bar_window,
-                                                  &part, &x, &y, &time);
+                                                    &part, &x, &y, &time);
      obj = Qnil;
@@ -6749,15 +6749,15 @@ read_avail_input (expected)
 {
  int nread = 0;
  int err = 0;
-  struct device *d;
+  struct terminal *t;
-  /* Loop through the available devices, and call their input hooks. */
+  /* Loop through the available terminals, and call their input hooks. */
-  d = device_list;
+  t = terminal_list;
-  while (d)
+  while (t)
    {
-      struct device *next = d->next_device;
+      struct terminal *next = t->next_terminal;
-      if (d->read_socket_hook)
+      if (t->read_socket_hook)
        {
          int nr;
          struct input_event hold_quit;
@@ -6766,7 +6766,7 @@ read_avail_input (expected)
          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)
+          while (nr = (*t->read_socket_hook) (t, expected, &hold_quit), nr > 0)
            {
              nread += nr;
              expected = 0;
@@ -6778,10 +6778,10 @@ read_avail_input (expected)
            }
          else if (nr == -2)          /* Non-transient error. */
            {
-              /* The display device terminated; it should be closed. */
+              /* The terminal device terminated; it should be closed. */
              
-              /* Kill Emacs if this was our last display. */
+              /* Kill Emacs if this was our last terminal. */
-              if (! device_list->next_device)
+              if (!terminal_list->next_terminal)
                /* 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
@@ -6792,18 +6792,18 @@ read_avail_input (expected)
                   alone in its group.  */
                kill (getpid (), SIGHUP);
              
-              /* XXX Is calling delete_device safe here?  It calls Fdelete_frame. */
+              /* XXX Is calling delete_terminal safe here?  It calls Fdelete_frame. */
-              if (d->delete_device_hook)
+              if (t->delete_terminal_hook)
-                (*d->delete_device_hook) (d);
+                (*t->delete_terminal_hook) (t);
              else
-                delete_device (d);
+                delete_terminal (t);
            }
          if (hold_quit.kind != NO_EVENT)
            kbd_buffer_store_event (&hold_quit);
        }
-      d = next;
+      t = next;
    }
  if (err && !nread)
@@ -6814,12 +6814,12 @@ read_avail_input (expected)
 /* This is the tty way of reading available input.
-   Note that each terminal device has its own `struct device' object,
+   Note that each terminal device has its own `struct terminal' object,
   and so this function is called once for each individual termcap
-   display.  The first parameter indicates which device to read from.  */
+   terminal.  The first parameter indicates which terminal to read from.  */
 int
-tty_read_avail_input (struct device *device,
+tty_read_avail_input (struct terminal *terminal,
                      int expected,
                      struct input_event *hold_quit)
 {
@@ -6828,10 +6828,10 @@ tty_read_avail_input (struct device *device,
     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 = device->display_info.tty;
+  struct tty_display_info *tty = terminal->display_info.tty;
  int nread = 0;
-  if (device->type != output_termcap)
+  if (terminal->type != output_termcap)
    abort ();
  /* XXX I think the following code should be moved to separate hook
@@ -6861,7 +6861,7 @@ tty_read_avail_input (struct device *device,
  if (ioctl (fileno (tty->input), FIONREAD, &n_to_read) < 0)
    {
      if (! noninteractive)
-        return -2;          /* Close this device. */
+        return -2;          /* Close this terminal. */
      else
        n_to_read = 0;
    }
@@ -6890,14 +6890,14 @@ tty_read_avail_input (struct device *device,
         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 device. */
+        return -2;          /* Close this terminal. */
 #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)
-        return -2;          /* Close this device. */
+        return -2;          /* Close this terminal. */
 #endif
    }
  while (
@@ -10440,7 +10440,7 @@ interrupt_signal (signalnum)	/* If we don't have an argument, */
 {
  /* Must preserve main program's value of errno.  */
  int old_errno = errno;
-  struct device *device;
+  struct terminal *terminal;
 #if defined (USG) && !defined (POSIX_SIGNALS)
  /* USG systems forget handlers when they are used;
@@ -10451,9 +10451,9 @@ interrupt_signal (signalnum)	/* If we don't have an argument, */
  SIGNAL_THREAD_CHECK (signalnum);
-  /* See if we have an active display on our controlling terminal. */
+  /* See if we have an active terminal on our controlling tty. */
-  device = get_named_tty (NULL);
+  terminal = get_named_tty (NULL);
-  if (!device)
+  if (!terminal)
    {
      /* If there are no frames there, let's pretend that we are a
         well-behaving UN*X program and quit. */
@@ -10467,7 +10467,7 @@ interrupt_signal (signalnum)	/* If we don't have an argument, */
         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 = device->display_info.tty->top_frame;
+      internal_last_event_frame = terminal->display_info.tty->top_frame;
      handle_interrupt ();
    }
@@ -10710,18 +10710,18 @@ DEFUN ("set-output-flow-control", Fset_output_flow_control, Sset_output_flow_con
 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
 C-q in key sequences.
-This setting only has an effect on tty display devices and only when
+This setting only has an effect on tty terminals and only when
 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
 See also `current-input-mode'.  */)
       (flow, terminal)
       Lisp_Object flow, terminal;
 {
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  struct tty_display_info *tty;
-  if (d == NULL || d->type != output_termcap)
+  if (t == NULL || t->type != output_termcap)
    return Qnil;
-  tty = d->display_info.tty;
+  tty = t->display_info.tty;
  if (tty->flow_control != !NILP (flow))
    {
@@ -10750,9 +10750,9 @@ parity.
 Otherwise, Emacs will accept and pass through 8-bit input without
 specially interpreting the top bit.
-This setting only has an effect on tty display devices.
+This setting only has an effect on tty terminal devices.
-Optional parameter TERMINAL specifies the tty display device to use.
+Optional parameter TERMINAL specifies the tty terminal device to use.
 It may be a terminal id, a frame, or nil for the terminal used by the
 currently selected frame.
@@ -10760,13 +10760,13 @@ See also `current-input-mode'.  */)
       (meta, terminal)
       Lisp_Object meta, terminal;
 {
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  struct tty_display_info *tty;
  int new_meta;
  
-  if (d == NULL || d->type != output_termcap)
+  if (t == NULL || t->type != output_termcap)
    return Qnil;
-  tty = d->display_info.tty;
+  tty = t->display_info.tty;
  if (NILP (meta))
    new_meta = 0;
@@ -10795,18 +10795,18 @@ DEFUN ("set-quit-char", Fset_quit_char, Sset_quit_char, 1, 1, 0,
       doc: /* Specify character used for quitting.
 QUIT must be an ASCII character.
-This function only has an effect on the tty display on the controlling
+This function only has an effect on the terminal on the controlling
 tty of the Emacs process.
 See also `current-input-mode'.  */)
       (quit)
       Lisp_Object quit;
 {
-  struct device *d = get_named_tty (NULL);
+  struct terminal *t = get_named_tty (NULL);
  struct tty_display_info *tty;
-  if (d == NULL || d->type != output_termcap)
+  if (t == NULL || t->type != output_termcap)
    return Qnil;
-  tty = d->display_info.tty;
+  tty = t->display_info.tty;
 #ifndef DOS_NT
  /* this causes startup screen to be restored and messes with the mouse */
@@ -11025,7 +11025,7 @@ delete_kboard (kb)
      && FRAMEP (selected_frame)
      && FRAME_LIVE_P (XFRAME (selected_frame)))
    {
-      current_kboard = XFRAME (selected_frame)->device->kboard;
+      current_kboard = XFRAME (selected_frame)->terminal->kboard;
      if (current_kboard == kb)
        abort ();
    }
@@ -11463,7 +11463,7 @@ command exit.
 The value `kill-region' is special; it means that the previous command
 was a kill command.
-`last-command' has a separate binding for each display device.
+`last-command' has a separate binding for each terminal device.
 See Info node `(elisp)Multiple displays'.  */);
  DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
@@ -11589,8 +11589,8 @@ untranslated.  In a vector, an element which is nil means "no translation".
 This is applied to the characters supplied to input methods, not their
 output.  See also `translation-table-for-input'.
-`local-keyboard-translate-table' has a separate binding for each
+This variable has a separate binding for each terminal.  See Info node
-terminal.  See Info node `(elisp)Multiple displays'.  */);
+`(elisp)Multiple displays'.  */);
  DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
               doc: /* Non-nil means to always spawn a subshell instead of suspending.
@@ -11677,7 +11677,8 @@ It also replaces `overriding-local-map'.
 This variable is intended to let commands such as `universal-argument'
 set up a different keymap for reading the next command.
-`overriding-terminal-local-map' has a separate binding for each display device.
+`overriding-terminal-local-map' has a separate binding for each
+terminal device.
 See Info node `(elisp)Multiple displays'.  */);
  DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
@@ -11705,7 +11706,7 @@ Each element should have the form (N . SYMBOL) where N is the
 numeric keysym code (sans the \"system-specific\" bit 1<<28)
 and SYMBOL is its name.
-`system-key-alist' has a separate binding for each display device.
+`system-key-alist' has a separate binding for each terminal device.
 See Info node `(elisp)Multiple displays'.  */);
  DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map,
@@ -11731,15 +11732,15 @@ Typing `ESC O P' to `read-key-sequence' would return [f1].  Typing
 `C-x ESC O P' would return [?\\C-x f1].  If [f1] were a prefix key,
 typing `ESC O P x' would return [f1 x].
-`local-function-key-map' has a separate binding for each display
+`local-function-key-map' has a separate binding for each terminal
 device.  See Info node `(elisp)Multiple displays'.  If you need to
-define a binding on all display devices, change `function-key-map'
+define a binding on all terminals, change `function-key-map'
 instead.  Initially, `local-function-key-map' is an empty keymap that
-has `function-key-map' as its parent on all display devices.  */);
+has `function-key-map' as its parent on all terminal devices.  */);
  DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
               doc: /* The parent keymap of all `local-function-key-map' instances.
-Function key definitions that apply to all display devices should go
+Function key definitions that apply to all terminal devices should go
 here.  If a mapping is defined in both the current
 `local-function-key-map' binding and this variable, then the local
 definition will take precendence.  */);
@@ -11750,13 +11751,13 @@ definition will take precendence.  */);
 This keymap works like `function-key-map', but comes after that,
 and its non-prefix bindings override ordinary bindings.
-`key-translation-map' has a separate binding for each display device.
+`key-translation-map' has a separate binding for each terminal device.
 (See Info node `(elisp)Multiple displays'.)  If you need to set a key
-translation on all devices, change `global-key-translation-map' instead.  */);
+translation on all terminals, change `global-key-translation-map' instead.  */);
  DEFVAR_LISP ("key-translation-map", &Vkey_translation_map,
               doc: /* The parent keymap of all `local-key-translation-map' instances.
-Key translations that apply to all display devices should go here.  */);
+Key translations that apply to all terminal devices should go here.  */);
  Vkey_translation_map = Fmake_sparse_keymap (Qnil);
  DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list,
diff --git a/src/keyboard.h b/src/keyboard.h
index 45dbd495d28..6c320a4fad8 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -21,8 +21,9 @@ Boston, MA 02110-1301, USA.  */
 /* Length of echobuf field in each KBOARD.  */
-/* Each KBOARD represents one logical input stream from which Emacs gets input.
+/* Each KBOARD represents one logical input stream from which Emacs
-   If we are using ordinary terminals, it has one KBOARD object for each terminal device.
+   gets input.  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.
@@ -356,7 +357,7 @@ extern void kbd_buffer_store_help_event P_ ((Lisp_Object, Lisp_Object));
 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 device *, int,
+extern int tty_read_avail_input P_ ((struct terminal *, int,
                                     struct input_event *));
 /* arch-tag: 769cbade-1ba9-4950-b886-db265b061aa3
diff --git a/src/lisp.h b/src/lisp.h
index 0aa2d7cb510..f04d29808d1 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3064,7 +3064,7 @@ EXFUN (Fcall_process, MANY);
 extern int child_setup P_ ((int, int, int, char **, int, Lisp_Object));
 extern void init_callproc_1 P_ ((void));
 extern void init_callproc P_ ((void));
-extern void set_process_environment P_ ((void));
+extern void set_global_environment P_ ((void));
 extern void syms_of_callproc P_ ((void));
 /* defined in doc.c */
@@ -3130,7 +3130,7 @@ extern void syms_of_xmenu P_ ((void));
 struct tty_display_info;
 /* defined in termhooks.h */
-struct device;
+struct terminal;
 /* defined in sysdep.c */
 #ifndef HAVE_GET_CURRENT_DIR_NAME
diff --git a/src/minibuf.c b/src/minibuf.c
index 4025226574d..795acb1988c 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -552,7 +552,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
  if (minibuffer_auto_raise)
    Fraise_frame (mini_frame);
-  temporarily_switch_to_single_kboard (XFRAME (mini_frame)->device->kboard);
+  temporarily_switch_to_single_kboard (XFRAME (mini_frame)->terminal->kboard);
  /* We have to do this after saving the window configuration
     since that is what restores the current buffer.  */
diff --git a/src/sysdep.c b/src/sysdep.c
index 7f9d189d79a..956323f3a3b 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1782,7 +1782,7 @@ nil means don't delete them until `list-processes' is run.  */);
  setbuf (tty_out->output, (char *) _sobuf);
 #endif
-  tty_set_terminal_modes (tty_out->device);
+  tty_set_terminal_modes (tty_out->terminal);
  if (!tty_out->term_initted)
    {
@@ -1994,7 +1994,7 @@ reset_sys_modes (tty_out)
  }
 #endif
-  tty_reset_terminal_modes (tty_out->device);
+  tty_reset_terminal_modes (tty_out->terminal);
 #ifdef BSD_SYSTEM
 #ifndef BSD4_1
diff --git a/src/term.c b/src/term.c
index b599e1b97fe..49356348545 100644
--- a/src/term.c
+++ b/src/term.c
@@ -87,7 +87,7 @@ static void tty_show_cursor P_ ((struct tty_display_info *));
 static void tty_hide_cursor P_ ((struct tty_display_info *));
 static void tty_background_highlight P_ ((struct tty_display_info *tty));
 static void dissociate_if_controlling_tty P_ ((int fd));
-static void delete_tty P_ ((struct device *));
+static void delete_tty P_ ((struct terminal *));
 #define OUTPUT(tty, a)                                          \
  emacs_tputs ((tty), a,                                        \
@@ -198,9 +198,9 @@ tty_ring_bell (struct frame *f)
 /* Set up termcap modes for Emacs. */
 void
-tty_set_terminal_modes (struct device *display)
+tty_set_terminal_modes (struct terminal *terminal)
 {
-  struct tty_display_info *tty = display->display_info.tty;
+  struct tty_display_info *tty = terminal->display_info.tty;
  
  if (tty->output)
    {
@@ -227,9 +227,9 @@ tty_set_terminal_modes (struct device *display)
 /* Reset termcap modes before exiting Emacs. */
 void
-tty_reset_terminal_modes (struct device *display)
+tty_reset_terminal_modes (struct terminal *terminal)
 {
-  struct tty_display_info *tty = display->display_info.tty;
+  struct tty_display_info *tty = terminal->display_info.tty;
  if (tty->output)
    {
@@ -246,7 +246,7 @@ tty_reset_terminal_modes (struct device *display)
    }
 }
-/* Flag the end of a display update on a termcap display. */
+/* Flag the end of a display update on a termcap terminal. */
 static void
 tty_update_end (struct frame *f)
@@ -1809,30 +1809,37 @@ tty_capable_p (tty, caps, fg, bg)
 DEFUN ("tty-display-color-p", Ftty_display_color_p, Stty_display_color_p,
       0, 1, 0,
-       doc: /* Return non-nil if the display device DEVICE can display colors.
+       doc: /* Return non-nil if the tty device TERMINAL can display colors.
-DEVICE must be a tty device.  */)
-     (device)
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
-     Lisp_Object device;
+frame's terminal).  This function always returns nil if TERMINAL
+is not on a tty device.  */)
+     (terminal)
+     Lisp_Object terminal;
 {
-  struct device *d = get_tty_device (device);
+  struct terminal *t = get_tty_terminal (terminal);
-  if (!d)
+  if (!t)
    return Qnil;
  else
-    return d->display_info.tty->TN_max_colors > 0 ? Qt : Qnil;
+    return t->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 the tty device DEVICE.  */)
+       doc: /* Return the number of colors supported by the tty device TERMINAL.
-     (device)
-     Lisp_Object device;
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
+frame's terminal).  This function always returns nil if TERMINAL
+is not on a tty device.  */)
+     (terminal)
+     Lisp_Object terminal;
 {
-  struct device *d = get_tty_device (device);
+  struct terminal *t = get_tty_terminal (terminal);
-  if (!d)
+  if (!t)
    return make_number (0);
  else
-    return make_number (d->display_info.tty->TN_max_colors);
+    return make_number (t->display_info.tty->TN_max_colors);
 }
 #ifndef WINDOWSNT
@@ -1974,20 +1981,20 @@ set_tty_color_mode (f, val)
-/* Return the tty display object specified by DEVICE. */
+/* Return the tty display object specified by TERMINAL. */
-struct device *
+struct terminal *
-get_tty_device (Lisp_Object terminal)
+get_tty_terminal (Lisp_Object terminal)
 {
-  struct device *d = get_device (terminal, 0);
+  struct terminal *t = get_terminal (terminal, 0);
-  if (d && d->type == output_initial)
+  if (t && t->type == output_initial)
-    d = NULL;
+    t = NULL;
-  if (d && d->type != output_termcap)
+  if (t && t->type != output_termcap)
-    error ("Device %d is not a termcap display device", d->id);
+    error ("Device %d is not a termcap terminal device", t->id);
-  return d;
+  return t;
 }
 /* Return the active termcap device that uses the tty device with the
@@ -1998,75 +2005,77 @@ get_tty_device (Lisp_Object terminal)
   Returns NULL if the named terminal device is not opened.  */
 
-struct device *
+struct terminal *
 get_named_tty (name)
     char *name;
 {
-  struct device *d;
+  struct terminal *t;
-  for (d = device_list; d; d = d->next_device) {
+  for (t = terminal_list; t; t = t->next_terminal) {
-    if (d->type == output_termcap
+    if (t->type == output_termcap
-        && ((d->display_info.tty->name == 0 && name == 0)
+        && ((t->display_info.tty->name == 0 && name == 0)
-            || (name && d->display_info.tty->name
+            || (name && t->display_info.tty->name
-                && !strcmp (d->display_info.tty->name, name)))
+                && !strcmp (t->display_info.tty->name, name)))
-        && DEVICE_ACTIVE_P (d))
+        && TERMINAL_ACTIVE_P (t))
-      return d;
+      return t;
  };
  return 0;
 }
-DEFUN ("display-tty-type", Fdisplay_tty_type, Sdisplay_tty_type, 0, 1, 0,
+DEFUN ("tty-type", Ftty_type, Stty_type, 0, 1, 0,
-       doc: /* Return the type of the tty device that DEVICE uses.
+       doc: /* Return the type of the tty device that TERMINAL uses.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
-selected frame's display device). */)
+frame's terminal).  */)
-  (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  if (d->type != output_termcap)
+  if (t->type != output_termcap)
-    error ("Display %d is not a termcap display", d->id);
+    error ("Terminal %d is not a termcap terminal", t->id);
           
-  if (d->display_info.tty->type)
+  if (t->display_info.tty->type)
-    return build_string (d->display_info.tty->type);
+    return build_string (t->display_info.tty->type);
  else
    return Qnil;
 }
-DEFUN ("display-controlling-tty-p", Fdisplay_controlling_tty_p, Sdisplay_controlling_tty_p, 0, 1, 0,
+DEFUN ("controlling-tty-p", Fcontrolling_tty_p, Scontrolling_tty_p, 0, 1, 0,
-       doc: /* Return non-nil if DEVICE is on the controlling tty of the Emacs process.
+       doc: /* Return non-nil if TERMINAL is on the controlling tty of the Emacs process.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
-selected frame's display device).  */)
+frame's terminal).  This function always returns nil if TERMINAL
-  (device)
+is not on a tty device.  */)
-     Lisp_Object device;
+     (terminal)
+     Lisp_Object terminal;
 {
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  if (d->type != output_termcap || d->display_info.tty->name)
+  if (t->type != output_termcap || t->display_info.tty->name)
    return Qnil;
  else
    return Qt;
 }
 DEFUN ("tty-no-underline", Ftty_no_underline, Stty_no_underline, 0, 1, 0,
-       doc: /* Declare that the tty used by DEVICE does not handle underlining.
+       doc: /* Declare that the tty used by TERMINAL does not handle underlining.
 This is used to override the terminfo data, for certain terminals that
 do not really do underlining, but say that they do.  This function has
-no effect if used on a non-tty display.
+no effect if used on a non-tty terminal.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
-selected frame's display device).  */)
+frame's terminal).  This function always returns nil if TERMINAL
-  (device)
+is not on a tty device.  */)
-     Lisp_Object device;
+  (terminal)
+     Lisp_Object terminal;
 {
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  if (d->type == output_termcap)
+  if (t->type == output_termcap)
-    d->display_info.tty->TS_enter_underline_mode = 0;
+    t->display_info.tty->TS_enter_underline_mode = 0;
  return Qnil;
 }
@@ -2094,36 +2103,36 @@ A suspended tty may be resumed by calling `resume-tty' on it.  */)
     (tty)
     Lisp_Object tty;
 {
-  struct device *d = get_tty_device (tty);
+  struct terminal *t = get_tty_terminal (tty);
  FILE *f;
  
-  if (!d)
+  if (!t)
    error ("Unknown tty device");
-  f = d->display_info.tty->input;
+  f = t->display_info.tty->input;
  
  if (f)
    {
-      reset_sys_modes (d->display_info.tty);
+      reset_sys_modes (t->display_info.tty);
      delete_keyboard_wait_descriptor (fileno (f));
      
      fclose (f);
-      if (f != d->display_info.tty->output)
+      if (f != t->display_info.tty->output)
-        fclose (d->display_info.tty->output);
+        fclose (t->display_info.tty->output);
      
-      d->display_info.tty->input = 0;
+      t->display_info.tty->input = 0;
-      d->display_info.tty->output = 0;
+      t->display_info.tty->output = 0;
-      if (FRAMEP (d->display_info.tty->top_frame))
+      if (FRAMEP (t->display_info.tty->top_frame))
-        FRAME_SET_VISIBLE (XFRAME (d->display_info.tty->top_frame), 0);
+        FRAME_SET_VISIBLE (XFRAME (t->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);
+          args[1] = make_number (t->id);
          Frun_hook_with_args (2, args);
        }
    }
@@ -2134,56 +2143,56 @@ A suspended tty may be resumed by calling `resume-tty' on it.  */)
 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.
+suspended terminal are revived.
-It is an error to resume a display while another display is active on
+It is an error to resume a terminal while another terminal is active
-the same device.
+on the same device.
-This function runs `resume-tty-functions' after resuming the device.
+This function runs `resume-tty-functions' after resuming the terminal.
-The functions are run with one arg, the id of the resumed display
+The functions are run with one arg, the id of the resumed terminal
 device.
 `resume-tty' does nothing if it is called on a device that is not
 suspended.
-TTY may be a display device id, a frame, or nil for the display device
+TTY may be a terminal id, a frame, or nil for the terminal device of
-of the currently selected frame. */)
+the currently selected frame. */)
     (tty)
     Lisp_Object tty;
 {
-  struct device *d = get_tty_device (tty);
+  struct terminal *t = get_tty_terminal (tty);
  int fd;
-  if (!d)
+  if (!t)
    error ("Unknown tty device");
-  if (!d->display_info.tty->input)
+  if (!t->display_info.tty->input)
    {
-      if (get_named_tty (d->display_info.tty->name))
+      if (get_named_tty (t->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);
+      fd = emacs_open (t->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+");
+      t->display_info.tty->output = fdopen (fd, "w+");
-      d->display_info.tty->input = d->display_info.tty->output;
+      t->display_info.tty->input = t->display_info.tty->output;
    
      add_keyboard_wait_descriptor (fd);
-      if (FRAMEP (d->display_info.tty->top_frame))
+      if (FRAMEP (t->display_info.tty->top_frame))
-        FRAME_SET_VISIBLE (XFRAME (d->display_info.tty->top_frame), 1);
+        FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
-      init_sys_modes (d->display_info.tty);
+      init_sys_modes (t->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);
+          args[1] = make_number (t->id);
          Frun_hook_with_args (2, args);
        }
    }
@@ -2210,7 +2219,7 @@ create_tty_output (struct frame *f)
  t = xmalloc (sizeof (struct tty_output));
  bzero (t, sizeof (struct tty_output));
-  t->display_info = FRAME_DEVICE (f)->display_info.tty;
+  t->display_info = FRAME_TERMINAL (f)->display_info.tty;
  f->output_data.tty = t;
 }
@@ -2271,7 +2280,7 @@ static void maybe_fatal();
   If MUST_SUCCEED is true, then all errors are fatal. */
-struct device *
+struct terminal *
 init_tty (char *name, char *terminal_type, int must_succeed)
 {
  char *area;
@@ -2281,72 +2290,72 @@ init_tty (char *name, char *terminal_type, int must_succeed)
  register char *p;
  int status;
  struct tty_display_info *tty;
-  struct device *device;
+  struct terminal *terminal;
  if (!terminal_type)
    maybe_fatal (must_succeed, 0, 0,
                 "Unknown terminal type",
                 "Unknown terminal type");
-  /* If we already have a display on the given device, use that.  If
+  /* If we already have a terminal on the given device, use that.  If
-     all such displays are suspended, create a new one instead.  */
+     all such terminals are suspended, create a new one instead.  */
  /* XXX Perhaps this should be made explicit by having init_tty
-     always create a new display and separating device and frame
+     always create a new terminal and separating terminal and frame
     creation on Lisp level.  */
-  device = get_named_tty (name);
+  terminal = get_named_tty (name);
-  if (device)
+  if (terminal)
-    return device;
+    return terminal;
-  device = create_device ();
+  terminal = create_terminal ();
  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;
-  device->type = output_termcap;
+  terminal->type = output_termcap;
-  device->display_info.tty = tty;
+  terminal->display_info.tty = tty;
-  tty->device = device;
+  tty->terminal = terminal;
  tty->Wcm = (struct cm *) xmalloc (sizeof (struct cm));
  Wcm_clear (tty);
-  device->rif = 0; /* ttys don't support window-based redisplay. */
+  terminal->rif = 0; /* ttys don't support window-based redisplay. */
-  device->cursor_to_hook = &tty_cursor_to;
+  terminal->cursor_to_hook = &tty_cursor_to;
-  device->raw_cursor_to_hook = &tty_raw_cursor_to;
+  terminal->raw_cursor_to_hook = &tty_raw_cursor_to;
-  device->clear_to_end_hook = &tty_clear_to_end;
+  terminal->clear_to_end_hook = &tty_clear_to_end;
-  device->clear_frame_hook = &tty_clear_frame;
+  terminal->clear_frame_hook = &tty_clear_frame;
-  device->clear_end_of_line_hook = &tty_clear_end_of_line;
+  terminal->clear_end_of_line_hook = &tty_clear_end_of_line;
-  device->ins_del_lines_hook = &tty_ins_del_lines;
+  terminal->ins_del_lines_hook = &tty_ins_del_lines;
-  device->insert_glyphs_hook = &tty_insert_glyphs;
+  terminal->insert_glyphs_hook = &tty_insert_glyphs;
-  device->write_glyphs_hook = &tty_write_glyphs;
+  terminal->write_glyphs_hook = &tty_write_glyphs;
-  device->delete_glyphs_hook = &tty_delete_glyphs;
+  terminal->delete_glyphs_hook = &tty_delete_glyphs;
-  device->ring_bell_hook = &tty_ring_bell;
+  terminal->ring_bell_hook = &tty_ring_bell;
  
-  device->reset_terminal_modes_hook = &tty_reset_terminal_modes;
+  terminal->reset_terminal_modes_hook = &tty_reset_terminal_modes;
-  device->set_terminal_modes_hook = &tty_set_terminal_modes;
+  terminal->set_terminal_modes_hook = &tty_set_terminal_modes;
-  device->update_begin_hook = 0; /* Not needed. */
+  terminal->update_begin_hook = 0; /* Not needed. */
-  device->update_end_hook = &tty_update_end;
+  terminal->update_end_hook = &tty_update_end;
-  device->set_terminal_window_hook = &tty_set_terminal_window;
+  terminal->set_terminal_window_hook = &tty_set_terminal_window;
-  device->mouse_position_hook = 0; /* Not needed. */
+  terminal->mouse_position_hook = 0; /* Not needed. */
-  device->frame_rehighlight_hook = 0; /* Not needed. */
+  terminal->frame_rehighlight_hook = 0; /* Not needed. */
-  device->frame_raise_lower_hook = 0; /* Not needed. */
+  terminal->frame_raise_lower_hook = 0; /* Not needed. */
-  device->set_vertical_scroll_bar_hook = 0; /* Not needed. */
+  terminal->set_vertical_scroll_bar_hook = 0; /* Not needed. */
-  device->condemn_scroll_bars_hook = 0; /* Not needed. */
+  terminal->condemn_scroll_bars_hook = 0; /* Not needed. */
-  device->redeem_scroll_bar_hook = 0; /* Not needed. */
+  terminal->redeem_scroll_bar_hook = 0; /* Not needed. */
-  device->judge_scroll_bars_hook = 0; /* Not needed. */
+  terminal->judge_scroll_bars_hook = 0; /* Not needed. */
-  device->read_socket_hook = &tty_read_avail_input; /* keyboard.c */
+  terminal->read_socket_hook = &tty_read_avail_input; /* keyboard.c */
-  device->frame_up_to_date_hook = 0; /* Not needed. */
+  terminal->frame_up_to_date_hook = 0; /* Not needed. */
  
-  device->delete_frame_hook = &delete_tty_output;
+  terminal->delete_frame_hook = &delete_tty_output;
-  device->delete_device_hook = &delete_tty;
+  terminal->delete_terminal_hook = &delete_tty;
  
  if (name)
    {
@@ -2370,7 +2379,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
      if (fd < 0)
        {
-          delete_tty (device);
+          delete_tty (terminal);
          error ("Could not open file: %s", name);
        }
      if (!isatty (fd))
@@ -2383,7 +2392,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
      
      file = fdopen (fd, "w+");
      tty->name = xstrdup (name);
-      device->name = xstrdup (name);
+      terminal->name = xstrdup (name);
      tty->input = file;
      tty->output = file;
    }
@@ -2396,7 +2405,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
          error ("There is no controlling terminal any more");
        }
      tty->name = 0;
-      device->name = xstrdup (ttyname (0));
+      terminal->name = xstrdup (ttyname (0));
      tty->input = stdin;
      tty->output = stdout;
    }
@@ -2418,16 +2427,16 @@ init_tty (char *name, char *terminal_type, int must_succeed)
  FrameCols (tty) = FRAME_COLS (f);  /* XXX */
  tty->specified_window = FRAME_LINES (f); /* XXX */
-  tty->device->delete_in_insert_mode = 1;
+  tty->terminal->delete_in_insert_mode = 1;
  UseTabs (tty) = 0;
-  device->scroll_region_ok = 0;
+  terminal->scroll_region_ok = 0;
  /* Seems to insert lines when it's not supposed to, messing up the
-     device.  In doing a trace, it didn't seem to be called much, so I
+     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.  */
-  device->line_ins_del_ok = 0;
+  terminal->line_ins_del_ok = 0;
-  device->char_ins_del_ok = 1;
+  terminal->char_ins_del_ok = 1;
  baud_rate = 19200;
@@ -2435,7 +2444,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
  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 device;
+  return terminal;
 #else  /* not WINDOWSNT */
  Wcm_clear (tty);
@@ -2451,11 +2460,11 @@ init_tty (char *name, char *terminal_type, int must_succeed)
  if (status < 0)
    {
 #ifdef TERMINFO
-      maybe_fatal (must_succeed, buffer, device,
+      maybe_fatal (must_succeed, buffer, terminal,
                   "Cannot open terminfo database file",
                   "Cannot open terminfo database file");
 #else
-      maybe_fatal (must_succeed, buffer, device,
+      maybe_fatal (must_succeed, buffer, terminal,
                   "Cannot open termcap database file",
                   "Cannot open termcap database file");
 #endif
@@ -2463,7 +2472,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
  if (status == 0)
    {
 #ifdef TERMINFO
-      maybe_fatal (must_succeed, buffer, device,
+      maybe_fatal (must_succeed, buffer, terminal,
                   "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\
@@ -2472,7 +2481,7 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
 to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
                   terminal_type);
 #else
-      maybe_fatal (must_succeed, buffer, device,
+      maybe_fatal (must_succeed, buffer, terminal,
                   "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\
@@ -2594,9 +2603,9 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  /* Since we make MagicWrap terminals look like AutoWrap, we need to have
     the former flag imply the latter.  */
  AutoWrap (tty) = MagicWrap (tty) || tgetflag ("am");
-  device->memory_below_frame = tgetflag ("db");
+  terminal->memory_below_frame = tgetflag ("db");
  tty->TF_hazeltine = tgetflag ("hz");
-  device->must_write_spaces = tgetflag ("in");
+  terminal->must_write_spaces = tgetflag ("in");
  tty->meta_key = tgetflag ("km") || tgetflag ("MT");
  tty->TF_insmode_motion = tgetflag ("mi");
  tty->TF_standout_motion = tgetflag ("ms");
@@ -2604,19 +2613,19 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  tty->TF_teleray = tgetflag ("xt");
 #ifdef MULTI_KBOARD
-  device->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
+  terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
-  init_kboard (device->kboard);
+  init_kboard (terminal->kboard);
-  device->kboard->next_kboard = all_kboards;
+  terminal->kboard->next_kboard = all_kboards;
-  all_kboards = device->kboard;
+  all_kboards = terminal->kboard;
-  device->kboard->reference_count++;
+  terminal->kboard->reference_count++;
  /* 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 = device->kboard;
+    current_kboard = terminal->kboard;
 #endif
-  term_get_fkeys (address, device->kboard);
+  term_get_fkeys (address, terminal->kboard);
  /* Get frame size from system, or else from termcap.  */
  {
@@ -2632,13 +2641,13 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
    FrameRows (tty) = tgetnum ("li");
  if (FrameRows (tty) < 3 || FrameCols (tty) < 3)
-    maybe_fatal (must_succeed, NULL, device,
+    maybe_fatal (must_succeed, NULL, terminal,
                 "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->device->min_padding_speed = tgetnum ("pb");
+  tty->terminal->min_padding_speed = tgetnum ("pb");
 #endif
  TabWidth (tty) = tgetnum ("tw");
@@ -2716,7 +2725,7 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  if (!strcmp (terminal_type, "supdup"))
    {
-      device->memory_below_frame = 1;
+      terminal->memory_below_frame = 1;
      tty->Wcm->cm_losewrap = 1;
    }
  if (!strncmp (terminal_type, "c10", 3)
@@ -2743,7 +2752,7 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
            tty->TS_set_window = "\033v%C %C %C %C ";
        }
      /* Termcap entry often fails to have :in: flag */
-      device->must_write_spaces = 1;
+      terminal->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, tty->TS_termcap_modes);
@@ -2765,7 +2774,7 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  if (Wcm_init (tty) == -1)     /* can't do cursor motion */
    {
-      maybe_fatal (must_succeed, NULL, device,
+      maybe_fatal (must_succeed, NULL, terminal,
                   "Terminal type \"%s\" is not powerful enough to run Emacs",
 #ifdef VMS
                   "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
@@ -2794,7 +2803,7 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
    }
  if (FrameRows (tty) <= 0 || FrameCols (tty) <= 0)
-    maybe_fatal (must_succeed, NULL, device,
+    maybe_fatal (must_succeed, NULL, terminal,
                 "Could not determine the frame size",
                 "Could not determine the frame size");
@@ -2808,30 +2817,30 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  UseTabs (tty) = tabs_safe_p (fileno (tty->input)) && TabWidth (tty) == 8;
-  device->scroll_region_ok
+  terminal->scroll_region_ok
    = (tty->Wcm->cm_abs
       && (tty->TS_set_window || tty->TS_set_scroll_region || tty->TS_set_scroll_region_1));
-  device->line_ins_del_ok
+  terminal->line_ins_del_ok
    = (((tty->TS_ins_line || tty->TS_ins_multi_lines)
        && (tty->TS_del_line || tty->TS_del_multi_lines))
-       || (device->scroll_region_ok
+       || (terminal->scroll_region_ok
           && tty->TS_fwd_scroll && tty->TS_rev_scroll));
-  device->char_ins_del_ok
+  terminal->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));
-  device->fast_clear_end_of_line = tty->TS_clr_line != 0;
+  terminal->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.  */
-  device->line_ins_del_ok = 0;
+  terminal->line_ins_del_ok = 0;
-  device->char_ins_del_ok = 0;
+  terminal->char_ins_del_ok = 0;
 #endif
  /* Don't do this.  I think termcap may still need the buffer. */
@@ -2840,26 +2849,26 @@ to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
  /* Init system terminal modes (RAW or CBREAK, etc.).  */
  init_sys_modes (tty);
-  return device;
+  return terminal;
 #endif /* not WINDOWSNT */
 }
 /* Auxiliary error-handling function for init_tty.
-   Free BUFFER and delete DEVICE, then call error or fatal
+   Free BUFFER and delete TERMINAL, then call error or fatal
   with str1 or str2, respectively, according to MUST_SUCCEED.  */
 static void
-maybe_fatal (must_succeed, buffer, device, str1, str2, arg1, arg2)
+maybe_fatal (must_succeed, buffer, terminal, str1, str2, arg1, arg2)
     int must_succeed;
     char *buffer;
-     struct device *device;
+     struct terminal *terminal;
     char *str1, *str2, *arg1, *arg2;
 {
  if (buffer)
    xfree (buffer);
-  if (device)
+  if (terminal)
-    delete_tty (device);
+    delete_tty (terminal);
  
  if (must_succeed)
    fatal (str2, arg1, arg2);
@@ -2886,38 +2895,38 @@ fatal (str, arg1, arg2)
 static int deleting_tty = 0;
-/* Delete the given terminal device, closing all frames on it. */
+/* Delete the given tty terminal, closing all frames on it. */
 static void
-delete_tty (struct device *device)
+delete_tty (struct terminal *terminal)
 {
  struct tty_display_info *tty;
  Lisp_Object tail, frame;
  char *tty_name;
-  int last_device;
+  int last_terminal;
  
  if (deleting_tty)
    /* We get a recursive call when we delete the last frame on this
-       device. */
+       terminal. */
    return;
-  if (device->type != output_termcap)
+  if (terminal->type != output_termcap)
    abort ();
-  tty = device->display_info.tty;
+  tty = terminal->display_info.tty;
  
-  last_device = 1;
+  last_terminal = 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_device = 0;
+          last_terminal = 0;
          break;
        }
    }
-  if (last_device)
+  if (last_terminal)
-      error ("Attempt to delete the sole display device with live frames");
+      error ("Attempt to delete the sole terminal device with live frames");
  
  if (tty == tty_list)
    tty_list = tty->next;
@@ -2947,10 +2956,10 @@ delete_tty (struct device *device)
    }
  /* reset_sys_modes needs a valid device, so this call needs to be
-     before delete_device. */
+     before delete_terminal. */
  reset_sys_modes (tty);
-  delete_device (device);
+  delete_terminal (terminal);
  tty_name = tty->name;
  if (tty->type)
@@ -3025,8 +3034,8 @@ See `resume-tty'.  */);
  defsubr (&Stty_display_color_p);
  defsubr (&Stty_display_color_cells);
  defsubr (&Stty_no_underline);
-  defsubr (&Sdisplay_tty_type);
+  defsubr (&Stty_type);
-  defsubr (&Sdisplay_controlling_tty_p);
+  defsubr (&Scontrolling_tty_p);
  defsubr (&Ssuspend_tty);
  defsubr (&Sresume_tty);
 }
diff --git a/src/termchar.h b/src/termchar.h
index 87072136317..f4b58f105b0 100644
--- a/src/termchar.h
+++ b/src/termchar.h
@@ -58,9 +58,9 @@ struct tty_display_info
  int reference_count;          /* Number of frames that are on this display. */
-  struct device *device;        /* Points back to the generic display device
+  struct terminal *terminal;    /* Points back to the generic terminal
                                   structure.  This is sometimes handy. */
-  
  /* Info on cursor positioning.  */
  struct cm *Wcm;
@@ -194,7 +194,7 @@ extern struct tty_display_info *tty_list;
 #define FRAME_TTY(f)                            \
  ((f)->output_method == output_termcap         \
-   ? (f)->device->display_info.tty              \
+   ? (f)->terminal->display_info.tty            \
   : (abort(), (struct tty_display_info *) 0))
 #define CURTTY() FRAME_TTY (SELECTED_FRAME())
diff --git a/src/termhooks.h b/src/termhooks.h
index c925a85b484..7045d6ee1e3 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -1,4 +1,4 @@
-/* Parameters and display hooks for output devices.
+/* Parameters and display hooks for terminal devices.
   Copyright (C) 1985, 1986, 1993, 1994, 2002, 2003, 2004,
                 2005 Free Software Foundation, Inc.
@@ -288,30 +288,30 @@ enum {
 #endif /* CONSP */
-/* Device-local parameters. */
+/* Terminal-local parameters. */
-struct device
+struct terminal
 {
-  /* Chain of all display devices. */
+  /* Chain of all terminal devices. */
-  struct device *next_device;
+  struct terminal *next_terminal;
-  /* Unique id for this display device. */
+  /* Unique id for this terminal device. */
  int id;
-  /* The number of frames that are on this device. */
+  /* The number of frames that are on this terminal. */
  int reference_count;
  
-  /* The type of the display device. */
+  /* The type of the terminal device. */
  enum output_method type;
-  /* The name of the display device.  Do not use this to identify the device. */
+  /* The name of the terminal device.  Do not use this to identify the device. */
  char *name;
 #ifdef MULTI_KBOARD
-  /* The device's keyboard object. */
+  /* The terminal's keyboard object. */
  struct kboard *kboard;
 #endif
-  /* Device-type dependent data shared amongst all frames on this display. */
+  /* Device-type dependent data shared amongst all frames on this terminal. */
  union display_info
  {
    struct tty_display_info *tty;     /* termchar.h */
@@ -381,8 +381,8 @@ struct device
  
  void (*ring_bell_hook) P_ ((struct frame *f));
  
-  void (*reset_terminal_modes_hook) P_ ((struct device *));
+  void (*reset_terminal_modes_hook) P_ ((struct terminal *));
-  void (*set_terminal_modes_hook) P_ ((struct device *));
+  void (*set_terminal_modes_hook) P_ ((struct terminal *));
  void (*update_begin_hook) P_ ((struct frame *));
  void (*update_end_hook) P_ ((struct frame *));
@@ -428,7 +428,7 @@ struct device
  /* 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
+     hook is zero, that means the terminal we're displaying on doesn't
     support overlapping frames, so there's no need to raise or lower
     anything.
     
@@ -512,10 +512,10 @@ struct device
  /* Called to read input events.
-     DEVICE indicates which display device to read from.  Input events
+     TERMINAL indicates which terminal device to read from.  Input
-     should be read into BUF, the size of which is given in SIZE.
+     events should be read into BUF, the size of which is given in
-     EXPECTED is non-zero if the caller suspects that new input is
+     SIZE.  EXPECTED is non-zero if the caller suspects that new input
-     available.
+     is available.
     A positive return value indicates that that many input events
     where read into BUF.
@@ -525,11 +525,11 @@ struct device
     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.
+     terminal 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 device *device,
+  int (*read_socket_hook) P_ ((struct terminal *terminal,
                               int expected,
                               struct input_event *hold_quit));
@@ -538,43 +538,43 @@ struct device
  /* Called to delete the device-specific portions of a frame that is
-     on this display device. */
+     on this terminal device. */
  void (*delete_frame_hook) P_ ((struct frame *));
-  /* Called after the last frame on this device is deleted, or when
+  /* Called after the last frame on this terminal is deleted, or when
     the display device was closed (hangup).
     
-     If this is NULL, then the generic delete_device is called
+     If this is NULL, then the generic delete_terminal is called
-     instead.  Otherwise the hook must call delete_device itself.
+     instead.  Otherwise the hook must call delete_terminal itself.
     The hook must check for and close any live frames that are still
-     on the device.  Fdelete_frame ensures that there are no live
+     on the terminal.  Fdelete_frame ensures that there are no live
-     frames on the device when it calls this hook, so infinite
+     frames on the terminal when it calls this hook, so infinite
     recursion is prevented.  */
-  void (*delete_device_hook) P_ ((struct device *));
+  void (*delete_terminal_hook) P_ ((struct terminal *));
 };
-/* Chain of all display devices currently in use. */
+/* Chain of all terminal devices currently in use. */
-extern struct device *device_list;
+extern struct terminal *terminal_list;
-#define FRAME_MUST_WRITE_SPACES(f) ((f)->device->must_write_spaces)
+#define FRAME_MUST_WRITE_SPACES(f) ((f)->terminal->must_write_spaces)
-#define FRAME_FAST_CLEAR_END_OF_LINE(f) ((f)->device->fast_clear_end_of_line)
+#define FRAME_FAST_CLEAR_END_OF_LINE(f) ((f)->terminal->fast_clear_end_of_line)
-#define FRAME_LINE_INS_DEL_OK(f) ((f)->device->line_ins_del_ok)
+#define FRAME_LINE_INS_DEL_OK(f) ((f)->terminal->line_ins_del_ok)
-#define FRAME_CHAR_INS_DEL_OK(f) ((f)->device->char_ins_del_ok)
+#define FRAME_CHAR_INS_DEL_OK(f) ((f)->terminal->char_ins_del_ok)
-#define FRAME_SCROLL_REGION_OK(f) ((f)->device->scroll_region_ok)
+#define FRAME_SCROLL_REGION_OK(f) ((f)->terminal->scroll_region_ok)
-#define FRAME_SCROLL_REGION_COST(f) ((f)->device->scroll_region_cost)
+#define FRAME_SCROLL_REGION_COST(f) ((f)->terminal->scroll_region_cost)
-#define FRAME_MEMORY_BELOW_FRAME(f) ((f)->device->memory_below_frame)
+#define FRAME_MEMORY_BELOW_FRAME(f) ((f)->terminal->memory_below_frame)
-#define FRAME_TERMINAL_CODING(f) ((f)->device->terminal_coding)
+#define FRAME_TERMINAL_CODING(f) ((f)->terminal->terminal_coding)
-#define FRAME_KEYBOARD_CODING(f) ((f)->device->keyboard_coding)
+#define FRAME_KEYBOARD_CODING(f) ((f)->terminal->keyboard_coding)
-#define DEVICE_TERMINAL_CODING(d) ((d)->terminal_coding)
+#define TERMINAL_TERMINAL_CODING(d) ((d)->terminal_coding)
-#define DEVICE_KEYBOARD_CODING(d) ((d)->keyboard_coding)
+#define TERMINAL_KEYBOARD_CODING(d) ((d)->keyboard_coding)
-#define FRAME_RIF(f) ((f)->device->rif)
+#define FRAME_RIF(f) ((f)->terminal->rif)
-#define FRAME_DEVICE(f) ((f)->device)
+#define FRAME_TERMINAL(f) ((f)->terminal)
 /* FRAME_WINDOW_P tests whether the frame is a window, and is
   defined to be the predicate for the window system being used.  */
@@ -592,16 +592,16 @@ extern struct device *device_list;
 #define FRAME_WINDOW_P(f) (0)
 #endif
-/* Return true if the display device is not suspended. */
+/* Return true if the terminal device is not suspended. */
-#define DEVICE_ACTIVE_P(d) ((d)->type != output_termcap || (d)->display_info.tty->input)
+#define TERMINAL_ACTIVE_P(d) ((d)->type != output_termcap || (d)->display_info.tty->input)
-extern Lisp_Object get_terminal_param P_ ((struct device *, Lisp_Object));
+extern Lisp_Object get_terminal_param P_ ((struct terminal *, Lisp_Object));
-extern struct device *get_device P_ ((Lisp_Object display, int));
+extern struct terminal *get_terminal P_ ((Lisp_Object terminal, int));
-extern struct device *create_device P_ ((void));
+extern struct terminal *create_terminal P_ ((void));
-extern void delete_device P_ ((struct device *));
+extern void delete_terminal P_ ((struct terminal *));
-/* The initial display device, created by initial_term_init. */
+/* The initial terminal device, created by initial_term_init. */
-extern struct device *initial_device;
+extern struct terminal *initial_terminal;
 /* arch-tag: 33a00ecc-52b5-4186-a410-8801ac9f087d
   (do not change this comment) */
diff --git a/src/terminal.c b/src/terminal.c
index 83879a43afa..084318b893f 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -28,19 +28,19 @@ Boston, MA 02110-1301, USA.  */
 #include "coding.h"
 #include "keyboard.h"
-/* Chain of all displays currently in use. */
+/* Chain of all terminals currently in use. */
-struct device *device_list;
+struct terminal *terminal_list;
-/* The first unallocated display id. */
+/* The first unallocated terminal id. */
-static int next_device_id;
+static int next_terminal_id;
-/* The initial display device, created by initial_term_init. */
+/* The initial terminal device, created by initial_term_init. */
-struct device *initial_device;
+struct terminal *initial_terminal;
 /* Function to use to ring the bell.  */
 Lisp_Object Vring_bell_function;
-void delete_initial_device P_ ((struct device *));
+static void delete_initial_terminal P_ ((struct terminal *));
@@ -66,22 +66,22 @@ ring_bell (struct frame *f)
      Vring_bell_function = function;
    }
-  else if (FRAME_DEVICE (f)->ring_bell_hook)
+  else if (FRAME_TERMINAL (f)->ring_bell_hook)
-    (*FRAME_DEVICE (f)->ring_bell_hook) (f);
+    (*FRAME_TERMINAL (f)->ring_bell_hook) (f);
 }
 void
 update_begin (struct frame *f)
 {
-  if (FRAME_DEVICE (f)->update_begin_hook)
+  if (FRAME_TERMINAL (f)->update_begin_hook)
-    (*FRAME_DEVICE (f)->update_begin_hook) (f);
+    (*FRAME_TERMINAL (f)->update_begin_hook) (f);
 }
 void
 update_end (struct frame *f)
 {
-  if (FRAME_DEVICE (f)->update_end_hook)
+  if (FRAME_TERMINAL (f)->update_end_hook)
-    (*FRAME_DEVICE (f)->update_end_hook) (f);
+    (*FRAME_TERMINAL (f)->update_end_hook) (f);
 }
 /* Specify how many text lines, from the top of the window,
@@ -92,8 +92,8 @@ update_end (struct frame *f)
 void
 set_terminal_window (struct frame *f, int size)
 {
-  if (FRAME_DEVICE (f)->set_terminal_window_hook)
+  if (FRAME_TERMINAL (f)->set_terminal_window_hook)
-    (*FRAME_DEVICE (f)->set_terminal_window_hook) (f, size);
+    (*FRAME_TERMINAL (f)->set_terminal_window_hook) (f, size);
 }
 /* Move cursor to row/column position VPOS/HPOS.  HPOS/VPOS are
@@ -102,8 +102,8 @@ set_terminal_window (struct frame *f, int size)
 void
 cursor_to (struct frame *f, int vpos, int hpos)
 {
-  if (FRAME_DEVICE (f)->cursor_to_hook)
+  if (FRAME_TERMINAL (f)->cursor_to_hook)
-    (*FRAME_DEVICE (f)->cursor_to_hook) (f, vpos, hpos);
+    (*FRAME_TERMINAL (f)->cursor_to_hook) (f, vpos, hpos);
 }
 /* Similar but don't take any account of the wasted characters.  */
@@ -111,8 +111,8 @@ cursor_to (struct frame *f, int vpos, int hpos)
 void
 raw_cursor_to (struct frame *f, int row, int col)
 {
-  if (FRAME_DEVICE (f)->raw_cursor_to_hook)
+  if (FRAME_TERMINAL (f)->raw_cursor_to_hook)
-    (*FRAME_DEVICE (f)->raw_cursor_to_hook) (f, row, col);  
+    (*FRAME_TERMINAL (f)->raw_cursor_to_hook) (f, row, col);  
 }
 /* Erase operations */
@@ -121,8 +121,8 @@ raw_cursor_to (struct frame *f, int row, int col)
 void
 clear_to_end (struct frame *f)
 {
-  if (FRAME_DEVICE (f)->clear_to_end_hook)
+  if (FRAME_TERMINAL (f)->clear_to_end_hook)
-    (*FRAME_DEVICE (f)->clear_to_end_hook) (f);
+    (*FRAME_TERMINAL (f)->clear_to_end_hook) (f);
 }
 /* Clear entire frame */
@@ -130,8 +130,8 @@ clear_to_end (struct frame *f)
 void
 clear_frame (struct frame *f)
 {
-  if (FRAME_DEVICE (f)->clear_frame_hook)
+  if (FRAME_TERMINAL (f)->clear_frame_hook)
-    (*FRAME_DEVICE (f)->clear_frame_hook) (f);
+    (*FRAME_TERMINAL (f)->clear_frame_hook) (f);
 }
 /* Clear from cursor to end of line.
@@ -142,8 +142,8 @@ clear_frame (struct frame *f)
 void
 clear_end_of_line (struct frame *f, int first_unused_hpos)
 {
-  if (FRAME_DEVICE (f)->clear_end_of_line_hook)
+  if (FRAME_TERMINAL (f)->clear_end_of_line_hook)
-    (*FRAME_DEVICE (f)->clear_end_of_line_hook) (f, first_unused_hpos);
+    (*FRAME_TERMINAL (f)->clear_end_of_line_hook) (f, first_unused_hpos);
 }
 /* Output LEN glyphs starting at STRING at the nominal cursor position.
@@ -152,8 +152,8 @@ clear_end_of_line (struct frame *f, int first_unused_hpos)
 void
 write_glyphs (struct frame *f, struct glyph *string, int len)
 {
-  if (FRAME_DEVICE (f)->write_glyphs_hook)
+  if (FRAME_TERMINAL (f)->write_glyphs_hook)
-    (*FRAME_DEVICE (f)->write_glyphs_hook) (f, string, len);
+    (*FRAME_TERMINAL (f)->write_glyphs_hook) (f, string, len);
 }
 /* Insert LEN glyphs from START at the nominal cursor position.
@@ -166,8 +166,8 @@ insert_glyphs (struct frame *f, struct glyph *start, int len)
  if (len <= 0)
    return;
-  if (FRAME_DEVICE (f)->insert_glyphs_hook)
+  if (FRAME_TERMINAL (f)->insert_glyphs_hook)
-    (*FRAME_DEVICE (f)->insert_glyphs_hook) (f, start, len);
+    (*FRAME_TERMINAL (f)->insert_glyphs_hook) (f, start, len);
 }
 /* Delete N glyphs at the nominal cursor position. */
@@ -175,8 +175,8 @@ insert_glyphs (struct frame *f, struct glyph *start, int len)
 void
 delete_glyphs (struct frame *f, int n)
 {
-  if (FRAME_DEVICE (f)->delete_glyphs_hook)
+  if (FRAME_TERMINAL (f)->delete_glyphs_hook)
-    (*FRAME_DEVICE (f)->delete_glyphs_hook) (f, n);
+    (*FRAME_TERMINAL (f)->delete_glyphs_hook) (f, n);
 }
 /* Insert N lines at vpos VPOS.  If N is negative, delete -N lines.  */
@@ -184,185 +184,209 @@ delete_glyphs (struct frame *f, int n)
 void
 ins_del_lines (struct frame *f, int vpos, int n)
 {
-  if (FRAME_DEVICE (f)->ins_del_lines_hook)
+  if (FRAME_TERMINAL (f)->ins_del_lines_hook)
-    (*FRAME_DEVICE (f)->ins_del_lines_hook) (f, vpos, n);
+    (*FRAME_TERMINAL (f)->ins_del_lines_hook) (f, vpos, n);
 }
-/* Return the display object specified by DEVICE.  DEVICE may be a
+/* Return the terminal object specified by TERMINAL.  TERMINAL may be a
-   display id, a frame, or nil for the display device of the current
+   terminal id, a frame, or nil for the terminal device of the current
   frame.  If THROW is zero, return NULL for failure, otherwise throw
   an error.  */
-struct device *
+struct terminal *
-get_device (Lisp_Object device, int throw)
+get_terminal (Lisp_Object terminal, int throw)
 {
-  struct device *result = NULL;
+  struct terminal *result = NULL;
-  if (NILP (device))
+  if (NILP (terminal))
-    device = selected_frame;
+    terminal = selected_frame;
-  if (INTEGERP (device))
+  if (INTEGERP (terminal))
    {
-      struct device *d;
+      struct terminal *t;
-      for (d = device_list; d; d = d->next_device)
+      for (t = terminal_list; t; t = t->next_terminal)
        {
-          if (d->id == XINT (device))
+          if (t->id == XINT (terminal))
            {
-              result = d;
+              result = t;
              break;
            }
        }
    }
-  else if (FRAMEP (device))
+  else if (FRAMEP (terminal))
    {
-      result = FRAME_DEVICE (XFRAME (device));
+      result = FRAME_TERMINAL (XFRAME (terminal));
    }
  if (result == NULL && throw)
-    wrong_type_argument (Qdisplay_live_p, device);
+    wrong_type_argument (Qterminal_live_p, terminal);
  return result;
 }
-/* Create a new device object and add it to the device list. */
+/* Create a new terminal object and add it to the terminal list. */
-struct device *
+struct terminal *
-create_device (void)
+create_terminal (void)
 {
-  struct device *device = (struct device *) xmalloc (sizeof (struct device));
+  struct terminal *terminal = (struct terminal *) xmalloc (sizeof (struct terminal));
  
-  bzero (device, sizeof (struct device));
+  bzero (terminal, sizeof (struct terminal));
-  device->next_device = device_list;
+  terminal->next_terminal = terminal_list;
-  device_list = device;
+  terminal_list = terminal;
-  device->id = next_device_id++;
+  terminal->id = next_terminal_id++;
-  device->keyboard_coding =
+  terminal->keyboard_coding =
    (struct coding_system *) xmalloc (sizeof (struct coding_system));
-  device->terminal_coding =
+  terminal->terminal_coding =
    (struct coding_system *) xmalloc (sizeof (struct coding_system));
-  setup_coding_system (Qnil, device->keyboard_coding);
+  setup_coding_system (Qnil, terminal->keyboard_coding);
-  setup_coding_system (Qnil, device->terminal_coding);
+  setup_coding_system (Qnil, terminal->terminal_coding);
-  device->param_alist = Qnil;
+  terminal->param_alist = Qnil;
-  return device;
+  return terminal;
 }
 /* Mark the Lisp pointers in the terminal objects.
   Called by the Fgarbage_collector.  */
 void
-mark_devices (void)
+mark_terminals (void)
 {
-  struct device *d;
+  struct terminal *t;
-  for (d = device_list; d; d = d->next_device)
+  for (t = terminal_list; t; t = t->next_terminal)
    {
-      mark_object (d->param_alist);
+      mark_object (t->param_alist);
    }
 }
-/* Remove a device from the device list and free its memory. */
+/* Remove a terminal from the terminal list and free its memory. */
 void
-delete_device (struct device *device)
+delete_terminal (struct terminal *terminal)
 {
-  struct device **dp;
+  struct terminal **tp;
  Lisp_Object tail, frame;
  
  /* Check for and close live frames that are still on this
-     device. */
+     terminal. */
  FOR_EACH_FRAME (tail, frame)
    {
      struct frame *f = XFRAME (frame);
-      if (FRAME_LIVE_P (f) && f->device == device)
+      if (FRAME_LIVE_P (f) && f->terminal == terminal)
        {
          Fdelete_frame (frame, Qt);
        }
    }
-  for (dp = &device_list; *dp != device; dp = &(*dp)->next_device)
+  for (tp = &terminal_list; *tp != terminal; tp = &(*tp)->next_terminal)
-    if (! *dp)
+    if (! *tp)
      abort ();
-  *dp = device->next_device;
+  *tp = terminal->next_terminal;
-  if (device->keyboard_coding)
+  if (terminal->keyboard_coding)
-    xfree (device->keyboard_coding);
+    xfree (terminal->keyboard_coding);
-  if (device->terminal_coding)
+  if (terminal->terminal_coding)
-    xfree (device->terminal_coding);
+    xfree (terminal->terminal_coding);
-  if (device->name)
+  if (terminal->name)
-    xfree (device->name);
+    xfree (terminal->name);
  
 #ifdef MULTI_KBOARD
-  if (device->kboard && --device->kboard->reference_count == 0)
+  if (terminal->kboard && --terminal->kboard->reference_count == 0)
-    delete_kboard (device->kboard);
+    delete_kboard (terminal->kboard);
 #endif
  
-  bzero (device, sizeof (struct device));
+  bzero (terminal, sizeof (struct terminal));
-  xfree (device);
+  xfree (terminal);
 }
-DEFUN ("delete-display", Fdelete_display, Sdelete_display, 0, 2, 0,
+DEFUN ("delete-terminal", Fdelete_terminal, Sdelete_terminal, 0, 2, 0,
-       doc: /* Delete DEVICE by deleting all frames on it and closing the device.
+       doc: /* Delete TERMINAL by deleting all frames on it and closing the terminal.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL may be a terminal id, a frame, or nil (meaning the selected
-selected frame's display device).
+frame's terminal).
 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. */)
-  (device, force)
+  (terminal, force)
-     Lisp_Object device, force;
+     Lisp_Object terminal, force;
 {
-  struct device *d, *p;
+  struct terminal *t, *p;
-  d = get_device (device, 0);
+  t = get_terminal (terminal, 0);
-  if (!d)
+  if (!t)
    return Qnil;
-  p = device_list;
+  p = terminal_list;
-  while (p && (p == d || !DEVICE_ACTIVE_P (p)))
+  while (p && (p == t || !TERMINAL_ACTIVE_P (p)))
-    p = p->next_device;
+    p = p->next_terminal;
  
  if (NILP (force) && !p)
-    error ("Attempt to delete the sole active display device");
+    error ("Attempt to delete the sole active display terminal");
-  if (d->delete_device_hook)
+  if (t->delete_terminal_hook)
-    (*d->delete_device_hook) (d);
+    (*t->delete_terminal_hook) (t);
  else
-    delete_device (d);
+    delete_terminal (t);
  return Qnil;
 }
-DEFUN ("display-live-p", Fdisplay_live_p, Sdisplay_live_p, 1, 1, 0,
-       doc: /* Return non-nil if OBJECT is a device which has not been deleted.
+DEFUN ("frame-terminal", Fframe_terminal, Sframe_terminal, 0, 1, 0,
-Value is nil if OBJECT is not a live display device.
+       doc: /* Return the terminal that FRAME is displayed on.
-If object is a live display device, the return value indicates what
+If FRAME is nil, the selected frame is used.
-sort of output device it uses.  See the documentation of `framep' for
+The terminal device is represented by its integer identifier.  */)
+  (frame)
+     Lisp_Object frame;
+{
+  struct terminal *t;
+  if (NILP (frame))
+    frame = selected_frame;
+  CHECK_LIVE_FRAME (frame);
+  t = get_terminal (frame, 0);
+  if (!t)
+    return Qnil;
+  else
+    return make_number (t->id);
+}
+DEFUN ("terminal-live-p", Fterminal_live_p, Sterminal_live_p, 1, 1, 0,
+       doc: /* Return non-nil if OBJECT is a terminal which has not been deleted.
+Value is nil if OBJECT is not a live display terminal.
+If object is a live display terminal, the return value indicates what
+sort of output terminal it uses.  See the documentation of `framep' for
 possible return values.
-Display devices are represented by their integer identifiers. */)
+Display terminals are represented by their integer identifiers. */)
     (object)
     Lisp_Object object;
 {
-  struct device *d;
+  struct terminal *t;
  
  if (!INTEGERP (object))
    return Qnil;
-  d = get_device (object, 0);
+  t = get_terminal (object, 0);
-  if (!d)
+  if (!t)
    return Qnil;
-  switch (d->type)
+  switch (t->type)
    {
    case output_initial: /* The initial frame is like a termcap frame. */
    case output_termcap:
@@ -380,64 +404,64 @@ Display devices are represented by their integer identifiers. */)
    }
 }
-DEFUN ("display-list", Fdisplay_list, Sdisplay_list, 0, 0, 0,
+DEFUN ("terminal-list", Fterminal_list, Sterminal_list, 0, 0, 0,
-       doc: /* Return a list of all display devices.
+       doc: /* Return a list of all terminal devices.
-Display devices are represented by their integer identifiers. */)
+Terminal devices are represented by their integer identifiers. */)
  ()
 {
-  Lisp_Object devices = Qnil;
+  Lisp_Object terminals = Qnil;
-  struct device *d;
+  struct terminal *t;
-  for (d = device_list; d; d = d->next_device)
+  for (t = terminal_list; t; t = t->next_terminal)
-    devices = Fcons (make_number (d->id), devices);
+    terminals = Fcons (make_number (t->id), terminals);
-  return devices;
+  return terminals;
 }
-DEFUN ("display-name", Fdisplay_name, Sdisplay_name, 0, 1, 0,
+DEFUN ("terminal-name", Fterminal_name, Sterminal_name, 0, 1, 0,
-       doc: /* Return the name of the display device DEVICE.
+       doc: /* Return the name of the terminal device TERMINAL.
 It is not guaranteed that the returned value is unique among opened devices.
-DEVICE may be a display device id, a frame, or nil (meaning the
+TERMINAL may be a terminal id, a frame, or nil (meaning the
-selected frame's display device). */)
+selected frame's terminal). */)
-  (device)
+  (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct device *d = get_device (device, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  if (d->name)
+  if (t->name)
-    return build_string (d->name);
+    return build_string (t->name);
  else
    return Qnil;
 }
-/* Return the value of terminal parameter PARAM in device D.  */
+/* Return the value of terminal parameter PARAM in terminal T.  */
 Lisp_Object
-get_terminal_param (d, param)
+get_terminal_param (t, param)
-     struct device *d;
+     struct terminal *t;
     Lisp_Object param;
 {
-  Lisp_Object tem = Fassq (param, d->param_alist);
+  Lisp_Object tem = Fassq (param, t->param_alist);
  if (EQ (tem, Qnil))
    return tem;
  return Fcdr (tem);
 }
-/* Set the value of terminal parameter PARAMETER in device D to VALUE.
+/* Set the value of terminal parameter PARAMETER in terminal D to VALUE.
   Return the previous value.  */
 Lisp_Object
-store_terminal_param (d, parameter, value)
+store_terminal_param (t, parameter, value)
-     struct device *d;
+     struct terminal *t;
     Lisp_Object parameter;
     Lisp_Object value;
 {
-  Lisp_Object old_alist_elt = Fassq (parameter, d->param_alist);
+  Lisp_Object old_alist_elt = Fassq (parameter, t->param_alist);
  if (EQ (old_alist_elt, Qnil))
    {
-      d->param_alist = Fcons (Fcons (parameter, value), d->param_alist);
+      t->param_alist = Fcons (Fcons (parameter, value), t->param_alist);
      return Qnil;
    }
  else
@@ -454,27 +478,27 @@ DEFUN ("terminal-parameters", Fterminal_parameters, Sterminal_parameters, 0, 1,
 The value is a list of elements of the form (PARM . VALUE), where PARM
 is a symbol.
-TERMINAL can be a terminal if, a frame or nil (meaning the selected
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
 frame's terminal).  */)
     (terminal)
     Lisp_Object terminal;
 {
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  return Fcopy_alist (d->param_alist);
+  return Fcopy_alist (t->param_alist);
 }
 DEFUN ("terminal-parameter", Fterminal_parameter, Sterminal_parameter, 2, 2, 0,
       doc: /* Return TERMINAL's value for parameter PARAMETER.
-TERMINAL can be a terminal if, a frame or nil (meaning the selected
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
 frame's terminal).  */)
     (terminal, parameter)
     Lisp_Object terminal;
     Lisp_Object parameter;
 {
  Lisp_Object value;
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  CHECK_SYMBOL (parameter);
-  value = Fcdr (Fassq (parameter, d->param_alist));
+  value = Fcdr (Fassq (parameter, t->param_alist));
  return value;
 }
@@ -484,14 +508,14 @@ DEFUN ("modify-terminal-parameters", Fmodify_terminal_parameters,
 ALIST is an alist of parameters to change and their new values.
 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
-TERMINAL can be a terminal if, a frame or nil (meaning the selected
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
 frame's terminal).  */)
     (terminal, alist)
     Lisp_Object terminal;
     Lisp_Object alist;
 {
  Lisp_Object tail, prop, val;
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
  int length = XINT (Fsafe_length (alist));
  int i;
  Lisp_Object *parms = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
@@ -515,7 +539,7 @@ frame's terminal).  */)
    {
      prop = parms[i];
      val = values[i];
-      store_terminal_param (d, prop, val);
+      store_terminal_param (t, prop, val);
    }
  return Qnil;
 }
@@ -525,50 +549,50 @@ DEFUN ("set-terminal-parameter", Fset_terminal_parameter,
       doc: /* Set TERMINAL's value for parameter PARAMETER to VALUE.
 Return the previous value of PARAMETER.
-TERMINAL can be a terminal if, a frame or nil (meaning the selected
+TERMINAL can be a terminal id, a frame or nil (meaning the selected
 frame's terminal).  */)
     (terminal, parameter, value)
     Lisp_Object terminal;
     Lisp_Object parameter;
     Lisp_Object value;
 {
-  struct device *d = get_device (terminal, 1);
+  struct terminal *t = get_terminal (terminal, 1);
-  return store_terminal_param (d, parameter, value);
+  return store_terminal_param (t, parameter, value);
 }
-/* Create the bootstrap display device for the initial frame.
+/* Create the bootstrap display terminal for the initial frame.
-   Returns a device of type output_initial.  */
+   Returns a terminal of type output_initial.  */
-struct device *
+struct terminal *
-init_initial_device (void)
+init_initial_terminal (void)
 {
-  if (initialized || device_list || tty_list)
+  if (initialized || terminal_list || tty_list)
    abort ();
-  initial_device = create_device ();
+  initial_terminal = create_terminal ();
-  initial_device->type = output_initial;
+  initial_terminal->type = output_initial;
-  initial_device->name = xstrdup ("initial_device");
+  initial_terminal->name = xstrdup ("initial_terminal");
-  initial_device->kboard = initial_kboard;
+  initial_terminal->kboard = initial_kboard;
-  initial_device->delete_device_hook = &delete_initial_device;
+  initial_terminal->delete_terminal_hook = &delete_initial_terminal;
  /* All other hooks are NULL. */
-  return initial_device;
+  return initial_terminal;
 }
-/* Deletes the bootstrap display device.
+/* Deletes the bootstrap terminal device.
-   Called through delete_device_hook. */
+   Called through delete_terminal_hook. */
-void
+static void
-delete_initial_device (struct device *device)
+delete_initial_terminal (struct terminal *terminal)
 {
-  if (device != initial_device)
+  if (terminal != initial_terminal)
    abort ();
-  delete_device (device);
+  delete_terminal (terminal);
-  initial_device = NULL;
+  initial_terminal = NULL;
 }
 void
@@ -580,10 +604,11 @@ syms_of_terminal ()
 The function should accept no arguments.  */);
  Vring_bell_function = Qnil;
-  defsubr (&Sdelete_display);
+  defsubr (&Sdelete_terminal);
-  defsubr (&Sdisplay_live_p);
+  defsubr (&Sframe_terminal);
-  defsubr (&Sdisplay_list);
+  defsubr (&Sterminal_live_p);
-  defsubr (&Sdisplay_name);
+  defsubr (&Sterminal_list);
+  defsubr (&Sterminal_name);
  defsubr (&Sterminal_parameters);
  defsubr (&Sterminal_parameter);
  defsubr (&Smodify_terminal_parameters);
diff --git a/src/xdisp.c b/src/xdisp.c
index 1f04b1eac27..df6bba2ef0b 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -7304,8 +7304,8 @@ message2_nolog (m, nbytes, multibyte)
      do_pending_window_change (0);
      echo_area_display (1);
      do_pending_window_change (0);
-      if (FRAME_DEVICE (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+      if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
-        (*FRAME_DEVICE (f)->frame_up_to_date_hook) (f);
+        (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
    }
 }
@@ -7408,8 +7408,8 @@ message3_nolog (m, nbytes, multibyte)
      do_pending_window_change (0);
      echo_area_display (1);
      do_pending_window_change (0);
-      if (FRAME_DEVICE (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
+      if (FRAME_TERMINAL (f)->frame_up_to_date_hook != 0 && ! gc_in_progress)
-        (*FRAME_DEVICE (f)->frame_up_to_date_hook) (f);
+        (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
    }
 }
@@ -10940,16 +10940,16 @@ redisplay_internal (preserve_echo_area)
              /* Mark all the scroll bars to be removed; we'll redeem
                 the ones we want when we redisplay their windows.  */
-              if (FRAME_DEVICE (f)->condemn_scroll_bars_hook)
+              if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
-                FRAME_DEVICE (f)->condemn_scroll_bars_hook (f);
+                FRAME_TERMINAL (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 (FRAME_DEVICE (f)->judge_scroll_bars_hook)
+              if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
-                FRAME_DEVICE (f)->judge_scroll_bars_hook (f);
+                FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
              /* If fonts changed, display again.  */
              /* ??? rms: I suspect it is a mistake to jump all the way
@@ -10999,8 +10999,8 @@ redisplay_internal (preserve_echo_area)
              if (f->updated_p)
                {
                  mark_window_display_accurate (f->root_window, 1);
-                  if (FRAME_DEVICE (f)->frame_up_to_date_hook)
+                  if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
-                    FRAME_DEVICE (f)->frame_up_to_date_hook (f);
+                    FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
                }
            }
        }
@@ -11086,8 +11086,8 @@ redisplay_internal (preserve_echo_area)
          /* Say overlay arrows are up to date.  */
          update_overlay_arrows (1);
-          if (FRAME_DEVICE (sf)->frame_up_to_date_hook != 0)
+          if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
-            FRAME_DEVICE (sf)->frame_up_to_date_hook (sf);
+            FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
        }
      update_mode_lines = 0;
@@ -12343,8 +12343,8 @@ set_vertical_scroll_bar (w)
    start = end = whole = 0;
  /* Indicate what this scroll bar ought to be displaying now.  */
-  if (FRAME_DEVICE (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
+  if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
-    (*FRAME_DEVICE (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
+    (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
      (w, end - start, whole, start);
 }
@@ -13083,8 +13083,8 @@ redisplay_window (window, just_this_one_p)
      /* Note that we actually used the scroll bar attached to this
         window, so it shouldn't be deleted at the end of redisplay.  */
-      if (FRAME_DEVICE (f)->redeem_scroll_bar_hook)
+      if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
-        (*FRAME_DEVICE (f)->redeem_scroll_bar_hook) (w);
+        (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
    }
  /* Restore current_buffer and value of point in it.  */
diff --git a/src/xfns.c b/src/xfns.c
index 7bf302594be..345ceebb34b 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -244,7 +244,7 @@ check_x_frame (frame)
 }
 /* Let the user specify an X display with a Lisp object.
-   OBJECT may be nil, a frame or a device id.
+   OBJECT may be nil, a frame or a terminal id.
   nil stands for the selected frame--or, if that is not an X frame,
   the first X display on the list.  */
@@ -267,12 +267,12 @@ check_x_display_info (object)
    }
  else if (INTEGERP (object))
    {
-      struct device *d = get_device (XINT (object), 1);
+      struct terminal *t = get_terminal (XINT (object), 1);
-      if (d->type != output_x_window)
+      if (t->type != output_x_window)
-        error ("Display %d is not an X display", XINT (object));
+        error ("Terminal %d is not an X display", XINT (object));
-      dpyinfo = d->display_info.x;
+      dpyinfo = t->display_info.x;
    }
  else if (STRINGP (object))
    dpyinfo = x_display_info_for_name (object);
@@ -1463,10 +1463,10 @@ x_set_scroll_bar_foreground (f, value, oldval)
  if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
    {
      /* Remove all scroll bars because they have wrong colors.  */
-      if (FRAME_DEVICE (f)->condemn_scroll_bars_hook)
+      if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
-        (*FRAME_DEVICE (f)->condemn_scroll_bars_hook) (f);
+        (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
-      if (FRAME_DEVICE (f)->judge_scroll_bars_hook)
+      if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
-        (*FRAME_DEVICE (f)->judge_scroll_bars_hook) (f);
+        (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
      update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
      redraw_frame (f);
@@ -1512,10 +1512,10 @@ x_set_scroll_bar_background (f, value, oldval)
  if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
    {
      /* Remove all scroll bars because they have wrong colors.  */
-      if (FRAME_DEVICE (f)->condemn_scroll_bars_hook)
+      if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
-        (*FRAME_DEVICE (f)->condemn_scroll_bars_hook) (f);
+        (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
-      if (FRAME_DEVICE (f)->judge_scroll_bars_hook)
+      if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
-        (*FRAME_DEVICE (f)->judge_scroll_bars_hook) (f);
+        (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
      update_face_from_frame_parameter (f, Qscroll_bar_background, value);
      redraw_frame (f);
@@ -3025,14 +3025,14 @@ This function is an internal primitive--use `make-frame' instead.  */)
     until we know if this frame has a specified name.  */
  Vx_resource_name = Vinvocation_name;
-  display = x_get_arg (dpyinfo, parms, Qdevice, 0, 0, RES_TYPE_NUMBER);
+  display = x_get_arg (dpyinfo, parms, Qterminal, 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);
 #ifdef MULTI_KBOARD
-  kb = dpyinfo->device->kboard;
+  kb = dpyinfo->terminal->kboard;
 #else
  kb = &the_only_kboard;
 #endif
@@ -3077,8 +3077,8 @@ This function is an internal primitive--use `make-frame' instead.  */)
  /* Note that X Windows does support scroll bars.  */
  FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
-  f->device = dpyinfo->device;
+  f->terminal = dpyinfo->terminal;
-  f->device->reference_count++;
+  f->terminal->reference_count++;
  f->output_method = output_x_window;
  f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
@@ -3395,7 +3395,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
    }
  /* Initialize `default-minibuffer-frame' in case this is the first
-     frame on this display device.  */
+     frame on this terminal.  */
  if (FRAME_HAS_MINIBUF_P (f)
      && (!FRAMEP (kb->Vdefault_minibuffer_frame)
          || !FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame))))
@@ -3500,10 +3500,10 @@ DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
       doc: /* Internal function called by `display-color-p', which see.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  if (dpyinfo->n_planes <= 2)
    return Qnil;
@@ -3525,13 +3525,13 @@ DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
       0, 1, 0,
       doc: /* Return t if the X display supports shades of gray.
 Note that color displays do support shades of gray.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
-If omitted or nil, that stands for the selected frame's display device.  */)
+If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  if (dpyinfo->n_planes <= 1)
    return Qnil;
@@ -3553,56 +3553,56 @@ If omitted or nil, that stands for the selected frame's display device.  */)
 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
       0, 1, 0,
-       doc: /* Returns the width in pixels of the X display DEVICE.
+       doc: /* Returns the width in pixels of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (dpyinfo->width);
 }
 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
       Sx_display_pixel_height, 0, 1, 0,
-       doc: /* Returns the height in pixels of the X display DEVICE.
+       doc: /* Returns the height in pixels of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (dpyinfo->height);
 }
 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
       0, 1, 0,
-       doc: /* Returns the number of bitplanes of the X display DEVICE.
+       doc: /* Returns the number of bitplanes of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (dpyinfo->n_planes);
 }
 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
       0, 1, 0,
-       doc: /* Returns the number of color cells of the X display DEVICE.
+       doc: /* Returns the number of color cells of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  int nr_planes = DisplayPlanes (dpyinfo->display,
                                 XScreenNumberOfScreen (dpyinfo->screen));
@@ -3620,29 +3620,29 @@ If omitted or nil, that stands for the selected frame's display.  */)
 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
       Sx_server_max_request_size,
       0, 1, 0,
-       doc: /* Returns the maximum request size of the X server of display DEVICE.
+       doc: /* Returns the maximum request size of the X server of display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (MAXREQUEST (dpyinfo->display));
 }
 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
-       doc: /* Returns the "vendor ID" string of the X server of display DEVICE.
+       doc: /* Returns the "vendor ID" string of the X server of display TERMINAL.
 \(Labelling every distributor as a "vendor" embodies the false assumption
 that operating systems cannot be developed and distributed noncommercially.)
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  char *vendor = ServerVendor (dpyinfo->display);
  if (! vendor) vendor = "";
@@ -3650,18 +3650,18 @@ If omitted or nil, that stands for the selected frame's display.  */)
 }
 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
-       doc: /* Returns the version numbers of the X server of display DEVICE.
+       doc: /* Returns the version numbers of the X server of display TERMINAL.
 The value is a list of three integers: the major and minor
 version numbers of the X Protocol in use, and the distributor-specific release
 number.  See also the function `x-server-vendor'.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  Display *dpy = dpyinfo->display;
  return Fcons (make_number (ProtocolVersion (dpy)),
@@ -3670,55 +3670,55 @@ If omitted or nil, that stands for the selected frame's display.  */)
 }
 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
-       doc: /* Return the number of screens on the X server of display DEVICE.
+       doc: /* Return the number of screens on the X server of display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (ScreenCount (dpyinfo->display));
 }
 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
-       doc: /* Return the height in millimeters of the X display DEVICE.
+       doc: /* Return the height in millimeters of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (HeightMMOfScreen (dpyinfo->screen));
 }
 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
-       doc: /* Return the width in millimeters of the X display DEVICE.
+       doc: /* Return the width in millimeters of the X display TERMINAL.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  return make_number (WidthMMOfScreen (dpyinfo->screen));
 }
 DEFUN ("x-display-backing-store", Fx_display_backing_store,
       Sx_display_backing_store, 0, 1, 0,
-       doc: /* Returns an indication of whether X display DEVICE does backing store.
+       doc: /* Returns an indication of whether X display TERMINAL does backing store.
 The value may be `always', `when-mapped', or `not-useful'.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  Lisp_Object result;
  switch (DoesBackingStore (dpyinfo->screen))
@@ -3745,17 +3745,17 @@ If omitted or nil, that stands for the selected frame's display.  */)
 DEFUN ("x-display-visual-class", Fx_display_visual_class,
       Sx_display_visual_class, 0, 1, 0,
-       doc: /* Return the visual class of the X display DEVICE.
+       doc: /* Return the visual class of the X display TERMINAL.
 The value is one of the symbols `static-gray', `gray-scale',
 `static-color', `pseudo-color', `true-color', or `direct-color'.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should a device id, a frame or a display name (a string).
+TERMINAL should a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  Lisp_Object result;
  switch (dpyinfo->visual->class)
@@ -3788,14 +3788,14 @@ If omitted or nil, that stands for the selected frame's display.  */)
 DEFUN ("x-display-save-under", Fx_display_save_under,
       Sx_display_save_under, 0, 1, 0,
-       doc: /* Returns t if the X display DEVICE supports the save-under feature.
+       doc: /* Returns t if the X display TERMINAL supports the save-under feature.
-The optional argument DEVICE specifies which display to ask about.
+The optional argument TERMINAL specifies which display to ask about.
-DEVICE should be a device id, a frame or a display name (a string).
+TERMINAL should be a terminal id, a frame or a display name (a string).
 If omitted or nil, that stands for the selected frame's display.  */)
-     (device)
+     (terminal)
-     Lisp_Object device;
+     Lisp_Object terminal;
 {
-  struct x_display_info *dpyinfo = check_x_display_info (device);
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
  if (DoesSaveUnders (dpyinfo->screen) == True)
    return Qt;
@@ -4075,7 +4075,7 @@ If DISPLAY is nil, that stands for the selected frame's display.  */)
  if (dpyinfo->reference_count > 0)
    error ("Display still has frames on it");
-  x_delete_device (dpyinfo->device);
+  x_delete_terminal (dpyinfo->terminal);
  return Qnil;
 }
@@ -4652,8 +4652,8 @@ x_create_tip_frame (dpyinfo, parms, text)
  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
  record_unwind_protect (unwind_create_tip_frame, frame);
-  f->device = dpyinfo->device;
+  f->terminal = dpyinfo->terminal;
-  f->device->reference_count++;
+  f->terminal->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
diff --git a/src/xselect.c b/src/xselect.c
index 16fb7187474..062336bc050 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1010,7 +1010,7 @@ x_handle_selection_clear (event)
     to see if this Emacs job now owns the selection
     through that display.  */
  for (t_dpyinfo = x_display_list; t_dpyinfo; t_dpyinfo = t_dpyinfo->next)
-    if (t_dpyinfo->device->kboard == dpyinfo->device->kboard)
+    if (t_dpyinfo->terminal->kboard == dpyinfo->terminal->kboard)
      {
        Window owner_window
          = XGetSelectionOwner (t_dpyinfo->display, selection);
diff --git a/src/xterm.c b/src/xterm.c
index 5da3f422f80..b784b560fc4 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -338,15 +338,15 @@ void x_raise_frame P_ ((struct frame *));
 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 device *x_create_device P_ ((struct x_display_info *));
+static struct terminal *x_create_terminal P_ ((struct x_display_info *));
-void x_delete_device P_ ((struct device *));
+void x_delete_terminal P_ ((struct terminal *));
 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_ ((struct device *));
+static void XTset_terminal_modes P_ ((struct terminal *));
-static void XTreset_terminal_modes P_ ((struct device *));
+static void XTreset_terminal_modes P_ ((struct terminal *));
 static void x_clear_frame P_ ((struct frame *));
 static void frame_highlight P_ ((struct frame *));
 static void frame_unhighlight P_ ((struct frame *));
@@ -806,7 +806,7 @@ x_draw_fringe_bitmap (w, row, p)
   rarely happens).  */
 static void
-XTset_terminal_modes (struct device *device)
+XTset_terminal_modes (struct terminal *terminal)
 {
 }
@@ -814,7 +814,7 @@ XTset_terminal_modes (struct device *device)
   the X-windows go away, and suspending requires no action.  */
 static void
-XTreset_terminal_modes (struct device *device)
+XTreset_terminal_modes (struct terminal *terminal)
 {
 }
@@ -5673,7 +5673,7 @@ handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
  int count = 0;
  int do_help = 0;
  int nbytes = 0;
-  struct frame *f;
+  struct frame *f = NULL;
  struct coding_system coding;
  XEvent event = *eventp;
@@ -6923,8 +6923,8 @@ x_dispatch_event (event, display)
   EXPECTED is nonzero if the caller knows input is available.  */
 static int
-XTread_socket (device, expected, hold_quit)
+XTread_socket (terminal, expected, hold_quit)
-     struct device *device;
+     struct terminal *terminal;
     int expected;
     struct input_event *hold_quit;
 {
@@ -6987,7 +6987,7 @@ XTread_socket (device, expected, hold_quit)
 #ifdef HAVE_X_SM
      /* Only check session manager input for the primary display. */
-      if (device->id == 1 && x_session_have_connection ())
+      if (terminal->id == 1 && x_session_have_connection ())
        {
          struct input_event inev;
          BLOCK_INPUT;
@@ -7656,7 +7656,7 @@ x_connection_closed (dpy, error_message)
      /* Protect display from being closed when we delete the last
         frame on it. */
      dpyinfo->reference_count++;
-      dpyinfo->device->reference_count++;
+      dpyinfo->terminal->reference_count++;
    }
  
  /* First delete frames whose mini-buffers are on frames
@@ -7724,7 +7724,7 @@ x_connection_closed (dpy, error_message)
      dpyinfo->display = 0;
      dpyinfo->reference_count--;
-      dpyinfo->device->reference_count--;
+      dpyinfo->terminal->reference_count--;
      if (dpyinfo->reference_count != 0)
        /* We have just closed all frames on this display. */
        abort ();
@@ -7734,7 +7734,7 @@ x_connection_closed (dpy, error_message)
  x_uncatch_errors (dpy, count);
-  if (device_list == 0)
+  if (terminal_list == 0)
    {
      fprintf (stderr, "%s\n", error_msg);
      shut_down_emacs (0, 0, Qnil);
@@ -10121,7 +10121,7 @@ x_term_init (display_name, xrm_option, resource_name)
 {
  int connection;
  Display *dpy;
-  struct device *device;
+  struct terminal *terminal;
  struct x_display_info *dpyinfo;
  XrmDatabase xrdb;
@@ -10268,7 +10268,7 @@ x_term_init (display_name, xrm_option, resource_name)
  dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
  bzero (dpyinfo, sizeof *dpyinfo);
-  device = x_create_device (dpyinfo);
+  terminal = x_create_terminal (dpyinfo);
 #ifdef MULTI_KBOARD
  {
@@ -10281,30 +10281,30 @@ x_term_init (display_name, xrm_option, resource_name)
                         SDATA (display_name)))
        break;
    if (share)
-      device->kboard = share->device->kboard;
+      terminal->kboard = share->terminal->kboard;
    else
      {
-        device->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
+        terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
-        init_kboard (device->kboard);
+        init_kboard (terminal->kboard);
        if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
          {
            char *vendor = ServerVendor (dpy);
            UNBLOCK_INPUT;
-            device->kboard->Vsystem_key_alist
+            terminal->kboard->Vsystem_key_alist
              = call1 (Qvendor_specific_keysyms,
                       build_string (vendor ? vendor : ""));
            BLOCK_INPUT;
          }
-        device->kboard->next_kboard = all_kboards;
+        terminal->kboard->next_kboard = all_kboards;
-        all_kboards = device->kboard;
+        all_kboards = terminal->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 = device->kboard;
+          current_kboard = terminal->kboard;
      }
-    device->kboard->reference_count++;
+    terminal->kboard->reference_count++;
  }
 #endif
@@ -10319,10 +10319,10 @@ x_term_init (display_name, xrm_option, resource_name)
  dpyinfo->display = dpy;
-  /* Set the name of the device. */
+  /* Set the name of the terminal. */
-  device->name = (char *) xmalloc (SBYTES (display_name) + 1);
+  terminal->name = (char *) xmalloc (SBYTES (display_name) + 1);
-  strncpy (device->name, SDATA (display_name), SBYTES (display_name));
+  strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
-  device->name[SBYTES (display_name)] = 0;
+  terminal->name[SBYTES (display_name)] = 0;
  
 #if 0
  XSetAfterFunction (x_current_display, x_trace_wire);
@@ -10614,7 +10614,7 @@ x_term_init (display_name, xrm_option, resource_name)
  /* Only do this for the very first display in the Emacs session.
     Ignore X session management when Emacs was first started on a
     tty.  */
-  if (device->id == 1)
+  if (terminal->id == 1)
    x_session_initialize (dpyinfo);
 #endif
@@ -10631,17 +10631,17 @@ x_delete_display (dpyinfo)
     struct x_display_info *dpyinfo;
 {
  int i;
-  struct device *d;
+  struct terminal *t;
-  /* Delete the generic struct device for this X display. */
+  /* Delete the generic struct terminal for this X display. */
-  for (d = device_list; d; d = d->next_device)
+  for (t = terminal_list; t; t = t->next_terminal)
-    if (d->type == output_x_window && d->display_info.x == dpyinfo)
+    if (t->type == output_x_window && t->display_info.x == dpyinfo)
      {
        /* Close X session management when we close its display. */
-        if (d->id == 1 && x_session_have_connection ())
+        if (t->id == 1 && x_session_have_connection ())
          x_session_close();
-        delete_device (d);
+        delete_terminal (t);
        break;
      }
@@ -10776,9 +10776,9 @@ static struct redisplay_interface x_redisplay_interface =
 /* This function is called when the last frame on a display is deleted. */
 void
-x_delete_device (struct device *device)
+x_delete_terminal (struct terminal *terminal)
 {
-  struct x_display_info *dpyinfo = device->display_info.x;
+  struct x_display_info *dpyinfo = terminal->display_info.x;
  int i;
  BLOCK_INPUT;
@@ -10807,50 +10807,50 @@ x_delete_device (struct device *device)
 }
-struct device *
+static struct terminal *
-x_create_device (struct x_display_info *dpyinfo)
+x_create_terminal (struct x_display_info *dpyinfo)
 {
-  struct device *device;
+  struct terminal *terminal;
  
-  device = create_device ();
+  terminal = create_terminal ();
-  device->type = output_x_window;
+  terminal->type = output_x_window;
-  device->display_info.x = dpyinfo;
+  terminal->display_info.x = dpyinfo;
-  dpyinfo->device = device;
+  dpyinfo->terminal = terminal;
  /* kboard is initialized in x_term_init. */
  
-  device->clear_frame_hook = x_clear_frame;
+  terminal->clear_frame_hook = x_clear_frame;
-  device->ins_del_lines_hook = x_ins_del_lines;
+  terminal->ins_del_lines_hook = x_ins_del_lines;
-  device->delete_glyphs_hook = x_delete_glyphs;
+  terminal->delete_glyphs_hook = x_delete_glyphs;
-  device->ring_bell_hook = XTring_bell;
+  terminal->ring_bell_hook = XTring_bell;
-  device->reset_terminal_modes_hook = XTreset_terminal_modes;
+  terminal->reset_terminal_modes_hook = XTreset_terminal_modes;
-  device->set_terminal_modes_hook = XTset_terminal_modes;
+  terminal->set_terminal_modes_hook = XTset_terminal_modes;
-  device->update_begin_hook = x_update_begin;
+  terminal->update_begin_hook = x_update_begin;
-  device->update_end_hook = x_update_end;
+  terminal->update_end_hook = x_update_end;
-  device->set_terminal_window_hook = XTset_terminal_window;
+  terminal->set_terminal_window_hook = XTset_terminal_window;
-  device->read_socket_hook = XTread_socket;
+  terminal->read_socket_hook = XTread_socket;
-  device->frame_up_to_date_hook = XTframe_up_to_date;
+  terminal->frame_up_to_date_hook = XTframe_up_to_date;
-  device->mouse_position_hook = XTmouse_position;
+  terminal->mouse_position_hook = XTmouse_position;
-  device->frame_rehighlight_hook = XTframe_rehighlight;
+  terminal->frame_rehighlight_hook = XTframe_rehighlight;
-  device->frame_raise_lower_hook = XTframe_raise_lower;
+  terminal->frame_raise_lower_hook = XTframe_raise_lower;
-  device->set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
+  terminal->set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
-  device->condemn_scroll_bars_hook = XTcondemn_scroll_bars;
+  terminal->condemn_scroll_bars_hook = XTcondemn_scroll_bars;
-  device->redeem_scroll_bar_hook = XTredeem_scroll_bar;
+  terminal->redeem_scroll_bar_hook = XTredeem_scroll_bar;
-  device->judge_scroll_bars_hook = XTjudge_scroll_bars;
+  terminal->judge_scroll_bars_hook = XTjudge_scroll_bars;
-  device->delete_frame_hook = x_destroy_window;
+  terminal->delete_frame_hook = x_destroy_window;
-  device->delete_device_hook = x_delete_device;
+  terminal->delete_terminal_hook = x_delete_terminal;
  
-  device->rif = &x_redisplay_interface;
+  terminal->rif = &x_redisplay_interface;
-  device->scroll_region_ok = 1;    /* We'll scroll partial frames. */
+  terminal->scroll_region_ok = 1;    /* We'll scroll partial frames. */
-  device->char_ins_del_ok = 1;
+  terminal->char_ins_del_ok = 1;
-  device->line_ins_del_ok = 1;         /* We'll just blt 'em. */
+  terminal->line_ins_del_ok = 1;         /* We'll just blt 'em. */
-  device->fast_clear_end_of_line = 1;  /* X does this well. */
+  terminal->fast_clear_end_of_line = 1;  /* X does this well. */
-  device->memory_below_frame = 0;   /* We don't remember what scrolls
+  terminal->memory_below_frame = 0;   /* We don't remember what scrolls
                                        off the bottom. */
-  return device;
+  return terminal;
 }
 void
diff --git a/src/xterm.h b/src/xterm.h
index b0464b6cbfa..dfb79d9d90f 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -388,7 +388,7 @@ struct x_display_info
    } wm_type;
  /* The generic display parameters corresponding to this X display. */
-  struct device *device;
+  struct terminal *terminal;
 };
 #ifdef HAVE_X_I18N
@@ -995,7 +995,7 @@ extern void x_wm_set_size_hint P_ ((struct frame *, long, int));
 extern void x_wm_set_window_state P_ ((struct frame *, int));
 extern void x_wm_set_icon_pixmap P_ ((struct frame *, int));
 extern void x_delete_display P_ ((struct x_display_info *));
-extern void x_delete_device P_ ((struct device *device));
+extern void x_delete_terminal P_ ((struct terminal *terminal));
 extern void x_initialize P_ ((void));
 extern unsigned long x_copy_color P_ ((struct frame *, unsigned long));
 #ifdef USE_X_TOOLKIT