Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-78

Merge from emacs--cvs-trunk--0

Patches applied:

 * emacs--cvs-trunk--0  (patch 514-518)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 104-105)

   - Update from CVS

17 files changed, 299 insertions, 303 deletions

diff --git a/lisp/progmodes/ada-prj.el b/lisp/progmodes/ada-prj.el
index d9bfb891ee3..91adf1ed187 100644
--- a/lisp/progmodes/ada-prj.el
+++ b/lisp/progmodes/ada-prj.el
@@ -477,7 +477,8 @@ connect to the target when working with cross-environments" t)
   (widget-insert "\n\n")
 
   (widget-setup)
-  (beginning-of-buffer)
+  (with-no-warnings
+    (beginning-of-buffer))
   )
 
 
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index d9f0d088319..71dc39a56e9 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -5599,6 +5599,7 @@ brace."
                          containing-sexp paren-state))
      )))
 
+;;;###autoload
 (defun c-guess-basic-syntax ()
   "Return the syntactic context of the current line.
 This function does not do any hidden buffer changes."
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index fa9eac2e021..dff4de60e45 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -377,13 +377,16 @@ you may also want to change `compilation-page-delimiter'.")
    '(;; configure output lines.
      ("^[Cc]hecking \\(?:[Ff]or \\|[Ii]f \\|[Ww]hether \\(?:to \\)?\\)?\\(.+\\)\\.\\.\\. *\\(?:(cached) *\\)?\\(\\(yes\\(?: .+\\)?\\)\\|no\\|\\(.*\\)\\)$"
       (1 font-lock-variable-name-face)
-      (2 font-lock-keyword-face))
+      (2 (compilation-face '(4 . 3))))
      ;; Command output lines.  Recognize `make[n]:' lines too.
      ("^\\([[:alnum:]_/.+-]+\\)\\(\\[\\([0-9]+\\)\\]\\)?[ \t]*:"
       (1 font-lock-function-name-face) (3 compilation-line-face nil t))
      (" --?o\\(?:utfile\\|utput\\)?[= ]?\\(\\S +\\)" . 1)
-     ("^Compilation finished" . font-lock-keyword-face)
-     ("^Compilation exited abnormally" . font-lock-keyword-face))
+     ("^Compilation \\(finished\\)"
+      (1 compilation-info-face))
+     ("^Compilation \\(exited abnormally\\|interrupt\\|killed\\|terminated\\)\\(?:.*with code \\([0-9]+\\)\\)?"
+      (1 compilation-error-face)
+      (2 compilation-error-face nil t)))
    "Additional things to highlight in Compilation mode.
 This gets tacked on the end of the generated expressions.")
 
@@ -443,6 +446,14 @@ You might also use mode hooks to specify it in certain modes, like this:
   :type 'string
   :group 'compilation)
 
+(defcustom compilation-disable-input nil
+  "*If non-nil, send end-of-file as compilation process input.
+This only affects platforms that support asynchronous processes (see
+`start-process'); synchronous compilation processes never accept input."
+  :type 'boolean
+  :group 'compilation
+  :version "22.1")
+
 ;; A weak per-compilation-buffer hash indexed by (FILENAME . DIRECTORY).  Each
 ;; value is a FILE-STRUCTURE as described above, with the car eq to the hash
 ;; key.  This holds the tree seen from root, for storing new nodes.
@@ -468,6 +479,12 @@ starting the compilation process.")
 ;; History of compile commands.
 (defvar compile-history nil)
 
+(defface compilation-error
+  '((t :inherit font-lock-warning-face))
+  "Face used to highlight compiler errors."
+  :group 'font-lock-highlighting-faces
+  :version "22.1")
+
 (defface compilation-warning
   '((((class color) (min-colors 16)) (:foreground "Orange" :weight bold))
     (((class color)) (:foreground "cyan" :weight bold))
@@ -475,8 +492,6 @@ starting the compilation process.")
   "Face used to highlight compiler warnings."
   :group 'font-lock-highlighting-faces
   :version "22.1")
-;; backward-compatibility alias
-(put 'compilation-warning-face 'face-alias 'compilation-warning)
 
 (defface compilation-info
   '((((class color) (min-colors 16) (background light))
@@ -487,74 +502,49 @@ starting the compilation process.")
      (:foreground "Green" :weight bold))
     (((class color)) (:foreground "green" :weight bold))
     (t (:weight bold)))
-  "Face used to highlight compiler warnings."
-  :group 'font-lock-highlighting-faces
-  :version "22.1")
-;; backward-compatibility alias
-(put 'compilation-info-face 'face-alias 'compilation-info)
-
-(defface compilation-error-file-name
-  '((default :inherit font-lock-warning-face)
-    (((supports :underline t)) :underline t))
-  "Face for displaying file names in compilation errors."
-  :group 'font-lock-highlighting-faces
-  :version "22.1")
-
-(defface compilation-warning-file-name
-  '((default :inherit font-lock-warning-face)
-    (((supports :underline t)) :underline t))
-  "Face for displaying file names in compilation errors."
-  :group 'font-lock-highlighting-faces
-  :version "22.1")
-
-(defface compilation-info-file-name
-  '((default :inherit compilation-info)
-    (((supports :underline t)) :underline t))
-  "Face for displaying file names in compilation errors."
+  "Face used to highlight compiler information."
   :group 'font-lock-highlighting-faces
   :version "22.1")
 
 (defface compilation-line-number
-  '((default :inherit font-lock-variable-name-face)
-    (((supports :underline t)) :underline t))
-  "Face for displaying file names in compilation errors."
+  '((t :inherit font-lock-variable-name-face))
+  "Face for displaying line numbers in compiler messages."
   :group 'font-lock-highlighting-faces
   :version "22.1")
 
 (defface compilation-column-number
-  '((default :inherit font-lock-type-face)
-    (((supports :underline t)) :underline t))
-  "Face for displaying file names in compilation errors."
+  '((t :inherit font-lock-type-face))
+  "Face for displaying column numbers in compiler messages."
   :group 'font-lock-highlighting-faces
   :version "22.1")
 
-(defvar compilation-message-face nil
+(defvar compilation-message-face 'underline
   "Face name to use for whole messages.
 Faces `compilation-error-face', `compilation-warning-face',
 `compilation-info-face', `compilation-line-face' and
 `compilation-column-face' get prepended to this, when applicable.")
 
-(defvar compilation-error-face 'compilation-error-file-name
+(defvar compilation-error-face 'compilation-error
   "Face name to use for file name in error messages.")
 
-(defvar compilation-warning-face 'compilation-warning-file-name
+(defvar compilation-warning-face 'compilation-warning
   "Face name to use for file name in warning messages.")
 
-(defvar compilation-info-face 'compilation-info-file-name
+(defvar compilation-info-face 'compilation-info
   "Face name to use for file name in informational messages.")
 
 (defvar compilation-line-face 'compilation-line-number
-  "Face name to use for line number in message.")
+  "Face name to use for line numbers in compiler messages.")
 
 (defvar compilation-column-face 'compilation-column-number
-  "Face name to use for column number in message.")
+  "Face name to use for column numbers in compiler messages.")
 
 ;; same faces as dired uses
 (defvar compilation-enter-directory-face 'font-lock-function-name-face
-  "Face name to use for column number in message.")
+  "Face name to use for entering directory messages.")
 
 (defvar compilation-leave-directory-face 'font-lock-type-face
-  "Face name to use for column number in message.")
+  "Face name to use for leaving directory messages.")
 
 
 
@@ -987,7 +977,11 @@ Returns the compilation buffer created."
         ;; Output a mode setter, for saving and later reloading this buffer.
         (insert "-*- mode: " name-of-mode
                 "; default-directory: " (prin1-to-string default-directory)
-                " -*-\n" command "\n")
+                " -*-\n"
+                (format "%s started at %s\n\n"
+                        mode-name
+                        (substring (current-time-string) 0 19))
+                command "\n")
         (setq thisdir default-directory))
       (set-buffer-modified-p nil))
     ;; If we're already in the compilation buffer, go to the end
@@ -1036,6 +1030,8 @@ Returns the compilation buffer created."
                                                        outbuf command))))
               ;; Make the buffer's mode line show process state.
               (setq mode-line-process '(":%s"))
+              (when compilation-disable-input
+                (process-send-eof proc))
               (set-process-sentinel proc 'compilation-sentinel)
               (set-process-filter proc 'compilation-filter)
               (set-marker (process-mark proc) (point) outbuf)
@@ -1173,7 +1169,7 @@ exited abnormally with code %d\n"
     (define-key map [menu-bar compilation compilation-separator2]
       '("----" . nil))
     (define-key map [menu-bar compilation compilation-grep]
-      '("Search Files (grep)" . grep))
+      '("Search Files (grep)..." . grep))
     (define-key map [menu-bar compilation compilation-recompile]
       '("Recompile" . recompile))
     (define-key map [menu-bar compilation compilation-compile]
@@ -1232,9 +1228,9 @@ Runs `compilation-mode-hook' with `run-mode-hooks' (which see).
 (defmacro define-compilation-mode (mode name doc &rest body)
   "This is like `define-derived-mode' without the PARENT argument.
 The parent is always `compilation-mode' and the customizable `compilation-...'
-variables are also set from the name of the mode you have chosen, by replacing
-the fist word, e.g `compilation-scroll-output' from `grep-scroll-output' if that
-variable exists."
+variables are also set from the name of the mode you have chosen,
+by replacing the first word, e.g `compilation-scroll-output' from
+`grep-scroll-output' if that variable exists."
   (let ((mode-name (replace-regexp-in-string "-mode\\'" "" (symbol-name mode))))
     `(define-derived-mode ,mode compilation-mode ,name
        ,doc
@@ -1513,7 +1509,7 @@ Prefix arg N says how many files to move backwards (or forwards, if negative)."
   (let ((buffer (compilation-find-buffer)))
     (if (get-buffer-process buffer)
         (interrupt-process (get-buffer-process buffer))
-      (error "The compilation process is not running"))))
+      (error "The %s process is not running" (downcase mode-name)))))
 
 (defalias 'compile-mouse-goto-error 'compile-goto-error)
 
@@ -1758,8 +1754,8 @@ Pop up the buffer containing MARKER and scroll to MARKER if we ask the user."
                                     marker)
             (let ((name (expand-file-name
                          (read-file-name
-                          (format "Find this error in: (default %s) "
-                                  filename)
+                          (format "Find this %s in: (default %s) "
+                                  compilation-error filename)
                           dir filename t))))
               (if (file-directory-p name)
                   (setq name (expand-file-name filename name)))
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index a698ee6322f..8854d57915c 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -858,16 +858,12 @@ Return t if it has at least one flymake overlay, nil if no overlay."
     (t (:bold t)))
   "Face used for marking error lines."
   :group 'flymake)
-;; backward-compatibility alias
-(put 'flymake-errline-face 'face-alias 'flymake-errline)
 
 (defface flymake-warnline
   '((((class color)) (:background "LightBlue2"))
     (t (:bold t)))
   "Face used for marking warning lines."
   :group 'flymake)
-;; backward-compatibility alias
-(put 'flymake-warnline-face 'face-alias 'flymake-warnline)
 
 (defun flymake-highlight-line (line-no line-err-info-list)
   "Highlight line LINE-NO in current buffer.
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index 42e415c5799..a1c6f0a80b0 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -58,7 +58,7 @@
 ;; using a macro:
 ;;
 ;;           #ifdef UNBUFFERED
-;;           setvbuf(stdout,(char *)NULL, _IONBF,0);
+;;           setvbuf (stdout, (char *) NULL, _IONBF, 0);
 ;;           #endif
 ;;
 ;; and compiling with -DUNBUFFERED while debugging.
@@ -1307,8 +1307,6 @@ static char *magick[] = {
     (((background light)) :foreground "grey40"))
   "Face for disabled breakpoint icon in fringe."
   :group 'gud)
-;; Compatibility alias for old name.
-(put 'breakpoint-disabled-bitmap-face 'face-alias 'breakpoint-disabled)
 
 ;; Put breakpoint icons in relevant margins (even those set in the GUD buffer).
 (defun gdb-info-breakpoints-custom ()
@@ -2192,6 +2190,7 @@ corresponding to the mode line clicked."
   (define-key gud-menu-map [ui]
     `(menu-item "GDB-UI" ,menu :visible (eq gud-minor-mode 'gdba)))
   (define-key menu [gdb-use-inferior-io]
+    ;; See defadvice below.
     (menu-bar-make-toggle toggle-gdb-use-inferior-io-buffer
                           gdb-use-inferior-io-buffer
      "Separate inferior IO" "Use separate IO %s"
@@ -2204,6 +2203,7 @@ corresponding to the mode line clicked."
   '(menu-item "Restore Window Layout" gdb-restore-windows
               :help "Restore standard layout for debug session.")))
 
+;; This function is defined above through a macro.
 (defadvice toggle-gdb-use-inferior-io-buffer (after gdb-kill-io-buffer activate)
   (unless gdb-use-inferior-io-buffer
     (kill-buffer (gdb-inferior-io-name))))
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 4378a7c253d..6dc5fcabd41 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -206,7 +206,7 @@ See `compilation-error-screen-columns'"
     (define-key map [menu-bar grep compilation-compile]
       '("Compile..." . compile))
     (define-key map [menu-bar grep compilation-grep]
-      '("Another grep" . grep))
+      '("Another grep..." . grep))
     (define-key map [menu-bar grep compilation-recompile]
       '("Repeat grep" . recompile))
     (define-key map [menu-bar grep compilation-separator2]
@@ -244,11 +244,11 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
 
 ;;;###autoload
 (defvar grep-regexp-alist
-  '(("^\\([^:\n]+\\)\\(:[ \t]*\\)\\([0-9]+\\)\\2"
+  '(("^\\(.+?\\)\\(:[ \t]*\\)\\([0-9]+\\)\\2"
      1 3)
     ;; Rule to match column numbers is commented out since no known grep
     ;; produces them
-    ;; ("^\\([^:\n]+\\)\\(:[ \t]*\\)\\([0-9]+\\)\\2\\(?:\\([0-9]+\\)\\(?:-\\([0-9]+\\)\\)?\\2\\)?"
+    ;; ("^\\(.+?\\)\\(:[ \t]*\\)\\([0-9]+\\)\\2\\(?:\\([0-9]+\\)\\(?:-\\([0-9]+\\)\\)?\\2\\)?"
     ;;  1 3 (4 . 5))
     ("^\\(\\(.+?\\):\\([0-9]+\\):\\).*?\
 \\(\033\\[01;31m\\(?:\033\\[K\\)?\\)\\(.*?\\)\\(\033\\[[0-9]*m\\)"
@@ -261,7 +261,7 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
       (lambda () (- (match-end 5) (match-end 1)
                     (- (match-end 4) (match-beginning 4)))))
      nil 1)
-    ("^Binary file \\(.+\\) matches$" 1 nil nil 1 1))
+    ("^Binary file \\(.+\\) matches$" 1 nil nil 0 1))
   "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")
 
 (defvar grep-error "grep hit"
@@ -272,8 +272,7 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
 (defvar grep-hit-face   compilation-info-face
   "Face name to use for grep hits.")
 
-;; compilation-error-face is wrong for this; it's designed to look like a link.
-(defvar grep-error-face font-lock-keyword-face
+(defvar grep-error-face 'compilation-error
   "Face name to use for grep error messages.")
 
 (defvar grep-match-face 'match
@@ -288,15 +287,17 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
      (": \\(.+\\): \\(?:Permission denied\\|No such \\(?:file or directory\\|device or address\\)\\)$"
       1 grep-error-face)
      ;; remove match from grep-regexp-alist before fontifying
+     ("^Grep started.*"
+      (0 '(face nil message nil help-echo nil mouse-face nil) t))
      ("^Grep finished \\(?:(\\(matches found\\))\\|with \\(no matches found\\)\\).*"
       (0 '(face nil message nil help-echo nil mouse-face nil) t)
-      (1 font-lock-keyword-face nil t)
-      (2 font-lock-keyword-face nil t))
-     ("^Grep \\(exited abnormally\\) with code \\([0-9]+\\).*"
+      (1 compilation-info-face nil t)
+      (2 compilation-warning-face nil t))
+     ("^Grep \\(exited abnormally\\|interrupt\\|killed\\|terminated\\)\\(?:.*with code \\([0-9]+\\)\\)?.*"
       (0 '(face nil message nil help-echo nil mouse-face nil) t)
       (1 grep-error-face)
-      (2 grep-error-face))
-     ("^[^\n-]+-[0-9]+-.*" (0 grep-context-face))
+      (2 grep-error-face nil t))
+     ("^.+?-[0-9]+-.*\n" (0 grep-context-face))
      ;; Highlight grep matches and delete markers
      ("\\(\033\\[01;31m\\)\\(.*?\\)\\(\033\\[[0-9]*m\\)"
       ;; Refontification does not work after the markers have been
@@ -517,11 +518,10 @@ temporarily highlight in visited source lines."
 
   ;; Setting process-setup-function makes exit-message-function work
   ;; even when async processes aren't supported.
-  (let ((compilation-process-setup-function 'grep-process-setup))
-    (compilation-start (if (and grep-use-null-device null-device)
-                           (concat command-args " " null-device)
-                         command-args)
-                       'grep-mode nil highlight-regexp)))
+  (compilation-start (if (and grep-use-null-device null-device)
+                         (concat command-args " " null-device)
+                       command-args)
+                     'grep-mode nil highlight-regexp))
 
 ;;;###autoload
 (define-compilation-mode grep-mode "Grep"
@@ -531,6 +531,9 @@ temporarily highlight in visited source lines."
        grep-hit-face)
   (set (make-local-variable 'compilation-error-regexp-alist)
        grep-regexp-alist)
+  (set (make-local-variable 'compilation-process-setup-function)
+       'grep-process-setup)
+  (set (make-local-variable 'compilation-disable-input) t)
   ;; Set `font-lock-lines-before' to 0 to not refontify the previous
   ;; line where grep markers may be already removed.
   (set (make-local-variable 'font-lock-lines-before) 0))
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 22b0b7b36d6..0577e2a2bb7 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -586,7 +586,9 @@ and source-file directory for your debugger."
   (gud-def gud-nexti  "nexti %p"      nil   "Step one instruction (skip functions).")
   (gud-def gud-cont   "cont"         "\C-r" "Continue with display.")
   (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
-  (gud-def gud-jump   "tbreak %f:%l\njump %f:%l" "\C-j" "Relocate execution address to line at point in source buffer.")
+  (gud-def gud-jump
+           (progn (gud-call "tbreak %f:%l") (gud-call "jump %f:%l"))
+           "\C-j" "Set execution address to current line.")
 
   (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
   (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
@@ -2596,7 +2598,7 @@ It is saved for when this flag is not set.")
 (defun gud-kill-buffer-hook ()
   (setq gud-minor-mode-type gud-minor-mode)
   (condition-case nil
-      (kill-process (get-buffer-process gud-comint-buffer))
+      (kill-process (get-buffer-process (current-buffer)))
     (error nil)))
 
 (defun gud-reset ()
diff --git a/lisp/progmodes/idlw-help.el b/lisp/progmodes/idlw-help.el
index 6dbbca4c5b1..8c43831ebac 100644
--- a/lisp/progmodes/idlw-help.el
+++ b/lisp/progmodes/idlw-help.el
@@ -193,8 +193,6 @@ support."
     (t (:weight bold)))
   "Face for highlighting links into IDLWAVE online help."
   :group 'idlwave-online-help)
-;; backward-compatibility alias
-(put 'idlwave-help-link-face 'face-alias 'idlwave-help-link)
 
 (defvar idlwave-help-activate-links-aggressively nil
   "Obsolete variable.")
diff --git a/lisp/progmodes/idlw-rinfo.el b/lisp/progmodes/idlw-rinfo.el
index 962292b740a..367de774bcf 100644
--- a/lisp/progmodes/idlw-rinfo.el
+++ b/lisp/progmodes/idlw-rinfo.el
@@ -1899,7 +1899,7 @@
    )
   "1850 builtin routines with 7685 keywords for IDL version 6.1.")
 
-(setq idlwave-system-variables-alist
+(defvar idlwave-system-variables-alist
   '(
     ("C" (link "sysvars7.html#wp997337"))
     ("CPU" (tags ("HW_VECTOR") ("VECTOR_ENABLE") ("HW_NCPU") ("TPOOL_NTHREADS") ("TPOOL_MIN_ELTS") ("TPOOL_MAX_ELTS")) (link "sysvars6.html#wp1014201"))
@@ -1932,7 +1932,7 @@
     ("Z" (tags ("TITLE" . 997839) ("TYPE" . 997842) ("STYLE" . 997742) ("TICKS" . 999577) ("TICKLEN" . 1012793) ("THICK" . 997798) ("RANGE" . 997713) ("CRANGE" . 997670) ("S" . 997736) ("MARGIN" . 997689) ("OMARGIN" . 997702) ("WINDOW" . 997845) ("REGION" . 997724) ("CHARSIZE" . 1012787) ("MINOR" . 997699) ("TICKV" . 997833) ("TICKNAME" . 997811) ("GRIDSTYLE" . 998134) ("TICKFORMAT" . 997801) ("TICKINTERVAL" . 997808) ("TICKLAYOUT" . 1012924) ("TICKUNITS" . 1012962)) (link "sysvars7.html#wp997657"))))
 
 
-(setq idlwave-system-class-info
+(defvar idlwave-system-class-info
   '(
     ("IDLgrContour" (tags "IDLGRCOMPONENT_TOP" "IDLGRCOMPONENTVERSION" "HIDE" "PARENT" "IDLGRCOMPONENT_BOTTOM" "IDLGRGRAPHIC_TOP" "IDLGRGRAPHICVERSION" "ALPHACHANNEL" "CLIP_PLANES" "COLOR" "DEPTH_TEST_DISABLE" "DEPTH_TEST_FUNCTION" "DEPTH_WRITE_DISABLE" "GRAPHICFLAGS" "PALETTE" "XCOORD_CONV" "YCOORD_CONV" "ZCOORD_CONV" "XRANGE" "YRANGE" "ZRANGE" "GRAPHIC_DATA_OBJECT" "IDLGRGRAPHIC_BOTTOM" "IDLGRCONTOUR_TOP" "IDLGRCONTOURVERSION" "AM_PM" "ANISOTROPY" "DATA_FORMAT" "DATA" "DAYS_OF_WEEK" "GEOM_FORMAT" "GEOM" "CONTOURFLAGS" "C_COLOR" "C_FILLPATTERN" "C_LABEL_INTERVAL" "C_LABEL_NOGAPS" "C_LABEL_OBJECTS" "C_LABEL_SHOW" "C_LINESTYLE" "C_THICK" "C_USE_LABEL_COLOR" "C_USE_LABEL_ORIENTATION" "C_VALUE" "LABEL_DEFAULTS" "LABEL_FONT" "LABEL_FORMAT" "LABEL_FRMTDATA" "LABEL_UNITS" "LABEL_UNIT_CODE" "MAXVAL" "MINVAL" "MONTHS" "NLEVELS" "POLYGONS" "SHADERANGE" "SHADING" "TICKINTERVAL" "TICKLEN" "PRECISIONDATA" "PRECISIONGEOM" "PRECISIONGRAPH" "LEVELINFO" "CFILL1" "DEPTHOFFSET" "MAPINFO" "IDLGRCONTOUR_BOTTOM") (inherits "IDLitComponent") (link "objects_gr43.html"))
     ("IDLgrAxis" (tags "IDLGRCOMPONENT_TOP" "IDLGRCOMPONENTVERSION" "HIDE" "PARENT" "IDLGRCOMPONENT_BOTTOM" "IDLGRGRAPHIC_TOP" "IDLGRGRAPHICVERSION" "ALPHACHANNEL" "CLIP_PLANES" "COLOR" "DEPTH_TEST_DISABLE" "DEPTH_TEST_FUNCTION" "DEPTH_WRITE_DISABLE" "GRAPHICFLAGS" "PALETTE" "XCOORD_CONV" "YCOORD_CONV" "ZCOORD_CONV" "XRANGE" "YRANGE" "ZRANGE" "GRAPHIC_DATA_OBJECT" "IDLGRGRAPHIC_BOTTOM" "IDLGRAXIS_TOP" "IDLGRAXISVERSION" "AM_PM" "AXIS_TYPE" "CALCFLAGS" "DAYS_OF_WEEK" "DIRECTION" "AXISFLAGS" "GRIDSTYLE" "LOCATION" "MAJOR" "MINOR" "MONTHS" "OUTRANGE" "RANGE" "SUBTICKLEN" "TEXTALIGNMENTS" "TEXTBASELINE" "TEXTUPDIR" "THICK" "TICKDIR" "TICKFORMAT" "ARRAY_TICKFORMAT" "TICKFRMTDATA" "TICKINTERVAL" "TICKLAYOUT" "TICKLEN" "TICKTEXT" "TICKUNITCODES" "TICKUNITS" "TICKVALUES" "TITLE" "CURRENT_LEVEL" "LEVEL_DATA" "STEPRANGEUNITS" "STEPRANGE" "IDLGRAXIS_BOTTOM") (inherits "IDLitComponent") (link "objects_gr3.html"))
@@ -2014,7 +2014,7 @@
     ("IDLjavaObject" (link "objects_misc28.html"))))
 
 
-(setq idlwave-executive-commands-alist '(
+(defvar idlwave-executive-commands-alist '(
     ("RESET_SESSION" . "symbols8.html")
     ("TRACE" . "symbols15.html")
     ("RNEW" . "symbols10.html")
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index 7c1324c94af..cc706195cc2 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -533,9 +533,7 @@ lines which have a breakpoint.  See also `idlwave-shell-mark-breakpoints'."
     '((((class color)) (:foreground "Black" :background "Pink"))
       (t (:underline t)))
     "Face for highlighting lines with breakpoints."
-    :group 'idlwave-shell-highlighting-and-faces)
-  ;; backward-compatibility alias
-  (put 'idlwave-shell-bp-face 'face-alias 'idlwave-shell-bp))
+    :group 'idlwave-shell-highlighting-and-faces))
 
 (defcustom idlwave-shell-disabled-breakpoint-face 
   'idlwave-shell-disabled-bp
@@ -553,10 +551,7 @@ lines which have a breakpoint.  See also `idlwave-shell-mark-breakpoints'."
     '((((class color)) (:foreground "Black" :background "gray"))
       (t (:underline t)))
     "Face for highlighting lines with breakpoints."
-    :group 'idlwave-shell-highlighting-and-faces)
-  ;; backward-compatibility alias
-  (put 'idlwave-shell-disabled-bp-face 'face-alias 'idlwave-shell-disabled-bp))
-
+    :group 'idlwave-shell-highlighting-and-faces))
 
 (defcustom idlwave-shell-expression-face 'secondary-selection
   "*The face for `idlwave-shell-expression-overlay'.
@@ -2761,13 +2756,14 @@ Runs to the last statement and then steps 1 statement.  Use the .out command."
   t)
 
 (defun idlwave-xemacs-hack-mouse-track (event)
-  (let ((oldfunc (symbol-function 'default-mouse-track-event-is-with-button)))
-    (unwind-protect
-        (progn
-          (fset 'default-mouse-track-event-is-with-button 
-                'idlwave-default-mouse-track-event-is-with-button)
-          (mouse-track event))
-      (fset 'default-mouse-track-event-is-with-button oldfunc))))
+  (if (featurep 'xemacs) 
+      (let ((oldfunc (symbol-function 'default-mouse-track-event-is-with-button)))
+        (unwind-protect
+            (progn
+              (fset 'default-mouse-track-event-is-with-button 
+                    'idlwave-default-mouse-track-event-is-with-button)
+              (mouse-track event))
+          (fset 'default-mouse-track-event-is-with-button oldfunc)))))
 ;;; End terrible hack section
 
 (defun idlwave-shell-mouse-print (event)
diff --git a/lisp/progmodes/idlw-toolbar.el b/lisp/progmodes/idlw-toolbar.el
index 9592acb607d..08dd08335bb 100644
--- a/lisp/progmodes/idlw-toolbar.el
+++ b/lisp/progmodes/idlw-toolbar.el
@@ -44,6 +44,9 @@
     (list 'image :type 'xpm :data image)))
 
 (defvar default-toolbar)
+(defvar idlwave-toolbar)
+(defvar idlwave-toolbar-is-possible)
+
 (if (not (or (and (featurep 'xemacs)                ; This is XEmacs
                   (featurep 'xpm)                   ; need xpm
                   (featurep 'toolbar))              ; ... and the toolbar
diff --git a/lisp/progmodes/ld-script.el b/lisp/progmodes/ld-script.el
index 8b378b7f0ab..a2449b6817e 100644
--- a/lisp/progmodes/ld-script.el
+++ b/lisp/progmodes/ld-script.el
@@ -39,8 +39,6 @@
   '((t (:weight bold :inherit font-lock-builtin-face)))
   "Face for location counter in GNU ld script."
   :group 'ld-script)
-;; backward-compatibility alias
-(put 'ld-script-location-counter-face 'face-alias 'ld-script-location-counter)
 
 ;; Syntax rules
 (defvar ld-script-mode-syntax-table
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index f7f96130f39..aeb09927535 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -815,7 +815,7 @@ See `sh-feature'.")
   :group 'sh-script
   :version "22.1")
 
-(defvar sh-font-lock-keywords
+(defvar sh-font-lock-keywords-var
   '((csh sh-append shell
          ("\\${?[#?]?\\([A-Za-z_][A-Za-z0-9_]*\\|0\\)" 1
           font-lock-variable-name-face))
@@ -838,7 +838,7 @@ See `sh-feature'.")
          1 font-lock-negation-char-face))
 
     ;; The next entry is only used for defining the others
-    (shell sh-append executable-font-lock-keywords
+    (shell
            ;; Using font-lock-string-face here confuses sh-get-indent-info.
            ("\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\\\)$" 3 'sh-escaped-newline)
            ("\\\\[^A-Za-z0-9]" 0 font-lock-string-face)
@@ -850,11 +850,11 @@ See `sh-feature'.")
           ("^\\(\\sw+\\):"  1 font-lock-variable-name-face)))
   "Default expressions to highlight in Shell Script modes.  See `sh-feature'.")
 
-(defvar sh-font-lock-keywords-1
+(defvar sh-font-lock-keywords-var-1
   '((sh "[ \t]in\\>"))
   "Subdued level highlighting for Shell Script modes.")
 
-(defvar sh-font-lock-keywords-2 ()
+(defvar sh-font-lock-keywords-var-2 ()
   "Gaudy level highlighting for Shell Script modes.")
 
 ;; These are used for the syntax table stuff (derived from cperl-mode).
@@ -1364,9 +1364,12 @@ with your script for an edit-interpret-debug cycle."
         paragraph-start (concat page-delimiter "\\|$")
         paragraph-separate paragraph-start
         comment-start "# "
+        comment-start-skip "#+[\t ]*"
+        local-abbrev-table sh-mode-abbrev-table
         comint-dynamic-complete-functions sh-dynamic-complete-functions
         ;; we can't look if previous line ended with `\'
         comint-prompt-regexp "^[ \t]*"
+        imenu-case-fold-search nil
         font-lock-defaults
         `((sh-font-lock-keywords
            sh-font-lock-keywords-1 sh-font-lock-keywords-2)
@@ -1403,13 +1406,14 @@ with your script for an edit-interpret-debug cycle."
 (defun sh-font-lock-keywords (&optional keywords)
   "Function to get simple fontification based on `sh-font-lock-keywords'.
 This adds rules for comments and assignments."
-  (sh-feature sh-font-lock-keywords
+  (sh-feature sh-font-lock-keywords-var
               (when (stringp (sh-feature sh-assignment-regexp))
                 (lambda (list)
                   `((,(sh-feature sh-assignment-regexp)
                      1 font-lock-variable-name-face)
                     ,@keywords
-                    ,@list)))))
+                    ,@list
+                    ,@executable-font-lock-keywords)))))
 
 (defun sh-font-lock-keywords-1 (&optional builtins)
   "Function to get better fontification including keywords."
@@ -1426,10 +1430,10 @@ This adds rules for comments and assignments."
                          "\\>")
                 (2 font-lock-keyword-face nil t)
                 (6 font-lock-builtin-face))
-               ,@(sh-feature sh-font-lock-keywords-2)))
+               ,@(sh-feature sh-font-lock-keywords-var-2)))
          (,(concat keywords "\\)\\>")
           2 font-lock-keyword-face)
-         ,@(sh-feature sh-font-lock-keywords-1)))))
+         ,@(sh-feature sh-font-lock-keywords-var-1)))))
 
 (defun sh-font-lock-keywords-2 ()
   "Function to get better fontification including keywords and builtins."
@@ -1491,6 +1495,7 @@ This adds rules for comments and assignments."
      ("case" sh-handle-this-rc-case sh-handle-prev-rc-case))))
 
 
+
 (defun sh-set-shell (shell &optional no-query-flag insert-flag)
   "Set this buffer's shell to SHELL (a string).
 When used interactively, insert the proper starting #!-line,
@@ -1523,13 +1528,10 @@ Calls the value of `sh-set-shell-hook' if set."
     (if (eq tem t)
         (setq require-final-newline mode-require-final-newline)))
   (setq
-        comment-start-skip "#+[\t ]*"
-        local-abbrev-table sh-mode-abbrev-table
         mode-line-process (format "[%s]" sh-shell)
         sh-shell-variables nil
         sh-shell-variables-initialized nil
-        imenu-generic-expression (sh-feature sh-imenu-generic-expression)
-        imenu-case-fold-search nil)
+        imenu-generic-expression (sh-feature sh-imenu-generic-expression))
   (make-local-variable 'sh-mode-syntax-table)
   (let ((tem (sh-feature sh-mode-syntax-table-input)))
     (setq sh-mode-syntax-table
@@ -1557,10 +1559,13 @@ Calls the value of `sh-set-shell-hook' if set."
         (message "Indentation setup for shell type %s" sh-shell))
     (message "No indentation for this shell type.")
     (setq indent-line-function 'sh-basic-indent-line))
+  (when font-lock-mode
+    (setq font-lock-set-defaults nil)
+    (font-lock-set-defaults)
+    (font-lock-fontify-buffer))
   (run-hooks 'sh-set-shell-hook))
 
 
-
 (defun sh-feature (alist &optional function)
   "Index ALIST by the current shell.
 If ALIST isn't a list where every element is a cons, it is returned as is.
@@ -1578,39 +1583,38 @@ Else indexing follows an inheritance logic which works in two ways:
     one shell to be derived from another shell.
     The value thus determined is physically replaced into the alist.
 
-Optional FUNCTION is applied to the determined value and the result is cached
-in ALIST."
+If FUNCTION is non-nil, it is called with one argument,
+the value thus obtained, and the result is used instead."
   (or (if (consp alist)
+          ;; Check for something that isn't a valid alist.
           (let ((l alist))
             (while (and l (consp (car l)))
               (setq l (cdr l)))
             (if l alist)))
-      (if function
-          (cdr (assoc (setq function (cons sh-shell function)) alist)))
-      (let ((sh-shell sh-shell)
-            elt val)
-        (while (and sh-shell
-                    (not (setq elt (assq sh-shell alist))))
-          (setq sh-shell (cdr (assq sh-shell sh-ancestor-alist))))
-        ;; If the shell is not known, treat it as sh.
-        (unless elt
-          (setq elt (assq 'sh alist)))
-        (if (and (consp (setq val (cdr elt)))
-                 (memq (car val) '(sh-append sh-modify)))
-            (setcdr elt
-                    (setq val
-                          (apply (car val)
-                                 (let ((sh-shell (car (cdr val))))
-                                   (if (assq sh-shell alist)
-                                       (sh-feature alist)
-                                     (eval sh-shell)))
-                                 (cddr val)))))
-        (if function
-            (nconc alist
-                   (list (cons function
-                               (setq sh-shell (car function)
-                                     val (funcall (cdr function) val))))))
-        val)))
+
+      (let ((orig-sh-shell sh-shell))
+        (let ((sh-shell sh-shell)
+              elt val)
+          (while (and sh-shell
+                      (not (setq elt (assq sh-shell alist))))
+            (setq sh-shell (cdr (assq sh-shell sh-ancestor-alist))))
+          ;; If the shell is not known, treat it as sh.
+          (unless elt
+            (setq elt (assq 'sh alist)))
+          (setq val (cdr elt))
+          (if (and (consp val)
+                   (memq (car val) '(sh-append sh-modify)))
+              (setq val
+                    (apply (car val)
+                           ;; Refer to the value for a different shell,
+                           ;; as a kind of inheritance.
+                           (let ((sh-shell (car (cdr val))))
+                             (sh-feature alist))
+                           (cddr val))))
+          (if function
+              (setq sh-shell orig-sh-shell
+                    val (funcall function val)))
+          val))))
 
 
 
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 129137c32fd..7e259dfb6e4 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -736,10 +736,11 @@ Used by `sql-rename-buffer'.")
 
 (defvar sql-interactive-mode-map
   (let ((map (make-sparse-keymap)))
-    (if (functionp 'set-keymap-parent)
+    (if (fboundp 'set-keymap-parent)
         (set-keymap-parent map comint-mode-map); Emacs
-      (set-keymap-parents map (list comint-mode-map))); XEmacs
-    (if (functionp 'set-keymap-name)
+      (if (fboundp 'set-keymap-parents)
+          (set-keymap-parents map (list comint-mode-map)))); XEmacs
+    (if (fboundp 'set-keymap-name)
         (set-keymap-name map 'sql-interactive-mode-map)); XEmacs
     (define-key map (kbd "C-j") 'sql-accumulate-and-indent)
     (define-key map (kbd "C-c C-w") 'sql-copy-column)
@@ -1901,16 +1902,8 @@ appended to the SQLi buffer without disturbing your SQL buffer."
   (describe-function 'sql-help))
 
 (defun sql-read-passwd (prompt &optional default)
-  "Read a password using PROMPT.
-Optional DEFAULT is password to start with.  This function calls
-`read-passwd' if it is available.  If not, function
-`ange-ftp-read-passwd' is called.  This should always be available,
-even in old versions of Emacs."
-  (if (fboundp 'read-passwd)
-      (read-passwd prompt nil default)
-    (unless (fboundp 'ange-ftp-read-passwd)
-      (autoload 'ange-ftp-read-passwd "ange-ftp"))
-    (ange-ftp-read-passwd prompt default)))
+  "Read a password using PROMPT.  Optional DEFAULT is password to start with."
+  (read-passwd prompt nil default))
 
 (defun sql-get-login (&rest what)
   "Get username, password and database from the user.
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 26d68aea50f..75f2bb56aa4 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -4,9 +4,8 @@
 
 ;; Authors:     Reto Zimmermann <reto@gnu.org>
 ;;              Rodney J. Whitby <software.vhdl-mode@rwhitby.net>
-;; Maintainer:  Reto Zimmermann <reto@gnu.org>
+;; Maintainer:  FSF  (Because Reto Zimmermann seems to have disappeared)
 ;; Keywords:    languages vhdl
-;; WWW:         http://opensource.ethz.ch/emacs/vhdl-mode.html
 
 (defconst vhdl-version "3.32.12"
   "VHDL Mode version number.")
@@ -67,13 +66,13 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Emacs Versions
 
-;; supported: GNU Emacs 20.X/21.X, XEmacs 20.X/21.X
+;; supported: GNU Emacs 20.X/21.X/22.X, XEmacs 20.X/21.X
 ;; tested on: GNU Emacs 20.4, XEmacs 21.1 (marginally)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Installation
 
-;; Prerequisites:  GNU Emacs 20.X/21.X, XEmacs 20.X/21.X.
+;; Prerequisites:  GNU Emacs 20.X/21.X/22.X, XEmacs 20.X/21.X.
 
 ;; Put `vhdl-mode.el' into the `site-lisp' directory of your Emacs installation
 ;; or into an arbitrary directory that is added to the load path by the
@@ -125,9 +124,9 @@
 ;; XEmacs handling
 (defconst vhdl-xemacs (string-match "XEmacs" emacs-version)
   "Non-nil if XEmacs is used.")
-;; Emacs 21 handling
-(defconst vhdl-emacs-21 (and (= emacs-major-version 21) (not vhdl-xemacs))
-  "Non-nil if Emacs 21 is used.")
+;; Emacs 21+ handling
+(defconst vhdl-emacs-21 (and (<= 21 emacs-major-version) (not vhdl-xemacs))
+  "Non-nil if Emacs 21, 22, ... is used.")
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index c1bfc140d84..66d91dce3da 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -139,8 +139,6 @@ Zero means compute the Imenu menu regardless of size."
      :foreground "LightSkyBlue"))
   "Face used to highlight mode line function names."
   :group 'which-func)
-;; backward-compatibility alias
-(put 'which-func-face 'face-alias 'which-func)
 
 (defcustom which-func-format
   `("["
diff --git a/lisp/progmodes/xscheme.el b/lisp/progmodes/xscheme.el
index f53653a306d..d568bca5b75 100644
--- a/lisp/progmodes/xscheme.el
+++ b/lisp/progmodes/xscheme.el
@@ -33,6 +33,85 @@
 ;;; Code:
 
 (require 'scheme)
+
+;;;; Internal Variables
+
+(defvar xscheme-previous-mode)
+(defvar xscheme-previous-process-state)
+(defvar xscheme-last-input-end)
+
+(defvar xscheme-process-command-line nil
+  "Command used to start the most recent Scheme process.")
+
+(defvar xscheme-process-name "scheme"
+  "Name of xscheme process that we're currently interacting with.")
+
+(defvar xscheme-buffer-name "*scheme*"
+  "Name of xscheme buffer that we're currently interacting with.")
+
+(defvar xscheme-expressions-ring-max 30
+  "*Maximum length of Scheme expressions ring.")
+
+(defvar xscheme-expressions-ring nil
+  "List of expressions recently transmitted to the Scheme process.")
+
+(defvar xscheme-expressions-ring-yank-pointer nil
+  "The tail of the Scheme expressions ring whose car is the last thing yanked.")
+
+(defvar xscheme-running-p nil
+  "This variable, if nil, indicates that the scheme process is
+waiting for input.  Otherwise, it is busy evaluating something.")
+
+(defconst xscheme-control-g-synchronization-p t
+  "If non-nil, insert markers in the scheme input stream to indicate when
+control-g interrupts were signaled.  Do not allow more control-g's to be
+signaled until the scheme process acknowledges receipt.")
+
+(defvar xscheme-control-g-disabled-p nil
+  "This variable, if non-nil, indicates that a control-g is being processed
+by the scheme process, so additional control-g's are to be ignored.")
+
+(defvar xscheme-string-receiver nil
+  "Procedure to send the string argument from the scheme process.")
+
+(defconst default-xscheme-runlight
+  '(": " xscheme-runlight-string)
+  "Default global (shared) xscheme-runlight modeline format.")
+
+(defvar xscheme-runlight "")
+(defvar xscheme-runlight-string nil)
+
+(defvar xscheme-process-filter-state 'idle
+  "State of scheme process escape reader state machine:
+idle                   waiting for an escape sequence
+reading-type           received an altmode but nothing else
+reading-string         reading prompt string")
+
+(defvar xscheme-allow-output-p t
+  "This variable, if nil, prevents output from the scheme process
+from being inserted into the process-buffer.")
+
+(defvar xscheme-prompt ""
+  "The current scheme prompt string.")
+
+(defvar xscheme-string-accumulator ""
+  "Accumulator for the string being received from the scheme process.")
+
+(defvar xscheme-mode-string nil)
+(setq-default scheme-mode-line-process
+              '("" xscheme-runlight))
+
+(mapcar 'make-variable-buffer-local
+        '(xscheme-expressions-ring
+          xscheme-expressions-ring-yank-pointer
+          xscheme-process-filter-state
+          xscheme-running-p
+          xscheme-control-g-disabled-p
+          xscheme-allow-output-p
+          xscheme-prompt
+          xscheme-string-accumulator
+          xscheme-mode-string
+          scheme-mode-line-process))
 
 (defgroup xscheme nil
   "Major mode for editing Scheme and interacting with MIT's C-Scheme."
@@ -355,6 +434,9 @@ with no args, if that value is non-nil.
             (if (eq (process-sentinel process) 'xscheme-process-sentinel)
                 (set-process-sentinel process (cdr previous-state))))))))
 
+(defvar scheme-interaction-mode-commands-alist nil)
+(defvar scheme-interaction-mode-map nil)
+
 (defun scheme-interaction-mode-initialize ()
   (use-local-map scheme-interaction-mode-map)
   (setq major-mode 'scheme-interaction-mode)
@@ -368,7 +450,7 @@ with no args, if that value is non-nil.
         (car (cdr (car entries))))
       (setq entries (cdr entries)))))
 
-(defvar scheme-interaction-mode-commands-alist nil)
+;; Initialize the command alist
 (setq scheme-interaction-mode-commands-alist
       (append scheme-interaction-mode-commands-alist
               '(("\C-c\C-m" xscheme-send-current-line)
@@ -378,7 +460,7 @@ with no args, if that value is non-nil.
                 ("\ep" xscheme-yank-pop)
                 ("\en" xscheme-yank-push))))
 
-(defvar scheme-interaction-mode-map nil)
+;; Initialize the mode map
 (if (not scheme-interaction-mode-map)
     (progn
       (setq scheme-interaction-mode-map (make-keymap))
@@ -411,18 +493,20 @@ Commands:
 \\{scheme-debugger-mode-map}"
   (error "Invalid entry to scheme-debugger-mode"))
 
+(defvar scheme-debugger-mode-map nil)
+
 (defun scheme-debugger-mode-initialize ()
   (use-local-map scheme-debugger-mode-map)
   (setq major-mode 'scheme-debugger-mode)
   (setq mode-name "Scheme Debugger"))
 
 (defun scheme-debugger-mode-commands (keymap)
-  (let ((char ? ))
+  (let ((char ?\s))
     (while (< char 127)
       (define-key keymap (char-to-string char) 'scheme-debugger-self-insert)
       (setq char (1+ char)))))
 
-(defvar scheme-debugger-mode-map nil)
+;; Initialize the debugger mode map
 (if (not scheme-debugger-mode-map)
     (progn
       (setq scheme-debugger-mode-map (make-keymap))
@@ -675,6 +759,9 @@ Useful for working with debugging Scheme under adb."
   (interactive)
   (process-send-string xscheme-process-name "(proceed)\n"))
 
+(defconst xscheme-control-g-message-string
+  "Sending C-G interrupt to Scheme...")
+
 (defun xscheme-send-control-g-interrupt ()
   "Cause the Scheme processor to halt and flush input.
 Control returns to the top level rep loop."
@@ -695,9 +782,6 @@ Control returns to the top level rep loop."
            (sleep-for 0.1)
            (xscheme-send-char 0)))))
 
-(defconst xscheme-control-g-message-string
-  "Sending C-G interrupt to Scheme...")
-
 (defun xscheme-send-control-u-interrupt ()
   "Cause the Scheme process to halt, returning to previous rep loop."
   (interactive)
@@ -722,82 +806,6 @@ Control returns to the top level rep loop."
   (if (and mark-p xscheme-control-g-synchronization-p)
       (xscheme-send-char 0)))
 
-;;;; Internal Variables
-
-(defvar xscheme-process-command-line nil
-  "Command used to start the most recent Scheme process.")
-
-(defvar xscheme-process-name "scheme"
-  "Name of xscheme process that we're currently interacting with.")
-
-(defvar xscheme-buffer-name "*scheme*"
-  "Name of xscheme buffer that we're currently interacting with.")
-
-(defvar xscheme-expressions-ring-max 30
-  "*Maximum length of Scheme expressions ring.")
-
-(defvar xscheme-expressions-ring nil
-  "List of expressions recently transmitted to the Scheme process.")
-
-(defvar xscheme-expressions-ring-yank-pointer nil
-  "The tail of the Scheme expressions ring whose car is the last thing yanked.")
-
-(defvar xscheme-last-input-end)
-
-(defvar xscheme-process-filter-state 'idle
-  "State of scheme process escape reader state machine:
-idle                   waiting for an escape sequence
-reading-type           received an altmode but nothing else
-reading-string         reading prompt string")
-
-(defvar xscheme-running-p nil
-  "This variable, if nil, indicates that the scheme process is
-waiting for input.  Otherwise, it is busy evaluating something.")
-
-(defconst xscheme-control-g-synchronization-p t
-  "If non-nil, insert markers in the scheme input stream to indicate when
-control-g interrupts were signaled.  Do not allow more control-g's to be
-signaled until the scheme process acknowledges receipt.")
-
-(defvar xscheme-control-g-disabled-p nil
-  "This variable, if non-nil, indicates that a control-g is being processed
-by the scheme process, so additional control-g's are to be ignored.")
-
-(defvar xscheme-allow-output-p t
-  "This variable, if nil, prevents output from the scheme process
-from being inserted into the process-buffer.")
-
-(defvar xscheme-prompt ""
-  "The current scheme prompt string.")
-
-(defvar xscheme-string-accumulator ""
-  "Accumulator for the string being received from the scheme process.")
-
-(defvar xscheme-string-receiver nil
-  "Procedure to send the string argument from the scheme process.")
-
-(defconst default-xscheme-runlight
-  '(": " xscheme-runlight-string)
-  "Default global (shared) xscheme-runlight modeline format.")
-
-(defvar xscheme-runlight "")
-(defvar xscheme-runlight-string nil)
-(defvar xscheme-mode-string nil)
-(setq-default scheme-mode-line-process
-              '("" xscheme-runlight))
-
-(mapcar 'make-variable-buffer-local
-        '(xscheme-expressions-ring
-          xscheme-expressions-ring-yank-pointer
-          xscheme-process-filter-state
-          xscheme-running-p
-          xscheme-control-g-disabled-p
-          xscheme-allow-output-p
-          xscheme-prompt
-          xscheme-string-accumulator
-          xscheme-mode-string
-          scheme-mode-line-process))
-
 ;;;; Basic Process Control
 
 (defun xscheme-start-process (command-line the-process the-buffer)
@@ -880,6 +888,61 @@ from being inserted into the process-buffer.")
   "True iff the current buffer is the Scheme process buffer."
   (eq (xscheme-process-buffer) (current-buffer)))
 
+;;;; Process Filter Operations
+
+(defvar xscheme-process-filter-alist
+  '((?A xscheme-eval
+        xscheme-process-filter:string-action-noexcursion)
+    (?D xscheme-enter-debugger-mode
+        xscheme-process-filter:string-action)
+    (?E xscheme-eval
+        xscheme-process-filter:string-action)
+    (?P xscheme-set-prompt-variable
+        xscheme-process-filter:string-action)
+    (?R xscheme-enter-interaction-mode
+        xscheme-process-filter:simple-action)
+    (?b xscheme-start-gc
+        xscheme-process-filter:simple-action)
+    (?c xscheme-unsolicited-read-char
+        xscheme-process-filter:simple-action)
+    (?e xscheme-finish-gc
+        xscheme-process-filter:simple-action)
+    (?f xscheme-exit-input-wait
+        xscheme-process-filter:simple-action)
+    (?g xscheme-enable-control-g
+        xscheme-process-filter:simple-action)
+    (?i xscheme-prompt-for-expression
+        xscheme-process-filter:string-action)
+    (?m xscheme-message
+        xscheme-process-filter:string-action)
+    (?n xscheme-prompt-for-confirmation
+        xscheme-process-filter:string-action)
+    (?o xscheme-output-goto
+        xscheme-process-filter:simple-action)
+    (?p xscheme-set-prompt
+        xscheme-process-filter:string-action)
+    (?s xscheme-enter-input-wait
+        xscheme-process-filter:simple-action)
+    (?v xscheme-write-value
+        xscheme-process-filter:string-action)
+    (?w xscheme-cd
+        xscheme-process-filter:string-action)
+    (?z xscheme-display-process-buffer
+        xscheme-process-filter:simple-action))
+  "Table used to decide how to handle process filter commands.
+Value is a list of entries, each entry is a list of three items.
+
+The first item is the character that the process filter dispatches on.
+The second item is the action to be taken, a function.
+The third item is the handler for the entry, a function.
+
+When the process filter sees a command whose character matches a
+particular entry, it calls the handler with two arguments: the action
+and the string containing the rest of the process filter's input
+stream.  It is the responsibility of the handler to invoke the action
+with the appropriate arguments, and to reenter the process filter with
+the remaining input.")
+
 ;;;; Process Filter
 
 (defun xscheme-process-sentinel (proc reason)
@@ -1037,61 +1100,6 @@ from being inserted into the process-buffer.")
   (rplaca (nthcdr 3 xscheme-runlight) runlight)
   (force-mode-line-update t))
 
-;;;; Process Filter Operations
-
-(defvar xscheme-process-filter-alist
-  '((?A xscheme-eval
-        xscheme-process-filter:string-action-noexcursion)
-    (?D xscheme-enter-debugger-mode
-        xscheme-process-filter:string-action)
-    (?E xscheme-eval
-        xscheme-process-filter:string-action)
-    (?P xscheme-set-prompt-variable
-        xscheme-process-filter:string-action)
-    (?R xscheme-enter-interaction-mode
-        xscheme-process-filter:simple-action)
-    (?b xscheme-start-gc
-        xscheme-process-filter:simple-action)
-    (?c xscheme-unsolicited-read-char
-        xscheme-process-filter:simple-action)
-    (?e xscheme-finish-gc
-        xscheme-process-filter:simple-action)
-    (?f xscheme-exit-input-wait
-        xscheme-process-filter:simple-action)
-    (?g xscheme-enable-control-g
-        xscheme-process-filter:simple-action)
-    (?i xscheme-prompt-for-expression
-        xscheme-process-filter:string-action)
-    (?m xscheme-message
-        xscheme-process-filter:string-action)
-    (?n xscheme-prompt-for-confirmation
-        xscheme-process-filter:string-action)
-    (?o xscheme-output-goto
-        xscheme-process-filter:simple-action)
-    (?p xscheme-set-prompt
-        xscheme-process-filter:string-action)
-    (?s xscheme-enter-input-wait
-        xscheme-process-filter:simple-action)
-    (?v xscheme-write-value
-        xscheme-process-filter:string-action)
-    (?w xscheme-cd
-        xscheme-process-filter:string-action)
-    (?z xscheme-display-process-buffer
-        xscheme-process-filter:simple-action))
-  "Table used to decide how to handle process filter commands.
-Value is a list of entries, each entry is a list of three items.
-
-The first item is the character that the process filter dispatches on.
-The second item is the action to be taken, a function.
-The third item is the handler for the entry, a function.
-
-When the process filter sees a command whose character matches a
-particular entry, it calls the handler with two arguments: the action
-and the string containing the rest of the process filter's input
-stream.  It is the responsibility of the handler to invoke the action
-with the appropriate arguments, and to reenter the process filter with
-the remaining input.")
-
 (defun xscheme-process-filter:simple-action (action)
   (setq xscheme-process-filter-state 'idle)
   (funcall action))
@@ -1196,10 +1204,6 @@ the remaining input.")
 (defun xscheme-prompt-for-confirmation (prompt-string)
   (xscheme-send-char (if (y-or-n-p prompt-string) ?y ?n)))
 
-(defun xscheme-prompt-for-expression (prompt-string)
-  (xscheme-send-string-2
-   (read-from-minibuffer prompt-string nil xscheme-prompt-for-expression-map)))
-
 (defvar xscheme-prompt-for-expression-map nil)
 (if (not xscheme-prompt-for-expression-map)
     (progn
@@ -1209,6 +1213,10 @@ the remaining input.")
                                  'xscheme-prompt-for-expression-exit
                                  xscheme-prompt-for-expression-map)))
 
+(defun xscheme-prompt-for-expression (prompt-string)
+  (xscheme-send-string-2
+   (read-from-minibuffer prompt-string nil xscheme-prompt-for-expression-map)))
+
 (defun xscheme-prompt-for-expression-exit ()
   (interactive)
   (if (eq (xscheme-region-expression-p (point-min) (point-max)) 'one)