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

Merge from emacs--cvs-trunk--0

Patches applied:

 * emacs--cvs-trunk--0  (patch 353-357)

   - Update from CVS

33 files changed, 596 insertions, 348 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 72e02620a50..1e4298f970e 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,203 @@
+2005-06-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/debug.el (debugger-will-be-back): New var.
+        (debug): Use it.
+        (debugger-step-through, debugger-continue, debugger-jump)
+        (debugger-return-value): Set it when needed.
+        (debugger-make-xrefs, debugger-frame, debugger-frame-clear):
+        Use inhibit-read-only.
+
+2005-06-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * thumbs.el: Don't set `auto-image-file-mode'.  Do not create the
+        thumbnails directory on loading.
+        (thumbs-conversion-program): Use `eq' to check the system type,
+        not `equal'.
+        (thumbs-temp-dir): Initialize to `temporary-file-directory',
+        not "/tmp".  Fix docstring.
+        (thumbs-thumbsdir): New function to return the thumbnails
+        directory, creating it if needed.
+        (thumbs-cleanup-thumbsdir, thumbs-thumbname): Use it.
+        (thumbs-temp-file): Delete variable and make it into a function.
+        (thumbs-resize-image, thumbs-modify-image): Use it.
+        (thumbs-kill-buffer): Simplify.
+        (thumbs-gensym): Defalias or duplicate CL `gensym'.
+        (thumbs-resize-image, thumbs-resize-interactive): Fix typos in
+        docstrings.
+
+2005-06-09  Kim F. Storm  <storm@cua.dk>
+
+        * subr.el (save-match-data): Add RESEAT arg `evaporate' to
+        set-match-data to free markers in match-data.
+
+        * replace.el (replace-match-data): Pass RESEAT arg `t' to
+        match-data to unchain markers in match-data.
+
+2005-06-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/debug.el (debug): Don't iconify if we know we'll re-enter
+        the debugger immediately anyway.  Undo the 2005-06-06 change, rendered
+        unnecessary now.
+
+2005-06-08  Richard M. Stallman  <rms@gnu.org>
+
+        * emacs-lisp/easy-mmode.el (define-minor-mode): If BODY is empty,
+        give the variable a doc string that doesn't say don't set it directly.
+
+        * textmodes/ispell.el (ispell-check-version):
+        Use match-string-no-properties.
+        (ispell-region, ispell-buffer-local-parsing, ispell-buffer-local-dict)
+        (ispell-buffer-local-words): Likewise.
+
+        * progmodes/make-mode.el (makefile-shell-face): Make this a no-op
+        except on terminals with enough colors to really display it.
+        (makefile-dependency-regex): Delete spurious `bb'.
+
+        * faces.el (escape-glyph): Use blue once again in last case.
+        (no-break-space): Redefine so that it isn't invisible on a tty.
+
+2005-06-08  Kim F. Storm  <storm@cua.dk>
+
+        * ido.el (ido-read-file-name): Fallback to read-file-name on C-f
+        also when reading directory name.
+
+2005-06-08  Lute Kamstra  <lute@gnu.org>
+
+        * textmodes/flyspell.el (flyspell-mode): Use define-minor-mode.
+        (flyspell-mode-line-string): Remove autoload cookie.
+        (flyspell-mode): Remove defvar.
+
+2005-06-07  Lute Kamstra  <lute@gnu.org>
+
+        * textmodes/org.el (org-run-mode-hooks): New function.
+        (org-agenda-mode): Use it.
+
+2005-06-07  David McCabe  <davemccabe@gmail.com>  (tiny change)
+
+        * emacs-lisp/lisp-mode.el (defstruct): Set `doc-string-elt' property.
+
+2005-06-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * international/iso-cvt.el (iso-sgml2iso-trans-tab): Add NBSP.
+
+2005-06-06  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * font-lock.el (font-lock-add-keywords): Doc fix.
+
+2005-06-06  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * textmodes/tex-mode.el (tex-guess-mode): Add RequirePackage.
+        (tex-compile-default): In the absence of any history, use the order in
+        tex-compile-alist to choose the preferred command.
+        (tex-compile-commands): Reorder a bit.
+
+        * textmodes/flyspell.el (flyspell-auto-correct-binding)
+        (flyspell-incorrect-face, flyspell-duplicate-face):
+        Use (X)Emacs-agnostic code.
+        (flyspell-mode-map): Don't overwrite at each load.  Remove code
+        redundant with the subsequent add-minor-mode.  Merge Emacs and
+        XEmacs code.
+        (flyspell-word): Minor simplification.
+        (flyspell-math-tex-command-p): Quieten the byte-compiler.
+        (flyspell-external-point-words): Remove unused vars `size' and `start'.
+        (flyspell-do-correct): Rename from flyspell-xemacs-correct.
+        Merge the corresponding Emacs code.
+        (flyspell-correct-word, flyspell-xemacs-popup): Use flyspell-do-correct.
+
+        * emacs-lisp/debug.el (debug): Don't bury the buffer unless it's in
+        a dedicated window.
+
+        * international/latexenc.el (latexenc-find-file-coding-system):
+        Undo part of last patch, to turn off a compiler warning.
+
+2005-06-06  Juri Linkov  <juri@jurta.org>
+
+        * tmm.el (tmm-inactive, tmm-remove-inactive-mouse-face):
+        Rename `tmm-inactive-face' to `tmm-inactive'.
+
+2005-06-06  Matt Hodges  <MPHodges@member.fsf.org>
+
+        * iswitchb.el: Rename faces.
+
+2005-06-06  Kim F. Storm  <storm@cua.dk>
+
+        * emulation/cua-base.el (cua-rectangle, cua-rectangle-noselect)
+        (cua-global-mark): Remove -face suffix from face names.
+
+        * emulation/cua-gmrk.el (cua--init-global-mark):
+        Remove cua-global-mark face setup.
+
+2005-06-06  Richard M. Stallman  <rms@gnu.org>
+
+        * progmodes/make-mode.el (makefile-dependency-regex): Handle whitespace
+        just like other allowed characters.
+        (makefile-match-dependency): Exclude leading and training whitespace
+        from the range of regexp subexp 1.
+        (makefile-macroassign-regex): Don't try to match the body,
+        just the name of the macro being defined.
+
+        * info.el (Info-read-node-name-2): New function.
+        (Info-read-node-name-1): Use that.
+        Add a completion-base-size-function property.
+
+        * simple.el (completion-setup-function): Look for
+        completion-base-size-function property of
+        minibuffer-completion-table.
+
+        * files.el (locate-file-completion): Doc fix.
+
+        * printing.el: Don't call pr-update-menus; user must do that.
+
+        * emacs-lisp/debug.el (debugger-window): New variable.
+        (debug): Use debugger-window if it is set and still alive.
+        Record debugger-window for next entry.
+
+        * mail/supercite.el (sc-mail-glom-frame): Mark as risky.
+
+2005-06-06  Matthias F,Av(Brste  <slashdevslashnull@gmx.net>
+
+        * files.el (hack-local-variables-confirm): New arg FLAG-TO-CHECK.
+        (hack-one-local-variable, hack-local-variables)
+        (hack-local-variables-prop-line): Pass that arg.
+
+2005-06-06  Kim F. Storm  <storm@cua.dk>
+
+        * ido.el (ido-first-match, ido-only-match, ido-subdir)
+        (ido-indicator): Remove -face suffix from face names.
+
+2005-06-06  Juri Linkov  <juri@jurta.org>
+
+        * font-lock.el (font-lock-regexp-backslash)
+        (font-lock-regexp-backslash-construct): New faces.
+        (lisp-font-lock-keywords-2): Use new faces.  Match `?:' only
+        after `('.  Add `while-no-input' to control structures.
+
+        * faces.el (no-break-space, shadow): New faces.
+        (escape-glyph): Use less loud colors pink2 and red4.
+
+        * diff-mode.el (diff-context-face)
+        * dired.el (dired-ignored)
+        * rfn-eshadow.el (file-name-shadow)
+        * tmm.el (tmm-inactive-face): Inherit from `shadow' face.
+
+        * info.el (Info-title-1-face): Use green instead of yellow because
+        bold yellow is not readable on light backgrounds.
+
+        * progmodes/compile.el (compilation-start): Move `erase-buffer' up
+        before selecting the desired mode to not spend time fontifying
+        old contents.
+
+2005-06-06  Juanma Barranquero  <lekktu@gmail.com>
+
+        * thumbs.el (thumbs-thumbsdir-max-size, thumbs-image-resizing-step)
+        (thumbs-thumbsdir-auto-clean): Fix typos in docstrings.
+
+        * ps-print.el (ps-default-fg, ps-default-bg):
+        Fix typos in docstrings.
+
+        * isearchb.el (isearchb): Don't pass a spurious second argument to
+        `iswitchb-completions'.
+
 2005-06-05  Nick Roberts  <nickrob@snap.net.nz>
 
         * progmodes/gdb-ui.el (gdb-info-locals-handler): Use window point
@@ -5,16 +205,16 @@
         (gdb-find-file-hook): Add doc string.
 
         * progmodes/gud.el (gdb, gud-menu-map): Add command to evaluate
-         C dereferenced pointer expression.
+        C dereferenced pointer expression.
         (gud-tool-bar-map): Put it on the tool bar.  Re-order icons.
 
         * toolbar/gud-pstar.xpm, toolbar/gud-pstar.pbm: New files.
 
-        * toolbar/gud-break.xpm, toolbar/gud-cont.xpm, toolbar/gud-down.xpm,
-        toolbar/gud-finish.xpm, toolbar/gud-ni.xpm, toolbar/gud-n.xpm,
-        toolbar/gud-print.xpm, toolbar/gud-remove.xpm, toolbar/gud-run.xpm,
-        toolbar/gud-si.xpm, toolbar/gud-s.xpm, toolbar/gud-until.xpm,
-        toolbar/gud-up.xpm, toolbar/gud-watch.xpm:
+        * toolbar/gud-break.xpm, toolbar/gud-cont.xpm, toolbar/gud-down.xpm
+        * toolbar/gud-finish.xpm, toolbar/gud-ni.xpm, toolbar/gud-n.xpm
+        * toolbar/gud-print.xpm, toolbar/gud-remove.xpm, toolbar/gud-run.xpm
+        * toolbar/gud-si.xpm, toolbar/gud-s.xpm, toolbar/gud-until.xpm
+        * toolbar/gud-up.xpm, toolbar/gud-watch.xpm:
         Make background transparent.
 
 2005-06-04  Luc Teirlinck  <teirllm@auburn.edu>
@@ -44,7 +244,7 @@
         (iswitchb-current-match-face, iswitchb-virtual-matches-face)
         (iswitchb-invalid-regexp-face): New faces.
         (iswitchb-completions): Use them.
-        (iswitchb-use-faces): Renamed from iswitchb-use-fonts, which is
+        (iswitchb-use-faces): Rename from iswitchb-use-fonts, which is
         now marked as an obsolete alias.
         (iswitchb-read-buffer): Remove check for bound font variables.
         (iswitchb-invalid-regexp): New free variable.
@@ -151,8 +351,7 @@
         (gdb-info-breakpoints-custom, gdb-delete-breakpoint)
         (gdb-goto-breakpoint, gdb-source-info, gdb-get-location)
         (gdb-assembler-custom): Improve regexps.
-        (def-gdb-auto-update-handler): Use window point to preserve
-        point.
+        (def-gdb-auto-update-handler): Use window point to preserve point.
 
 2005-05-31  Stefan Monnier  <monnier@iro.umontreal.ca>
 
diff --git a/lisp/diff-mode.el b/lisp/diff-mode.el
index aabd09e98ee..5deb7880bdf 100644
--- a/lisp/diff-mode.el
+++ b/lisp/diff-mode.el
@@ -243,10 +243,7 @@ when editing big diffs)."
 (defvar diff-function-face 'diff-function-face)
 
 (defface diff-context-face
-  '((((class color) (background light))
-     :foreground "grey50")
-    (((class color) (background dark))
-     :foreground "grey70"))
+  '((t :inherit shadow))
   "`diff-mode' face used to highlight context and other side-information."
   :group 'diff-mode)
 (defvar diff-context-face 'diff-context-face)
diff --git a/lisp/dired.el b/lisp/dired.el
index b0d86297e71..61aca72db5b 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -356,7 +356,7 @@ Subexpression 2 must end right before the \\n or \\r.")
   "Face name used for symbolic links.")
 
 (defface dired-ignored
-  '((t (:inherit font-lock-string-face)))
+  '((t (:inherit shadow)))
   "Face used for files suffixed with `completion-ignored-extensions'."
   :group 'dired-faces
   :version "22.1")
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index 2149cba8720..f1ff37551d7 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -88,6 +88,8 @@ This is to optimize `debugger-make-xrefs'.")
 (defvar debugger-outer-standard-output)
 (defvar debugger-outer-inhibit-redisplay)
 (defvar debugger-outer-cursor-in-echo-area)
+(defvar debugger-will-be-back nil
+  "Non-nil if we expect to get back in the debugger soon.")
 
 (defvar inhibit-debug-on-entry nil
   "Non-nil means that debug-on-entry is disabled.")
@@ -97,6 +99,8 @@ This is to optimize `debugger-make-xrefs'.")
 This variable is used by `debugger-jump', `debugger-step-through',
 and `debugger-reenable' to temporarily disable debug-on-entry.")
 
+(defvar inhibit-trace)                  ;Not yet implemented.
+
 ;;;###autoload
 (setq debugger 'debug)
 ;;;###autoload
@@ -121,6 +125,7 @@ first will be printed into the backtrace buffer."
                              (get-buffer-create "*Backtrace*")))
           (debugger-old-buffer (current-buffer))
           (debugger-step-after-exit nil)
+          (debugger-will-be-back nil)
           ;; Don't keep reading from an executing kbd macro!
           (executing-kbd-macro nil)
           ;; Save the outer values of these vars for the `e' command
@@ -178,7 +183,7 @@ first will be printed into the backtrace buffer."
                   ;; Place an extra debug-on-exit for macro's.
                   (when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
                     (backtrace-debug 5 t)))
-                (pop-to-buffer debugger-buffer)
+                (pop-to-buffer debugger-buffer)
                 (debugger-mode)
                 (debugger-setup-buffer debugger-args)
                 (when noninteractive
@@ -210,12 +215,23 @@ first will be printed into the backtrace buffer."
               ;; Still visible despite the save-window-excursion?  Maybe it
               ;; it's in a pop-up frame.  It would be annoying to delete and
               ;; recreate it every time the debugger stops, so instead we'll
-              ;; erase it and hide it but keep it alive.
+              ;; erase it (and maybe hide it) but keep it alive.
               (with-current-buffer debugger-buffer
                 (erase-buffer)
                 (fundamental-mode)
                 (with-selected-window (get-buffer-window debugger-buffer 0)
-                  (bury-buffer)))
+                  (when (and (window-dedicated-p (selected-window))
+                             (not debugger-will-be-back))
+                    ;; If the window is not dedicated, burying the buffer
+                    ;; will mean that the frame created for it is left
+                    ;; around showing some random buffer, and next time we
+                    ;; pop to the debugger buffer we'll create yet
+                    ;; another frame.
+                    ;; If debugger-will-be-back is non-nil, the frame
+                    ;; would need to be de-iconified anyway immediately
+                    ;; after when we re-enter the debugger, so iconifying it
+                    ;; here would cause flashing.
+                    (bury-buffer))))
             (kill-buffer debugger-buffer))
           (set-match-data debugger-outer-match-data)))
       ;; Put into effect the modified values of these variables
@@ -307,7 +323,7 @@ That buffer should be current already."
   (save-excursion
     (set-buffer (or buffer (current-buffer)))
     (setq buffer (current-buffer))
-    (let ((buffer-read-only nil)
+    (let ((inhibit-read-only t)
           (old-end (point-min)) (new-end (point-min)))
       ;; If we saved an old backtrace, find the common part
       ;; between the new and the old.
@@ -377,6 +393,7 @@ Enter another debugger on next entry to eval, apply or funcall."
   (interactive)
   (setq debugger-step-after-exit t)
   (setq debugger-jumping-flag t)
+  (setq debugger-will-be-back t)
   (add-hook 'post-command-hook 'debugger-reenable)
   (message "Proceeding, will debug on next eval or call.")
   (exit-recursive-edit))
@@ -387,6 +404,12 @@ Enter another debugger on next entry to eval, apply or funcall."
   (unless debugger-may-continue
     (error "Cannot continue"))
   (message "Continuing.")
+  (save-excursion
+    ;; Check to see if we've flagged some frame for debug-on-exit, in which
+    ;; case we'll probably come back to the debugger soon.
+    (goto-char (point-min))
+    (if (re-search-forward "^\\* " nil t)
+        (setq debugger-will-be-back t)))
   (exit-recursive-edit))
 
 (defun debugger-return-value (val)
@@ -397,6 +420,12 @@ will be used, such as in a debug on exit from a frame."
   (setq debugger-value val)
   (princ "Returning " t)
   (prin1 debugger-value)
+  (save-excursion
+    ;; Check to see if we've flagged some frame for debug-on-exit, in which
+    ;; case we'll probably come back to the debugger soon.
+    (goto-char (point-min))
+    (if (re-search-forward "^\\* " nil t)
+        (setq debugger-will-be-back t)))
   (exit-recursive-edit))
 
 (defun debugger-jump ()
@@ -406,6 +435,7 @@ will be used, such as in a debug on exit from a frame."
   (setq debugger-jumping-flag t)
   (add-hook 'post-command-hook 'debugger-reenable)
   (message "Continuing through this frame")
+  (setq debugger-will-be-back t)
   (exit-recursive-edit))
 
 (defun debugger-reenable ()
@@ -454,7 +484,7 @@ Applies to the frame whose line point is on in the backtrace."
   (beginning-of-line)
   (backtrace-debug (debugger-frame-number) t)
   (if (= (following-char) ? )
-      (let ((buffer-read-only nil))
+      (let ((inhibit-read-only t))
         (delete-char 1)
         (insert ?*)))
   (beginning-of-line))
@@ -470,7 +500,7 @@ Applies to the frame whose line point is on in the backtrace."
   (beginning-of-line)
   (backtrace-debug (debugger-frame-number) nil)
   (if (= (following-char) ?*)
-      (let ((buffer-read-only nil))
+      (let ((inhibit-read-only t))
         (delete-char 1)
         (insert ? )))
   (beginning-of-line))
diff --git a/lisp/emacs-lisp/easy-mmode.el b/lisp/emacs-lisp/easy-mmode.el
index bb0fa666217..a342f8a5530 100644
--- a/lisp/emacs-lisp/easy-mmode.el
+++ b/lisp/emacs-lisp/easy-mmode.el
@@ -183,13 +183,18 @@ Use the command `%s' to change this variable." pretty-name mode))
 
           (let ((curfile (or (and (boundp 'byte-compile-current-file)
                                   byte-compile-current-file)
-                             load-file-name)))
-            `(defcustom ,mode ,init-value
-               ,(format "Non-nil if %s is enabled.
+                             load-file-name))
+                base-doc-string)
+            (setq base-doc-string "Non-nil if %s is enabled.
 See the command `%s' for a description of this minor-mode.
 Setting this variable directly does not take effect;
-use either \\[customize] or the function `%s'."
-                        pretty-name mode mode)
+use either \\[customize] or the function `%s'.")
+            (if (null body)
+                (setq base-doc-string "Non-nil if %s is enabled.
+See the command `%s' for a description of this minor-mode."))
+
+            `(defcustom ,mode ,init-value
+               ,(format base-doc-string pretty-name mode mode)
                :set 'custom-set-minor-mode
                :initialize 'custom-initialize-default
                ,@group
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index bb815481bf0..72924417109 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -129,6 +129,7 @@
 (put 'defmacro 'doc-string-elt 3)
 (put 'defmacro* 'doc-string-elt 3)
 (put 'defsubst 'doc-string-elt 3)
+(put 'defstruct 'doc-string-elt 2)
 (put 'define-skeleton 'doc-string-elt 2)
 (put 'define-derived-mode 'doc-string-elt 4)
 (put 'define-compilation-mode 'doc-string-elt 3)
@@ -194,7 +195,7 @@
   (setq comment-start-skip "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\);+ *")
   (make-local-variable 'font-lock-comment-start-skip)
   ;; Font lock mode uses this only when it KNOWS a comment is starting.
-  (setq font-lock-comment-start-skip ";+ *") 
+  (setq font-lock-comment-start-skip ";+ *")
   (make-local-variable 'comment-add)
   (setq comment-add 1)                  ;default to `;;' in comment-region
   (make-local-variable 'comment-column)
diff --git a/lisp/emulation/cua-base.el b/lisp/emulation/cua-base.el
index 6ea6bfb7f3d..fe2b0a892a8 100644
--- a/lisp/emulation/cua-base.el
+++ b/lisp/emulation/cua-base.el
@@ -384,13 +384,13 @@ and after the region marked by the rectangle to search."
   :type 'boolean
   :group 'cua)
 
-(defface cua-rectangle-face
+(defface cua-rectangle
   '((default :inherit region)
     (((class color)) :foreground "white" :background "maroon"))
   "*Font used by CUA for highlighting the rectangle."
   :group 'cua)
 
-(defface cua-rectangle-noselect-face
+(defface cua-rectangle-noselect
   '((default :inherit region)
     (((class color)) :foreground "white" :background "dimgray"))
   "*Font used by CUA for highlighting the non-selected rectangle lines."
@@ -404,7 +404,7 @@ and after the region marked by the rectangle to search."
   :type 'boolean
   :group 'cua)
 
-(defface cua-global-mark-face
+(defface cua-global-mark
   '((((min-colors 88)(class color)) :foreground "black" :background "yellow1")
     (((class color)) :foreground "black" :background "yellow")
     (t :bold t))
diff --git a/lisp/emulation/cua-gmrk.el b/lisp/emulation/cua-gmrk.el
index 8280691ae18..b8874df0f34 100644
--- a/lisp/emulation/cua-gmrk.el
+++ b/lisp/emulation/cua-gmrk.el
@@ -74,7 +74,7 @@
       (move-overlay cua--global-mark-overlay (point) (1+ (point)))
     (setq cua--global-mark-overlay
           (make-overlay (point) (1+ (point))))
-    (overlay-put cua--global-mark-overlay 'face 'cua-global-mark-face))
+    (overlay-put cua--global-mark-overlay 'face 'cua-global-mark))
   (if (and cua-global-mark-blink-cursor-interval
            (not cua--orig-blink-cursor-interval))
       (setq cua--orig-blink-cursor-interval blink-cursor-interval
@@ -218,7 +218,7 @@ With prefix argument, don't jump to global mark when cancelling it."
               (let ((olist (overlays-at (marker-position cua--global-mark-marker)))
                     in-rect)
                 (while olist
-                  (if (eq (overlay-get (car olist) 'face) 'cua-rectangle-face)
+                  (if (eq (overlay-get (car olist) 'face) 'cua-rectangle)
                       (setq in-rect t olist nil)
                     (setq olist (cdr olist))))
                 (if in-rect
@@ -358,11 +358,6 @@ With prefix argument, don't jump to global mark when cancelling it."
 ;;; Initialization
 
 (defun cua--init-global-mark ()
-  (unless (face-background 'cua-global-mark-face)
-    (copy-face 'region 'cua-global-mark-face)
-    (set-face-foreground 'cua-global-mark-face "black")
-    (set-face-background 'cua-global-mark-face "cyan"))
-
   (define-key cua--global-mark-keymap [remap copy-region-as-kill]       'cua-copy-to-global-mark)
   (define-key cua--global-mark-keymap [remap kill-ring-save]            'cua-copy-to-global-mark)
   (define-key cua--global-mark-keymap [remap kill-region]               'cua-cut-to-global-mark)
diff --git a/lisp/emulation/cua-rect.el b/lisp/emulation/cua-rect.el
index 932448079dd..72fd9195850 100644
--- a/lisp/emulation/cua-rect.el
+++ b/lisp/emulation/cua-rect.el
@@ -755,7 +755,7 @@ If command is repeated at same position, delete the rectangle."
       (sit-for 0)  ; make window top/bottom reliable
       (cua--rectangle-operation nil t nil nil nil ; do not tabify
         '(lambda (s e l r v)
-           (let ((rface (if v 'cua-rectangle-face 'cua-rectangle-noselect-face))
+           (let ((rface (if v 'cua-rectangle 'cua-rectangle-noselect))
                  overlay bs ms as)
              (when (cua--rectangle-virtual-edges)
                (let ((lb (line-beginning-position))
diff --git a/lisp/faces.el b/lisp/faces.el
index 6bbf7da3761..8240cceaaef 100644
--- a/lisp/faces.el
+++ b/lisp/faces.el
@@ -2085,13 +2085,32 @@ Note: Other faces cannot inherit from the cursor face."
   :group 'whitespace            ; like `show-trailing-whitespace'
   :group 'basic-faces)
 
-(defface escape-glyph '((((background dark)) :foreground "cyan")
-                        ;; See the comment in minibuffer-prompt for
-                        ;; the reason not to use blue on MS-DOS.
-                        (((type pc)) :foreground "magenta")
-                        (t :foreground "blue"))
+(defface escape-glyph
+  '((((background dark)) :foreground "pink2")
+    ;; See the comment in minibuffer-prompt for
+    ;; the reason not to use blue on MS-DOS.
+    (((type pc)) :foreground "magenta")
+    ;; red4 is too light -- rms.
+    (t :foreground "blue"))
   "Face for characters displayed as ^-sequences or \-sequences."
-  :group 'basic-faces)
+  :group 'basic-faces
+  :version "22.1")
+
+(defface no-break-space
+  '((((class color) (min-colors 88)) :inherit escape-glyph :underline t)
+    (((class color) (min-colors 8)) :background "magenta" :foreground )
+    (t :inverse-video t))
+  "Face for non-breaking space."
+  :group 'basic-faces
+  :version "22.1")
+
+(defface shadow
+  '((((background dark))  :foreground "grey70")
+    (((background light)) :foreground "grey50"))
+  "Basic face for shadowed text."
+  :group 'basic-faces
+  :version "22.1")
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Manipulating font names.
diff --git a/lisp/files.el b/lisp/files.el
index a75b6b2fc89..b8ec5bf1cd0 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -658,7 +658,7 @@ one or more of those symbols."
 
 (defun locate-file-completion (string path-and-suffixes action)
   "Do completion for file names passed to `locate-file'.
-PATH-AND-SUFFIXES is a pair of lists (DIRECTORIES . SUFFIXES)."
+PATH-AND-SUFFIXES is a pair of lists, (DIRECTORIES . SUFFIXES)."
   (if (file-name-absolute-p string)
       (read-file-name-internal string nil action)
     (let ((names nil)
@@ -2159,9 +2159,9 @@ Otherwise, return nil; point may be changed."
        (goto-char beg)
        end))))
 
-(defun hack-local-variables-confirm (string)
-  (or (eq enable-local-variables t)
-      (and enable-local-variables
+(defun hack-local-variables-confirm (string flag-to-check)
+  (or (eq flag-to-check t)
+      (and flag-to-check
            (save-window-excursion
              (condition-case nil
                  (switch-to-buffer (current-buffer))
@@ -2236,7 +2236,8 @@ is specified, returning t if it is specified."
         (if (and result
                  (or mode-only
                      (hack-local-variables-confirm
-                      "Set local variables as specified in -*- line of %s? ")))
+                      "Set local variables as specified in -*- line of %s? "
+                      enable-local-variables)))
             (let ((enable-local-eval enable-local-eval))
               (while result
                 (hack-one-local-variable (car (car result)) (cdr (car result)))
@@ -2267,7 +2268,8 @@ is specified, returning t if it is specified."
               (and (search-forward "Local Variables:" nil t)
                    (or mode-only
                        (hack-local-variables-confirm
-                        "Set local variables as specified at end of %s? "))))
+                        "Set local variables as specified at end of %s? "
+                        enable-local-variables))))
         (skip-chars-forward " \t")
         (let ((enable-local-eval enable-local-eval)
               ;; suffix is what comes after "local variables:" in its line.
@@ -2489,7 +2491,8 @@ is considered risky."
                  ;; Permit eval if not root and user says ok.
                  (and (not (zerop (user-uid)))
                       (hack-local-variables-confirm
-                       "Process `eval' or hook local variables in %s? ")))
+                       "Process `eval' or hook local variables in %s? "
+                       enable-local-eval)))
              (if (eq var 'eval)
                  (save-excursion (eval val))
                (make-local-variable var)
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 1d07e5a9283..4457f9cfe03 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -691,7 +691,7 @@ For example:
 
  (add-hook 'c-mode-hook
   (lambda ()
-   (font-lock-add-keywords 'c-mode
+   (font-lock-add-keywords nil
     '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend)
       (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" .
        font-lock-keyword-face)))))
@@ -905,7 +905,7 @@ The value of this variable is used when Font Lock mode is turned on."
                         'font-lock-after-change-function t)
            (set (make-local-variable 'font-lock-fontify-buffer-function)
                 'jit-lock-refontify)
-           ;; Don't fontify eagerly (and don't abort is the buffer is large).
+           ;; Don't fontify eagerly (and don't abort if the buffer is large).
            (set (make-local-variable 'font-lock-fontified) t)
            ;; Use jit-lock.
            (jit-lock-register 'font-lock-fontify-region
@@ -1826,6 +1826,17 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
   "Font Lock mode face used to highlight preprocessor directives."
   :group 'font-lock-highlighting-faces)
 
+(defface font-lock-regexp-backslash
+  '((((class color) (min-colors 16)) :inherit escape-glyph)
+    (t :inherit bold))
+  "Font Lock mode face used to highlight a backslash in Lisp regexps."
+  :group 'font-lock-highlighting-faces)
+
+(defface font-lock-regexp-backslash-construct
+  '((t :inherit bold))
+  "Font Lock mode face used to highlight `\' constructs in Lisp regexps."
+  :group 'font-lock-highlighting-faces)
+
 ;;; End of Colour etc. support.
 
 ;;; Menu support.
@@ -2020,7 +2031,7 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
      `(;; Control structures.  Emacs Lisp forms.
        (,(concat
           "(" (regexp-opt
-               '("cond" "if" "while" "let" "let*"
+               '("cond" "if" "while" "while-no-input" "let" "let*"
                  "prog" "progn" "progv" "prog1" "prog2" "prog*"
                  "inline" "lambda" "save-restriction" "save-excursion"
                  "save-window-excursion" "save-selected-window"
@@ -2076,16 +2087,14 @@ This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
        ;; Make regexp grouping constructs bold, so they stand out, but only
        ;; in strings.
        ((lambda (bound)
-          (if (re-search-forward "\\(\\\\\\\\\\)\\([(|)]\\)\\(\\?:\\)?" bound t)
+          (if (re-search-forward "\\(\\\\\\\\\\)\\((\\(?:?:\\)?\\|[|)]\\)" bound t)
                (let ((face (get-text-property (1- (point)) 'face)))
                  (if (listp face)
                      (memq 'font-lock-string-face face)
                    (eq 'font-lock-string-face face)))))
-        ;; Should we introduce a lowlight face for this?
-        ;; Ideally that would retain the color, dimmed.
-        (1 font-lock-comment-face prepend)
-        (2 'bold prepend)
-        (3 font-lock-type-face prepend t))
+        (1 'font-lock-regexp-backslash prepend)
+        (2 'font-lock-regexp-backslash-construct prepend))
+
        ;; Underline innermost grouping, so that you can more easily see what
        ;; belongs together.  2005-05-12: Font-lock can go into an
        ;; unbreakable endless loop on this -- something's broken.
diff --git a/lisp/ido.el b/lisp/ido.el
index b01e9e35c37..4ac9546de64 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -299,8 +299,8 @@
 ;; ------------
 
 ;; The highlighting of matching items is controlled via ido-use-faces.
-;; The faces used are ido-first-match-face, ido-only-match-face and
-;; ido-subdir-face.
+;; The faces used are ido-first-match, ido-only-match and
+;; ido-subdir.
 ;; Colouring of the matching item was suggested by
 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
 
@@ -740,17 +740,17 @@ subdirs in the alternatives."
   :type 'boolean
   :group 'ido)
 
-(defface ido-first-match-face  '((t (:bold t)))
+(defface ido-first-match  '((t (:bold t)))
   "*Font used by ido for highlighting first match."
   :group 'ido)
 
-(defface ido-only-match-face  '((((class color))
+(defface ido-only-match  '((((class color))
                                  (:foreground "ForestGreen"))
                                 (t (:italic t)))
   "*Font used by ido for highlighting only match."
   :group 'ido)
 
-(defface ido-subdir-face  '((((min-colors 88) (class color))
+(defface ido-subdir  '((((min-colors 88) (class color))
                              (:foreground "red1"))
                             (((class color))
                              (:foreground "red"))
@@ -758,7 +758,7 @@ subdirs in the alternatives."
   "*Font used by ido for highlighting subdirs in the alternatives."
   :group 'ido)
 
-(defface ido-indicator-face  '((((min-colors 88) (class color))
+(defface ido-indicator  '((((min-colors 88) (class color))
                                 (:foreground "yellow1"
                                  :background "red1"
                                  :width condensed))
@@ -4039,7 +4039,7 @@ For details of keybindings, do `\\[describe-function] ido-find-file'."
          first)
 
     (if (and ind ido-use-faces)
-        (put-text-property 0 1 'face 'ido-indicator-face ind))
+        (put-text-property 0 1 'face 'ido-indicator ind))
 
     (if (and ido-use-faces comps)
         (let* ((fn (ido-name (car comps)))
@@ -4047,8 +4047,8 @@ For details of keybindings, do `\\[describe-function] ido-find-file'."
           (setq first (format "%s" fn))
           (put-text-property 0 ln 'face
                              (if (= (length comps) 1)
-                                 'ido-only-match-face
-                               'ido-first-match-face)
+                                 'ido-only-match
+                               'ido-first-match)
                              first)
           (if ind (setq first (concat first ind)))
           (setq comps (cons first (cdr comps)))))
@@ -4091,7 +4091,7 @@ For details of keybindings, do `\\[describe-function] ido-find-file'."
                                        (if (and ido-use-faces
                                                 (not (string= str first))
                                                 (ido-final-slash str))
-                                           (put-text-property 0 (length str) 'face 'ido-subdir-face str))
+                                           (put-text-property 0 (length str) 'face 'ido-subdir str))
                                        str)))))
                            comps))))))
 
@@ -4193,7 +4193,9 @@ See `read-file-name' for additional parameters."
           (eq (get this-command 'ido) 'dir)
           (memq this-command ido-read-file-name-as-directory-commands))
       (setq filename
-            (ido-read-directory-name prompt dir default-filename mustmatch initial)))
+            (ido-read-directory-name prompt dir default-filename mustmatch initial))
+      (if (eq ido-exit 'fallback)
+          (setq filename 'fallback)))
      ((and (not (eq (get this-command 'ido) 'ignore))
            (not (memq this-command ido-read-file-name-non-ido))
            (or (null predicate) (eq predicate 'file-exists-p)))
diff --git a/lisp/info.el b/lisp/info.el
index c36554e6a7a..4c6a0ea027d 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -1379,6 +1379,43 @@ If FORK is a string, it is the name to use for the new buffer."
 
 (defvar Info-read-node-completion-table)
 
+(defun Info-read-node-name-2 (string path-and-suffixes action)
+  "Virtual completion table for file names input in Info node names.
+PATH-AND-SUFFIXES is a pair of lists, (DIRECTORIES . SUFFIXES)."
+  (let* ((names nil)
+         (suffixes (remove "" (cdr path-and-suffixes)))
+         (suffix (concat (regexp-opt suffixes t) "\\'"))
+         (string-dir (file-name-directory string))
+         (dirs
+          (if (file-name-absolute-p string)
+              (list (file-name-directory string))
+            (car path-and-suffixes))))
+    (dolist (dir dirs)
+      (unless dir
+        (setq dir default-directory))
+      (if string-dir (setq dir (expand-file-name string-dir dir)))
+      (when (file-directory-p dir)
+        (dolist (file (file-name-all-completions
+                       (file-name-nondirectory string) dir))
+          ;; If the file name has no suffix or a standard suffix,
+          ;; include it.
+          (and (or (null (file-name-extension file))
+                   (string-match suffix file))
+               ;; But exclude subfiles of split info files.
+               (not (string-match "-[0-9]+\\'" file))
+               ;; And exclude backup files.
+               (not (string-match "~\\'" file))
+               (push (if string-dir (concat string-dir file) file) names))
+          ;; If the file name ends in a standard suffix,
+          ;; add the unsuffixed name as a completion option.
+          (when (string-match suffix file)
+            (setq file (substring file 0 (match-beginning 0)))
+            (push (if string-dir (concat string-dir file) file) names)))))
+    (cond
+     ((eq action t) (all-completions string names))
+     ((null action) (try-completion string names))
+     (t (test-completion string names)))))
+
 ;; This function is used as the "completion table" while reading a node name.
 ;; It does completion using the alist in Info-read-node-completion-table
 ;; unless STRING starts with an open-paren.
@@ -1389,15 +1426,16 @@ If FORK is a string, it is the name to use for the new buffer."
     (let ((file (substring string 1)))
       (cond
        ((eq code nil)
-        (let ((comp (try-completion file 'locate-file-completion
+        (let ((comp (try-completion file 'Info-read-node-name-2
                                     (cons Info-directory-list
                                           (mapcar 'car Info-suffix-list)))))
           (cond
            ((eq comp t) (concat string ")"))
            (comp (concat "(" comp)))))
-       ((eq code t) (all-completions file 'locate-file-completion
-                                     (cons Info-directory-list
-                                           (mapcar 'car Info-suffix-list))))
+       ((eq code t)
+        (all-completions file 'Info-read-node-name-2
+                         (cons Info-directory-list
+                               (mapcar 'car Info-suffix-list))))
        (t nil))))
    ;; If a file name was given, then any node is fair game.
    ((string-match "\\`(" string)
@@ -1413,6 +1451,10 @@ If FORK is a string, it is the name to use for the new buffer."
    (t
     (test-completion string Info-read-node-completion-table predicate))))
 
+;; Arrange to highlight the proper letters in the completion list buffer.
+(put 'Info-read-node-name-1 'completion-base-size-function
+     (lambda () 1))
+
 (defun Info-read-node-name (prompt &optional default)
   (let* ((completion-ignore-case t)
          (Info-read-node-completion-table (Info-build-node-completions))
@@ -3483,7 +3525,7 @@ the variable `Info-file-list-for-emacs'."
            (Info-goto-emacs-command-node command)))))
 
 (defface Info-title-1-face
-  '((((type tty pc) (class color)) :foreground "yellow" :weight bold)
+  '((((type tty pc) (class color)) :foreground "green" :weight bold)
     (t :height 1.2 :inherit Info-title-2-face))
   "Face for Info titles at level 1."
   :group 'info)
diff --git a/lisp/international/iso-cvt.el b/lisp/international/iso-cvt.el
index f7e325b0ca3..f896773e53c 100644
--- a/lisp/international/iso-cvt.el
+++ b/lisp/international/iso-cvt.el
@@ -791,6 +791,7 @@ Optional arg BUFFER is ignored (for use in `format-alist')."
     ("&iuml;" "ï")
     ("&eth;" "ð")
     ("&ntilde;" "ñ")
+    ("&nbsp;" " ")
     ("&ograve;" "ò")
     ("&oacute;" "ó")
     ("&ocirc;" "ô")
diff --git a/lisp/international/latexenc.el b/lisp/international/latexenc.el
index 24f7ebc6000..6ce21a5328a 100644
--- a/lisp/international/latexenc.el
+++ b/lisp/international/latexenc.el
@@ -47,7 +47,7 @@
 ;; like this
 
 ;; (add-to-list 'file-coding-system-alist
-;;           '("\\.tex\\|\\.ltx\\|\\.dtx\\|\\.drv\\'" . latexenc-find-file-coding-system))
+;;           '("\\.\\(tex\\|ltx\\|dtx\\|drv\\)\\'" . latexenc-find-file-coding-system))
 
 ;;; Code:
 
@@ -159,10 +159,11 @@ coding system names is determined from `latex-inputenc-coding-alist'."
                         (setq latexenc-main-file (concat file ext)))))))
             ;; try tex-modes tex-guess-main-file
             (when (and (not latexenc-dont-use-tex-guess-main-file-flag)
-                       (not latexenc-main-file)
-                       (fboundp 'tex-guess-main-file))
-              (let ((tex-start-of-header "\\\\document\\(style\\|class\\)"))
-                (setq latexenc-main-file (tex-guess-main-file))))
+                       (not latexenc-main-file))
+              ;; Use a separate `when' so the byte-compiler sees the fboundp.
+              (when (fboundp 'tex-guess-main-file)
+                (let ((tex-start-of-header "\\\\document\\(style\\|class\\)"))
+                  (setq latexenc-main-file (tex-guess-main-file)))))
             ;; if we found a master/main file get the coding system from it
             (if (and latexenc-main-file
                      (file-readable-p latexenc-main-file))
diff --git a/lisp/isearchb.el b/lisp/isearchb.el
index 9714701944f..5c70bd8fc00 100644
--- a/lisp/isearchb.el
+++ b/lisp/isearchb.el
@@ -151,7 +151,7 @@ It's purpose is to pass different call arguments to
       (switch-to-buffer buf)
       (if isearchb-show-completions
           (message "isearchb: %s%s" iswitchb-text
-                   (iswitchb-completions iswitchb-text nil))
+                   (iswitchb-completions iswitchb-text))
         (if (= 1 (length iswitchb-matches))
             (message "isearchb: %s (only match)" iswitchb-text)
           (message "isearchb: %s" iswitchb-text))))))
diff --git a/lisp/iswitchb.el b/lisp/iswitchb.el
index 2943be851a0..0cb12d391ff 100644
--- a/lisp/iswitchb.el
+++ b/lisp/iswitchb.el
@@ -404,21 +404,21 @@ iswitchb is running."
   :type 'hook
   :group 'iswitchb)
 
-(defface iswitchb-single-match-face
+(defface iswitchb-single-match
   '((t
      (:inherit font-lock-comment-face)))
   "Iswitchb face for single matching buffer name."
   :version "22.1"
   :group 'iswitchb)
 
-(defface iswitchb-current-match-face
+(defface iswitchb-current-match
   '((t
      (:inherit font-lock-function-name-face)))
   "Iswitchb face for current matching buffer name."
   :version "22.1"
   :group 'iswitchb)
 
-(defface iswitchb-virtual-matches-face
+(defface iswitchb-virtual-matches
   '((t
      (:inherit font-lock-builtin-face)))
   "Iswitchb face for matching virtual buffer names.
@@ -426,7 +426,7 @@ See also `iswitchb-use-virtual-buffers'."
   :version "22.1"
   :group 'iswitchb)
 
-(defface iswitchb-invalid-regexp-face
+(defface iswitchb-invalid-regexp
   '((t
      (:inherit font-lock-warning-face)))
   "Iswitchb face for indicating invalid regexp. "
@@ -1299,9 +1299,9 @@ Modified from `icomplete-completions'."
           (put-text-property 0 (length first) 'face
                              (if (= (length comps) 1)
                                  (if iswitchb-invalid-regexp
-                                     'iswitchb-invalid-regexp-face
-                                   'iswitchb-single-match-face)
-                               'iswitchb-current-match-face)
+                                     'iswitchb-invalid-regexp
+                                   'iswitchb-single-match)
+                               'iswitchb-current-match)
                              first)
           (setq comps  (cons first (cdr comps)))))
 
@@ -1330,7 +1330,7 @@ Modified from `icomplete-completions'."
         (let ((comp comps))
           (while comp
             (put-text-property 0 (length (car comp))
-                               'face 'iswitchb-virtual-matches-face
+                               'face 'iswitchb-virtual-matches
                                (car comp))
             (setq comp (cdr comp))))))
 
diff --git a/lisp/mail/supercite.el b/lisp/mail/supercite.el
index ba4aca881ef..593f46cad40 100644
--- a/lisp/mail/supercite.el
+++ b/lisp/mail/supercite.el
@@ -720,6 +720,7 @@ the list should be unique."
     (sc-mail-warn-if-non-rfc822-p (sc-mail-error-in-mail-field))
     (end                          (setq sc-mail-headers-end (point))))
   "Regi frame for glomming mail header information.")
+(put 'sc-mail-glom-frame 'risky-local-variable t)
 
 (defvar curline)                        ; dynamic bondage
 
diff --git a/lisp/printing.el b/lisp/printing.el
index ddfe6fd5cc0..41ea0238c6b 100644
--- a/lisp/printing.el
+++ b/lisp/printing.el
@@ -6434,7 +6434,8 @@ COMMAND.exe, COMMAND.bat and COMMAND.com in this order."
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
-(pr-update-menus t)
+;;; Files are not supposed to change Emacs behavior when you merely load them.
+;;; (pr-update-menus t)
 
 
 (provide 'printing)
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index a27a5282b42..e0c8ded307a 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -935,6 +935,7 @@ Returns the compilation buffer created."
                     (substitute-env-vars (match-string 1 command))
                   "~")
               default-directory))
+        (erase-buffer)
         ;; Select the desired mode.
         (if (not (eq mode t))
             (funcall mode)
@@ -944,11 +945,11 @@ Returns the compilation buffer created."
         (if highlight-regexp
             (set (make-local-variable 'compilation-highlight-regexp)
                  highlight-regexp))
-        (erase-buffer)
         ;; 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")  (setq thisdir default-directory))
+                " -*-\n" command "\n")
+        (setq thisdir default-directory))
       (set-buffer-modified-p nil))
     ;; If we're already in the compilation buffer, go to the end
     ;; of the buffer, so point will track the compilation output.
diff --git a/lisp/progmodes/make-mode.el b/lisp/progmodes/make-mode.el
index 7356583fb90..d2d2dc6263a 100644
--- a/lisp/progmodes/make-mode.el
+++ b/lisp/progmodes/make-mode.el
@@ -115,9 +115,8 @@
   :version "22.1")
 
 (defface makefile-shell-face
-  '((((class color) (background light)) (:background  "seashell1"))
-    (((class color) (background dark)) (:background  "seashell4"))
-    (t (:reverse-video t)))
+  '((((class color) (min-colors 88) (background light)) (:background  "seashell1"))
+    (((class color) (min-colors 88) (background dark)) (:background  "seashell4")))
   "Face to use for additionally highlighting Shell commands in Font-Lock mode."
   :group 'faces
   :group 'makefile
@@ -262,7 +261,7 @@ not be enclosed in { } or ( )."
 ;; index in makefile-imenu-generic-expression.
 (defvar makefile-dependency-regex
   ;; Allow for two nested levels $(v1:$(v2:$(v3:a=b)=c)=d)
-  "^ *\\(\\(?: *\\$\\(?:[({]\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[^({]\\|.[^\n$#})]+?[})]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\| *[^ \n$#:=]+\\)+?\\)[ \t]*\\(:\\)\\(?:[ \t]*$\\|[^=\n]\\(?:[^#\n]*?;[ \t]*\\(.+\\)\\)?\\)"
+  "^\\(\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[({]\\(?:\\$\\(?:[^({]\\|.[^\n$#})]+?[})]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#)}]\\)+?[})]\\|[^({]\\)\\|[^\n$#:=]\\)+?\\)\\(:\\)\\(?:[ \t]*$\\|[^=\n]\\(?:[^#\n]*?;[ \t]*\\(.+\\)\\)?\\)"
   "Regex used to find dependency lines in a makefile.")
 
 (defconst makefile-bsdmake-dependency-regex
@@ -291,7 +290,7 @@ not be enclosed in { } or ( )."
 ;; that if you change this regexp you might have to fix the imenu index in
 ;; makefile-imenu-generic-expression.
 (defconst makefile-macroassign-regex
-  "^ *\\([^ \n\t][^:#= \t\n]*\\)[ \t]*\\(?:!=[ \t]*\\(\\(?:.+\\\\\n\\)*.+\\)\\|[*:+]?[:?]?=[ \t]*\\(\\(?:.*\\\\\n\\)*.*\\)\\)"
+  "^ *\\([^ \n\t][^:#= \t\n]*\\)[ \t]*\\(?:!=\\|[*:+]?[:?]?=\\)"
   "Regex used to find macro assignment lines in a makefile.")
 
 (defconst makefile-var-use-regex
@@ -1704,6 +1703,19 @@ matched in a rule action."
             (when (save-excursion
                     (beginning-of-line)
                     (looking-at makefile-dependency-regex))
+              (save-excursion
+                (let ((deps-end (match-end 1))
+                      (match-data (match-data)))
+                  (goto-char deps-end)
+                  (skip-chars-backward " \t")
+                  (setq deps-end (point))
+                  (beginning-of-line)
+                  (skip-chars-forward " \t")
+                  ;; Alter the bounds recorded for subexp 1,
+                  ;; which is what is supposed to match the targets.
+                  (setcar (nthcdr 2 match-data) (point))
+                  (setcar (nthcdr 3 match-data) deps-end)
+                  (store-match-data match-data)))
               (end-of-line)
               (throw 'found (point)))))
       (goto-char pt))
diff --git a/lisp/ps-print.el b/lisp/ps-print.el
index 0b2a33f27c0..509a74cf6a5 100644
--- a/lisp/ps-print.el
+++ b/lisp/ps-print.el
@@ -3019,7 +3019,7 @@ Valid values are:
    NUMBER       It's a real value between 0.0 (black) and 1.0 (white) that
                 indicate the gray color.
 
-   COLOR-NAME   It's a string wich contains the color name.  For example:
+   COLOR-NAME   It's a string which contains the color name.  For example:
                 \"yellow\".
 
    LIST         It's a list of RGB values, that is a list of three real values
@@ -3059,7 +3059,7 @@ Valid values are:
    NUMBER       It's a real value between 0.0 (black) and 1.0 (white) that
                 indicate the gray color.
 
-   COLOR-NAME   It's a string wich contains the color name.  For example:
+   COLOR-NAME   It's a string which contains the color name.  For example:
                 \"yellow\".
 
    LIST         It's a list of RGB values, that is a list of three real values
@@ -6119,7 +6119,7 @@ XSTART YSTART are the relative position for the first page in a sheet.")
     (if (and (boundp 'ucs-mule-8859-to-mule-unicode)
            (char-table-p ucs-mule-8859-to-mule-unicode))
         (map-char-table
-         #'(lambda (k v) 
+         #'(lambda (k v)
              (if (and v (eq (char-charset v) 'latin-iso8859-1) (/= k v))
                  (aset tbl k v)))
          ucs-mule-8859-to-mule-unicode))
diff --git a/lisp/replace.el b/lisp/replace.el
index ba3d5fcfbf4..d5ccd8723c2 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -217,7 +217,7 @@ Fourth and fifth arg START and END specify the region to operate on.
 
 To customize possible responses, change the \"bindings\" in `query-replace-map'."
   (interactive (let ((common
-                      (query-replace-read-args 
+                      (query-replace-read-args
                        (if (and transient-mark-mode mark-active)
                          "Query replace in region"
                          "Query replace")
@@ -281,7 +281,7 @@ text, TO-STRING is actually made a list instead of a string.
 Use \\[repeat-complex-command] after this command for details."
   (interactive
    (let ((common
-          (query-replace-read-args 
+          (query-replace-read-args
            (if (and transient-mark-mode mark-active)
                "Query replace regexp in region"
              "Query replace regexp")
@@ -431,7 +431,7 @@ which will run faster and will not set the mark or print anything.
 and TO-STRING is also null.)"
   (interactive
    (let ((common
-          (query-replace-read-args 
+          (query-replace-read-args
            (if (and transient-mark-mode mark-active)
                "Replace string in region"
              "Replace string")
@@ -489,10 +489,10 @@ What you probably want is a loop like this:
 which will run faster and will not set the mark or print anything."
   (interactive
    (let ((common
-          (query-replace-read-args 
+          (query-replace-read-args
            (if (and transient-mark-mode mark-active)
-               "Replace regexp in region" 
-             "Replace regexp") 
+               "Replace regexp in region"
+             "Replace regexp")
            t)))
      (list (nth 0 common) (nth 1 common) (nth 2 common)
            (if (and transient-mark-mode mark-active)
@@ -1268,12 +1268,7 @@ but coerced to the correct value of INTEGERS."
              (and (eq new reuse)
                   (eq (null integers) (markerp (car reuse)))
                   new)))
-      (match-data integers
-                  (prog1 reuse
-                    (while reuse
-                      (if (markerp (car reuse))
-                          (set-marker (car reuse) nil))
-                      (setq reuse (cdr reuse)))))))
+      (match-data integers reuse t)))
 
 (defun replace-match-maybe-edit (newtext fixedcase literal noedit match-data)
   "Make a replacement with `replace-match', editing `\\?'.
diff --git a/lisp/rfn-eshadow.el b/lisp/rfn-eshadow.el
index 5fb31561c41..84731115d1a 100644
--- a/lisp/rfn-eshadow.el
+++ b/lisp/rfn-eshadow.el
@@ -113,10 +113,7 @@ system, `file-name-shadow-properties' is used instead."
   :group 'minibuffer)
 
 (defface file-name-shadow
-  '((((background dark))
-     :foreground "grey50")
-    (t
-     :foreground "grey70"))
+  '((t :inherit shadow))
   "Face used by `file-name-shadow-mode' for the shadow."
   :group 'minibuffer)
 
diff --git a/lisp/simple.el b/lisp/simple.el
index 016c48924e0..0d71efcf3bc 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -3342,10 +3342,15 @@ Outline mode sets this."
       (or (memq prop buffer-invisibility-spec)
           (assq prop buffer-invisibility-spec)))))
 
-;; Perform vertical scrolling of tall images if necessary.
-;; Don't vscroll in a keyboard macro.
+;; This is like line-move-1 except that it also performs
+;; vertical scrolling of tall images if appropriate.
+;; That is not really a clean thing to do, since it mixes
+;; scrolling with cursor motion.  But so far we don't have
+;; a cleaner solution to the problem of making C-n do something
+;; useful given a tall image.
 (defun line-move (arg &optional noerror to-end try-vscroll)
   (if (and auto-window-vscroll try-vscroll
+           ;; But don't vscroll in a keyboard macro.
            (not defining-kbd-macro)
            (not executing-kbd-macro))
       (let ((forward (> arg 0))
@@ -3368,6 +3373,8 @@ Outline mode sets this."
               ;; Update display before calling pos-visible-in-window-p,
               ;; because it depends on window-start being up-to-date.
               (sit-for 0)
+              ;; If the current line is partly hidden at the bottom,
+              ;; scroll it partially up so as to unhide the bottom.
               (if (and (setq part (nth 2 (pos-visible-in-window-p
                                           (line-beginning-position) nil t)))
                        (> (cdr part) 0))
@@ -4833,7 +4840,11 @@ of the differing parts is, by contrast, slightly highlighted."
                     (- (point) (minibuffer-prompt-end)))))
         ;; Otherwise, in minibuffer, the whole input is being completed.
         (if (minibufferp mainbuf)
-            (setq completion-base-size 0)))
+            (if (and (symbolp minibuffer-completion-table)
+                     (get minibuffer-completion-table 'completion-base-size-function))
+                (setq completion-base-size 
+                      (funcall (get minibuffer-completion-table 'completion-base-size-function)))
+              (setq completion-base-size 0))))
       ;; Put faces on first uncommon characters and common parts.
       (when completion-base-size
         (let* ((common-string-length
diff --git a/lisp/subr.el b/lisp/subr.el
index 2fe94e2a3c5..71d20ba350e 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1970,7 +1970,7 @@ The value returned is the value of the last form in BODY."
         '((save-match-data-internal (match-data)))
         (list 'unwind-protect
               (cons 'progn body)
-              '(set-match-data save-match-data-internal))))
+              '(set-match-data save-match-data-internal 'evaporate))))
 
 (defun match-string (num &optional string)
   "Return string of text matched by last search.
diff --git a/lisp/textmodes/flyspell.el b/lisp/textmodes/flyspell.el
index 500c9c4e113..0326510f75f 100644
--- a/lisp/textmodes/flyspell.el
+++ b/lisp/textmodes/flyspell.el
@@ -228,7 +228,6 @@ http://strw.leidenuniv.nl/~dominik/Tools"
   :version "21.1"
   :type 'boolean)
 
-;;;###autoload
 (defcustom flyspell-mode-line-string " Fly"
   "*String displayed on the modeline when flyspell is active.
 Set this to nil if you don't want a modeline indicator."
@@ -268,11 +267,7 @@ If `flyspell-large-region' is nil, all regions are treated as small."
   :type 'boolean)
 
 (defcustom flyspell-auto-correct-binding
-  (cond
-   ((eq flyspell-emacs 'xemacs)
-    [(control \;)])
-   (t
-    [?\C-\;]))
+  [(control ?\;)]
   "The key binding for flyspell auto correction."
   :group 'flyspell)
 
@@ -410,10 +405,6 @@ property of the major mode name.")
 ;*---------------------------------------------------------------------*/
 (eval-when-compile (defvar flyspell-local-mouse-map))
 
-;;;###autoload
-(defvar flyspell-mode nil)
-(make-variable-buffer-local 'flyspell-mode)
-
 (defvar flyspell-mouse-map
   (let ((map (make-sparse-keymap)))
     (if flyspell-use-meta-tab
@@ -425,26 +416,18 @@ property of the major mode name.")
     (define-key map [(control \.)] 'flyspell-auto-correct-word)
     map))
 
-;;;###autoload
-(defvar flyspell-mode-map (make-sparse-keymap))
-
-;; mouse, keyboard bindings and misc definition
-(when (or (assoc 'flyspell-mode minor-mode-map-alist)
-          (setq minor-mode-map-alist
-                (cons (cons 'flyspell-mode flyspell-mode-map)
-                      minor-mode-map-alist)))
-  (if flyspell-use-meta-tab
-      (define-key flyspell-mode-map "\M-\t" 'flyspell-auto-correct-word))
-  (cond
-   ((eq flyspell-emacs 'xemacs)
-    (define-key flyspell-mode-map flyspell-auto-correct-binding 'flyspell-auto-correct-previous-word)
-    (define-key flyspell-mode-map [(control \,)] 'flyspell-goto-next-error)
-    (define-key flyspell-mode-map [(control \.)] 'flyspell-auto-correct-word))
-   (flyspell-use-local-map
-    (define-key flyspell-mode-map flyspell-auto-correct-binding 'flyspell-auto-correct-previous-word)
-    (define-key flyspell-mode-map [?\C-\,] 'flyspell-goto-next-error)
-    (define-key flyspell-mode-map [?\C-\.] 'flyspell-auto-correct-word))))
-
+(defvar flyspell-mode-map
+  (let ((map (make-sparse-keymap)))
+    ;; mouse, keyboard bindings and misc definition
+    (if flyspell-use-meta-tab
+      (define-key map "\M-\t" 'flyspell-auto-correct-word))
+    (cond
+     ;; I don't understand this test, so I left it as is.  --Stef
+     ((or (featurep 'xemacs) flyspell-use-local-map)
+      (define-key map flyspell-auto-correct-binding 'flyspell-auto-correct-previous-word)
+      (define-key map [(control ?\,)] 'flyspell-goto-next-error)
+      (define-key map [(control ?\.)] 'flyspell-auto-correct-word)))
+    map))
 
 ;; the name of the overlay property that defines the keymap
 (defvar flyspell-overlay-keymap-property-name 'keymap)
@@ -462,20 +445,14 @@ property of the major mode name.")
 ;*    Highlighting                                                     */
 ;*---------------------------------------------------------------------*/
 (defface flyspell-incorrect-face
-  (if (eq flyspell-emacs 'xemacs)
-      '((((class color)) (:foreground "OrangeRed" :bold t :underline t))
-        (t (:bold t)))
-    '((((class color)) (:foreground "OrangeRed" :weight bold :underline t))
-      (t (:weight bold))))
+  '((((class color)) (:foreground "OrangeRed" :bold t :underline t))
+    (t (:bold t)))
   "Face used for marking a misspelled word in Flyspell."
   :group 'flyspell)
 
 (defface flyspell-duplicate-face
-  (if (eq flyspell-emacs 'xemacs)
-      '((((class color)) (:foreground "Gold3" :bold t :underline t))
-        (t (:bold t)))
-    '((((class color)) (:foreground "Gold3" :weight bold :underline t))
-      (t (:weight bold))))
+  '((((class color)) (:foreground "Gold3" :bold t :underline t))
+    (t (:bold t)))
   "Face used for marking a misspelled word that appears twice in the buffer.
 See also `flyspell-duplicate-distance'."
   :group 'flyspell)
@@ -486,7 +463,7 @@ See also `flyspell-duplicate-distance'."
 ;*    flyspell-mode ...                                                */
 ;*---------------------------------------------------------------------*/
 ;;;###autoload
-(defun flyspell-mode (&optional arg)
+(define-minor-mode flyspell-mode
   "Minor mode performing on-the-fly spelling checking.
 This spawns a single Ispell process and checks each word.
 The default flyspell behavior is to highlight incorrect words.
@@ -514,28 +491,12 @@ in your .emacs file.
 
 \\[flyspell-region] checks all words inside a region.
 \\[flyspell-buffer] checks the whole buffer."
-  (interactive "P")
-  (let ((old-flyspell-mode flyspell-mode))
-    ;; Mark the mode as on or off.
-    (setq flyspell-mode (not (or (and (null arg) flyspell-mode)
-                                 (<= (prefix-numeric-value arg) 0))))
-    ;; Do the real work.
-    (unless (eq flyspell-mode old-flyspell-mode)
-      (if flyspell-mode
-          (flyspell-mode-on)
-        (flyspell-mode-off))
-      ;; Force modeline redisplay.
-      (set-buffer-modified-p (buffer-modified-p)))))
-
-;*---------------------------------------------------------------------*/
-;*    Autoloading                                                      */
-;*---------------------------------------------------------------------*/
-;;;###autoload
-(add-minor-mode 'flyspell-mode
-                'flyspell-mode-line-string
-                flyspell-mode-map
-                nil
-                'flyspell-mode)
+  :lighter flyspell-mode-line-string
+  :keymap flyspell-mode-map
+  :group 'flyspell
+  (if flyspell-mode
+      (flyspell-mode-on)
+    (flyspell-mode-off)))
 
 ;*---------------------------------------------------------------------*/
 ;*    flyspell-buffers ...                                             */
@@ -1057,8 +1018,7 @@ Mostly we check word delimiters."
           (cond
            ((and (or (not (eq ispell-parser 'tex))
                      (and (> start (point-min))
-                          (not (eq (char-after (1- start)) ?}))
-                          (not (eq (char-after (1- start)) ?\\))))
+                          (not (memq (char-after (1- start)) '(?\} ?\\)))))
                  flyspell-mark-duplications-flag
                  (save-excursion
                    (goto-char (1- start))
@@ -1181,20 +1141,21 @@ Mostly we check word delimiters."
 ;*    time that function is called.                                    */
 ;*---------------------------------------------------------------------*/
 (defun flyspell-math-tex-command-p ()
-  (cond
-   (flyspell-check-tex-math-command
-    nil)
-   ((eq flyspell-tex-math-initialized t)
-    (texmathp))
-   ((eq flyspell-tex-math-initialized 'error)
-    nil)
-   (t
-    (setq flyspell-tex-math-initialized t)
-    (condition-case nil
-        (texmathp)
-      (error (progn
-               (setq flyspell-tex-math-initialized 'error)
-               nil))))))
+  (when (fboundp 'texmathp)
+    (cond
+     (flyspell-check-tex-math-command
+      nil)
+     ((eq flyspell-tex-math-initialized t)
+      (texmathp))
+     ((eq flyspell-tex-math-initialized 'error)
+      nil)
+     (t
+      (setq flyspell-tex-math-initialized t)
+      (condition-case nil
+          (texmathp)
+        (error (progn
+                 (setq flyspell-tex-math-initialized 'error)
+                 nil)))))))
 
 ;*---------------------------------------------------------------------*/
 ;*    flyspell-tex-command-p ...                                       */
@@ -1381,9 +1342,7 @@ Word syntax described by `flyspell-dictionary-alist' (which see)."
   (let ((buffer flyspell-external-ispell-buffer))
     (set-buffer buffer)
     (goto-char (point-min))
-    (let ((size (- flyspell-large-region-end flyspell-large-region-beg))
-          (start flyspell-large-region-beg)
-          (pword "")
+    (let ((pword "")
           (pcount 1))
       ;; now we are done with ispell, we have to find the word in
       ;; the initial buffer
@@ -1954,7 +1913,7 @@ The word checked is the word at the mouse position."
           (let ((start (car (cdr word)))
                 (end (car (cdr (cdr word))))
                 (word (car word))
-                poss replace)
+                poss)
             ;; now check spelling of word.
             (process-send-string ispell-process "%\n") ;put in verbose mode
             (process-send-string ispell-process (concat "^" word "\n"))
@@ -1972,89 +1931,65 @@ The word checked is the word at the mouse position."
              ((null poss)
               ;; ispell error
               (error "Ispell: error in Ispell process"))
-             ((string-match "GNU" (emacs-version))
-              ;; the word is incorrect, we have to propose a replacement
-              (setq replace (flyspell-emacs-popup event poss word))
-              (cond ((eq replace 'ignore)
-                     (goto-char save)
-                     nil)
-                    ((eq replace 'save)
-                     (goto-char save)
-                     (process-send-string ispell-process
-                                          (concat "*" word "\n"))
-                     (flyspell-unhighlight-at cursor-location)
-                     (setq ispell-pdict-modified-p '(t)))
-                    ((or (eq replace 'buffer) (eq replace 'session))
-                     (process-send-string ispell-process
-                                          (concat "@" word "\n"))
-                     (if (null ispell-pdict-modified-p)
-                         (setq ispell-pdict-modified-p
-                               (list ispell-pdict-modified-p)))
-                     (flyspell-unhighlight-at cursor-location)
-                     (goto-char save)
-                     (if (eq replace 'buffer)
-                         (ispell-add-per-file-word-list word)))
-                    (replace
-                     (flyspell-unhighlight-at cursor-location)
-                     (let ((new-word (if (atom replace)
-                                         replace
-                                       (car replace)))
-                           (cursor-location
-                            (+ (- (length word) (- end start))
-                               cursor-location)))
-                       (if (not (equal new-word (car poss)))
-                           (let ((old-max (point-max)))
-                             (delete-region start end)
-                             (funcall flyspell-insert-function new-word)
-                             (if flyspell-abbrev-p
-                                 (flyspell-define-abbrev word new-word))
-                             (flyspell-ajust-cursor-point save
-                                                          cursor-location
-                                                          old-max)))))
-                    (t
-                     (goto-char save)
-                     nil)))
-             ((eq flyspell-emacs 'xemacs)
+             ((featurep 'xemacs)
               (flyspell-xemacs-popup
-               event poss word cursor-location start end save)
-              (goto-char save)))
+               event poss word cursor-location start end save))
+             (t
+              ;; The word is incorrect, we have to propose a replacement.
+              (flyspell-do-correct (flyspell-emacs-popup event poss word)
+                                   poss word cursor-location start end save)))
             (ispell-pdict-save t))))))
 
 ;*---------------------------------------------------------------------*/
-;*    flyspell-xemacs-correct ...                                      */
+;*    flyspell-do-correct ...                                      */
 ;*---------------------------------------------------------------------*/
-(defun flyspell-xemacs-correct (replace poss word cursor-location start end save)
-  "The xemacs popup menu callback."
+(defun flyspell-do-correct (replace poss word cursor-location start end save)
+  "The popup menu callback."
+  ;; Originally, the XEmacs code didn't do the (goto-char save) here and did
+  ;; it instead right after calling the function.
   (cond ((eq replace 'ignore)
+         (goto-char save)
          nil)
         ((eq replace 'save)
-         (process-send-string ispell-process (concat "*" word "\n"))
-         (process-send-string ispell-process "#\n")
+         (goto-char save)
+         (ispell-send-string (concat "*" word "\n"))
+         ;; This was added only to the XEmacs side in revision 1.18 of
+         ;; flyspell.  I assume its absence on the Emacs side was an
+         ;; oversight.  --Stef
+         (ispell-send-string "#\n")
          (flyspell-unhighlight-at cursor-location)
          (setq ispell-pdict-modified-p '(t)))
         ((or (eq replace 'buffer) (eq replace 'session))
-         (process-send-string ispell-process (concat "@" word "\n"))
+         (ispell-send-string (concat "@" word "\n"))
          (flyspell-unhighlight-at cursor-location)
          (if (null ispell-pdict-modified-p)
              (setq ispell-pdict-modified-p
                    (list ispell-pdict-modified-p)))
+         (goto-char save)
          (if (eq replace 'buffer)
              (ispell-add-per-file-word-list word)))
         (replace
+         ;; This was added only to the Emacs side.  I assume its absence on
+         ;; the XEmacs side was an oversight.  --Stef
+         (flyspell-unhighlight-at cursor-location)
          (let ((old-max (point-max))
                (new-word (if (atom replace)
                              replace
                            (car replace)))
                (cursor-location (+ (- (length word) (- end start))
                                    cursor-location)))
-           (if (not (equal new-word (car poss)))
-               (progn
-                 (delete-region start end)
-                 (goto-char start)
-                 (funcall flyspell-insert-function new-word)
-                 (if flyspell-abbrev-p
-                     (flyspell-define-abbrev word new-word))))
-           (flyspell-ajust-cursor-point save cursor-location old-max)))))
+           (unless (equal new-word (car poss))
+             (delete-region start end)
+             (goto-char start)
+             (funcall flyspell-insert-function new-word)
+             (if flyspell-abbrev-p
+                 (flyspell-define-abbrev word new-word)))
+           ;; In the original Emacs code, this was only called in the body
+           ;; of the if.  I arbitrarily kept the XEmacs behavior instead.
+           (flyspell-ajust-cursor-point save cursor-location old-max)))
+        (t
+         (goto-char save)
+         nil)))
 
 ;*---------------------------------------------------------------------*/
 ;*    flyspell-ajust-cursor-point ...                                  */
@@ -2123,7 +2058,7 @@ The word checked is the word at the mouse position."
          (cor-menu   (if (consp corrects)
                          (mapcar (lambda (correct)
                                    (vector correct
-                                           (list 'flyspell-xemacs-correct
+                                           (list 'flyspell-do-correct
                                                  correct
                                                  (list 'quote poss)
                                                  word
@@ -2138,7 +2073,7 @@ The word checked is the word at the mouse position."
          (menu       (let ((save (if (consp affix)
                                      (vector
                                       (concat "Save affix: " (car affix))
-                                      (list 'flyspell-xemacs-correct
+                                      (list 'flyspell-do-correct
                                             ''save
                                             (list 'quote poss)
                                             word
@@ -2149,7 +2084,7 @@ The word checked is the word at the mouse position."
                                       t)
                                    (vector
                                     "Save word"
-                                    (list 'flyspell-xemacs-correct
+                                    (list 'flyspell-do-correct
                                           ''save
                                           (list 'quote poss)
                                           word
@@ -2159,7 +2094,7 @@ The word checked is the word at the mouse position."
                                           save)
                                     t)))
                            (session (vector "Accept (session)"
-                                            (list 'flyspell-xemacs-correct
+                                            (list 'flyspell-do-correct
                                                   ''session
                                                   (list 'quote poss)
                                                   word
@@ -2169,7 +2104,7 @@ The word checked is the word at the mouse position."
                                                   save)
                                             t))
                            (buffer  (vector "Accept (buffer)"
-                                            (list 'flyspell-xemacs-correct
+                                            (list 'flyspell-do-correct
                                                   ''buffer
                                                   (list 'quote poss)
                                                   word
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 6aff0a731c7..5b0542edaf2 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -796,19 +796,16 @@ Otherwise returns the library directory name, if that is defined."
                     nil t)
             case-fold-search case-fold-search-val)
       (if (or (not status)      ; major version mismatch
-              (< (car (read-from-string (buffer-substring-no-properties
-                                         (match-beginning 2) (match-end 2))))
+              (< (car (read-from-string (match-string-no-properties 2)))
                  (car (cdr ispell-required-version)))) ; minor version mismatch
           (error "%s version 3 release %d.%d.%d or greater is required"
                  ispell-program-name (car ispell-required-version)
                  (car (cdr ispell-required-version))
                  (car (cdr (cdr ispell-required-version))))
         ;; check that it is the correct version.
-        (if (and (= (car (read-from-string (buffer-substring-no-properties
-                                            (match-beginning 2)(match-end 2))))
+        (if (and (= (car (read-from-string (match-string-no-properties 2)))
                     (car (cdr ispell-required-version)))
-                 (< (car (read-from-string (buffer-substring-no-properties
-                                            (match-beginning 3)(match-end 3))))
+                 (< (car (read-from-string (match-string-no-properties 3)))
                     (car (cdr (cdr ispell-required-version)))))
           (setq ispell-offset 0))
         ;; Check to see if it's really aspell.
@@ -2537,9 +2534,7 @@ Return nil if spell session is quit,
                               (ispell-begin-skip-region-regexp)
                               ispell-region-end t))
                         (progn
-                          (setq key (buffer-substring-no-properties
-                                     (car (match-data))
-                                     (car (cdr (match-data)))))
+                          (setq key (match-string-no-properties 0))
                           (set-marker skip-region-start
                                       (- (point) (length key)))
                           (goto-char rstart))
@@ -3480,8 +3475,7 @@ Includes Latex/Nroff modes and extended character mode."
           (search-forward ispell-parsing-keyword)
           (while (re-search-forward " *\\([^ \"]+\\)" end t)
             ;; space separated definitions.
-            (setq string (downcase (buffer-substring-no-properties
-                                    (match-beginning 1) (match-end 1))))
+            (setq string (downcase (match-string-no-properties 1)))
             (cond ((and (string-match "latex-mode" string)
                         (not (eq 'exclusive ispell-check-comments)))
                    (ispell-send-string "+\n~tex\n"))
@@ -3514,8 +3508,7 @@ Both should not be used to define a buffer-local dictionary."
               (setq end (save-excursion (end-of-line) (point)))
               (if (re-search-forward " *\\([^ \"]+\\)" end t)
                   (setq ispell-local-dictionary
-                        (buffer-substring-no-properties (match-beginning 1)
-                                                        (match-end 1)))))))
+                        (match-string-no-properties 1))))))
       (goto-char (point-max))
       (if (search-backward ispell-pdict-keyword nil t)
           (progn
@@ -3523,8 +3516,7 @@ Both should not be used to define a buffer-local dictionary."
             (setq end (save-excursion (end-of-line) (point)))
             (if (re-search-forward " *\\([^ \"]+\\)" end t)
                 (setq ispell-local-pdict
-                      (buffer-substring-no-properties (match-beginning 1)
-                                                      (match-end 1))))))))
+                      (match-string-no-properties 1)))))))
   ;; Reload if new personal dictionary defined.
   (if (and ispell-local-pdict
            (not (equal ispell-local-pdict ispell-personal-dictionary)))
@@ -3554,8 +3546,7 @@ Both should not be used to define a buffer-local dictionary."
         ;; buffer-local words separated by a space, and can contain
         ;; any character other than a space.  Not rigorous enough.
         (while (re-search-forward " *\\([^ ]+\\)" end t)
-          (setq string (buffer-substring-no-properties (match-beginning 1)
-                                                       (match-end 1)))
+          (setq string (match-string-no-properties 1))
           ;; This can fail when string contains a word with illegal chars.
           ;; Error handling needs to be added between ispell and emacs.
           (if (and (< 1 (length string))
diff --git a/lisp/textmodes/org.el b/lisp/textmodes/org.el
index bbc59768aaf..d13a7514c16 100644
--- a/lisp/textmodes/org.el
+++ b/lisp/textmodes/org.el
@@ -154,8 +154,6 @@
 (require 'outline)
 (require 'time-date)
 (require 'easymenu)
-(or (fboundp 'run-mode-hooks)
-    (defalias 'run-mode-hooks 'run-hooks))
 
 ;;; Customization variables
 
@@ -384,6 +382,12 @@ or contain a special line
 If the file does not specify a category, then file's base name
 is used instead.")
 
+(defun org-run-mode-hooks (&rest hooks)
+  "Call `run-mode-hooks' if it is available; otherwise call `run-hooks'."
+  (if (fboundp 'run-mode-hooks)
+      (apply 'run-mode-hooks hooks)
+    (apply 'run-hooks hooks)))
+
 (defun org-set-regexps-and-options ()
   "Precompute regular expressions for current buffer."
   (when (eq major-mode 'org-mode)
@@ -3118,7 +3122,7 @@ The following commands are available:
      "--")
    (mapcar 'org-file-menu-entry org-agenda-files)))
   (org-agenda-set-mode-name)
-  (run-mode-hooks 'org-agenda-mode-hook))
+  (org-run-mode-hooks 'org-agenda-mode-hook))
 
 (define-key org-agenda-mode-map [(tab)] 'org-agenda-goto)
 (define-key org-agenda-mode-map [(return)] 'org-agenda-switch-to)
diff --git a/lisp/textmodes/tex-mode.el b/lisp/textmodes/tex-mode.el
index 3b5bab5b4dc..91f714af9d9 100644
--- a/lisp/textmodes/tex-mode.el
+++ b/lisp/textmodes/tex-mode.el
@@ -795,7 +795,7 @@ Inherits `shell-mode-map' with a few additions.")
                       (regexp-opt '("documentstyle" "documentclass"
                                     "begin" "subsection" "section"
                                     "part" "chapter" "newcommand"
-                                    "renewcommand") 'words)
+                                    "renewcommand" "RequirePackage") 'words)
                       "\\|NeedsTeXFormat{LaTeX")))
                   (if (and (looking-at
                             "document\\(style\\|class\\)\\(\\[.*\\]\\)?{slides}")
@@ -1639,9 +1639,12 @@ If NOT-ALL is non-nil, save the `.dvi' file."
              " " (if (< 0 (length tex-start-commands))
                      (shell-quote-argument tex-start-commands)) " %f")
      t "%r.dvi")
-    ("yap %r &" "%r.dvi")
     ("xdvi %r &" "%r.dvi")
+    ("xpdf %r.pdf &" "%r.pdf")
+    ("gv %r.ps &" "%r.ps")
+    ("yap %r &" "%r.dvi")
     ("advi %r &" "%r.dvi")
+    ("gv %r.pdf &" "%r.pdf")
     ("bibtex %r" "%r.aux" "%r.bbl")
     ("makeindex %r" "%r.idx" "%r.ind")
     ("texindex %r.??")
@@ -1649,9 +1652,6 @@ If NOT-ALL is non-nil, save the `.dvi' file."
     ("dvipdf %r" "%r.dvi" "%r.pdf")
     ("dvips -o %r.ps %r" "%r.dvi" "%r.ps")
     ("ps2pdf %r.ps" "%r.ps" "%r.pdf")
-    ("gv %r.ps &" "%r.ps")
-    ("gv %r.pdf &" "%r.pdf")
-    ("xpdf %r.pdf &" "%r.pdf")
     ("lpr %r.ps" "%r.ps"))
   "List of commands for `tex-compile'.
 Each element should be of the form (FORMAT IN OUT) where
@@ -1830,8 +1830,7 @@ FILE is typically the output DVI or PDF file."
             (push cmd cmds)
           (push (nth 1 cmd) unchanged-in))))
     ;; If no command seems to be applicable, arbitrarily pick the first one.
-    (unless cmds
-      (setq cmds (list (car tex-compile-commands))))
+    (setq cmds (if cmds (nreverse cmds) (list (car tex-compile-commands))))
     ;; Remove those commands whose input was considered stable for
     ;; some other command (typically if (t . "%.pdf") is inactive
     ;; then we're using pdflatex and the fact that the dvi file
@@ -1841,7 +1840,7 @@ FILE is typically the output DVI or PDF file."
         (unless (member (nth 1 cmd) unchanged-in)
           (push cmd tmp)))
       ;; Only remove if there's something left.
-      (if tmp (setq cmds tmp)))
+      (if tmp (setq cmds (nreverse tmp))))
     ;; Remove commands whose input is not uptodate either.
     (let ((outs (delq nil (mapcar (lambda (x) (nth 2 x)) cmds)))
           (tmp nil))
@@ -1849,7 +1848,7 @@ FILE is typically the output DVI or PDF file."
         (unless (member (nth 1 cmd) outs)
           (push cmd tmp)))
       ;; Only remove if there's something left.
-      (if tmp (setq cmds tmp)))
+      (if tmp (setq cmds (nreverse tmp))))
     ;; Select which file we're going to operate on (the latest).
     (let ((latest (nth 1 (car cmds))))
       (dolist (cmd (prog1 (cdr cmds) (setq cmds (list (car cmds)))))
diff --git a/lisp/thumbs.el b/lisp/thumbs.el
index 321fe7266cc..0fa44a3b8ee 100644
--- a/lisp/thumbs.el
+++ b/lisp/thumbs.el
@@ -65,8 +65,7 @@
   :version "22.1"
   :group 'multimedia)
 
-(defcustom thumbs-thumbsdir
-  (expand-file-name "~/.emacs-thumbs")
+(defcustom thumbs-thumbsdir "~/.emacs-thumbs"
   "*Directory to store thumbnails."
   :type 'directory
   :group 'thumbs)
@@ -83,12 +82,12 @@
 
 (defcustom thumbs-thumbsdir-max-size 50000000
   "Max size for thumbnails directory.
-When it reachs that size (in bytes), a warning is sent."
+When it reaches that size (in bytes), a warning is sent."
   :type 'string
   :group 'thumbs)
 
 (defcustom thumbs-conversion-program
-  (if (equal 'windows-nt system-type)
+  (if (eq system-type 'windows-nt)
       "convert.exe"
     (or (executable-find "convert")
         "/usr/X11R6/bin/convert"))
@@ -117,20 +116,19 @@ This is where you see the cursor."
 (defcustom thumbs-thumbsdir-auto-clean t
   "If set, delete older file in the thumbnails directory.
 Deletion is done at load time when the directory size is bigger
-than 'thumbs-thumbsdir-max-size'."
+than `thumbs-thumbsdir-max-size'."
   :type 'boolean
   :group 'thumbs)
 
 (defcustom thumbs-image-resizing-step 10
-  "Step by wich to resize image."
+  "Step by which to resize image."
   :type 'string
   :group 'thumbs)
 
-(defcustom thumbs-temp-dir
-  "/tmp/"
+(defcustom thumbs-temp-dir temporary-file-directory
   "Temporary directory to use.
-Leaving it to default '/tmp/' can let another user
-see some of your images."
+Defaults to `temporary-file-directory'.  Leaving it to
+this value can let another user see some of your images."
   :type 'directory
   :group 'thumbs)
 
@@ -140,10 +138,6 @@ see some of your images."
   :group 'thumbs)
 
 ;; Initialize some variable, for later use.
-(defvar thumbs-temp-file
-  (concat thumbs-temp-dir thumbs-temp-prefix)
-  "Temporary filename for images.")
-
 (defvar thumbs-current-tmp-filename
   nil
   "Temporary filename of current image.")
@@ -163,28 +157,36 @@ see some of your images."
   nil
   "List of marked files.")
 
-;; Make sure auto-image-file-mode is ON.
-(auto-image-file-mode t)
-
-;; Create the thumbs directory if it does not exists.
-(setq thumbs-thumbsdir (expand-file-name thumbs-thumbsdir))
-
-(when (not (file-directory-p thumbs-thumbsdir))
-  (progn
-    (make-directory thumbs-thumbsdir)
-    (message "Creating thumbnails directory")))
-
-(defvar thumbs-gensym-counter 0)
-
-(defun thumbs-gensym (&optional arg)
-  "Generate a new uninterned symbol.
-The name is made by appending a number to PREFIX, default \"Thumbs\"."
-  (let ((prefix (if (stringp arg) arg "Thumbs"))
-        (num (if (integerp arg) arg
-               (prog1
-                   thumbs-gensym-counter
-                 (setq thumbs-gensym-counter (1+ thumbs-gensym-counter))))))
-    (make-symbol (format "%s%d" prefix num))))
+(defalias 'thumbs-gensym
+    (if (fboundp 'gensym)
+        'gensym
+      ;; Copied from cl-macs.el
+      (defvar thumbs-gensym-counter 0)
+      (lambda (&optional prefix)
+        "Generate a new uninterned symbol.
+The name is made by appending a number to PREFIX, default \"G\"."
+        (let ((pfix (if (stringp prefix) prefix "G"))
+              (num (if (integerp prefix) prefix
+                     (prog1 thumbs-gensym-counter
+                       (setq thumbs-gensym-counter
+                             (1+ thumbs-gensym-counter))))))
+          (make-symbol (format "%s%d" pfix num))))))
+
+(defun thumbs-temp-file ()
+  "Return a unique temporary filename for an image."
+  (format "%s%s-%s.jpg"
+          (expand-file-name thumbs-temp-dir)
+          thumbs-temp-prefix
+          (thumbs-gensym "T")))
+
+(defun thumbs-thumbsdir ()
+  "Return the current thumbnails directory (from `thumbs-thumbsdir').
+Create the thumbnails directory if it does not exist."
+  (let ((thumbs-thumbsdir (expand-file-name thumbs-thumbsdir)))
+    (unless (file-directory-p thumbs-thumbsdir)
+      (make-directory thumbs-thumbsdir)
+      (message "Creating thumbnails directory"))
+    thumbs-thumbsdir))
 
 (defun thumbs-cleanup-thumbsdir ()
   "Clean the thumbnails directory.
@@ -197,8 +199,8 @@ reached."
             (lambda (f)
               (let ((fattribsL (file-attributes f)))
                 `(,(nth 4 fattribsL) ,(nth 7 fattribsL) ,f)))
-            (directory-files thumbs-thumbsdir t (image-file-name-regexp)))
-           '(lambda (l1 l2) (time-less-p (car l1)(car l2)))))
+            (directory-files (thumbs-thumbsdir) t (image-file-name-regexp)))
+           '(lambda (l1 l2) (time-less-p (car l1) (car l2)))))
          (dirsize (apply '+ (mapcar (lambda (x) (cadr x)) filesL))))
     (while (> dirsize thumbs-thumbsdir-max-size)
       (progn
@@ -258,7 +260,7 @@ ACTION-PREFIX is the symbol to place before the ACTION command
 
 (defun thumbs-resize-image (&optional increment size)
   "Resize image in current buffer.
-if INCREMENT is set, make the image bigger, else smaller.
+If INCREMENT is set, make the image bigger, else smaller.
 Or, alternatively, a SIZE may be specified."
   (interactive)
   ;; cleaning of old temp file
@@ -276,7 +278,7 @@ Or, alternatively, a SIZE may be specified."
                   thumbs-current-image-size)
                (thumbs-decrement-image-size
                 thumbs-current-image-size))))
-        (tmp (format "%s%s.jpg" thumbs-temp-file (thumbs-gensym))))
+        (tmp (thumbs-temp-file)))
     (erase-buffer)
     (thumbs-call-convert thumbs-current-image-filename
                          tmp "sample"
@@ -286,7 +288,7 @@ Or, alternatively, a SIZE may be specified."
     (setq thumbs-current-tmp-filename tmp)))
 
 (defun thumbs-resize-interactive (width height)
-  "Resize Image interactively to specified WIDTH and HEIGHT."
+  "Resize image interactively to specified WIDTH and HEIGHT."
   (interactive "nWidth: \nnHeight: ")
   (thumbs-resize-image nil (cons width height)))
 
@@ -305,7 +307,7 @@ Or, alternatively, a SIZE may be specified."
   (convert-standard-filename
    (let ((filename (expand-file-name img)))
      (format "%s/%08x-%s.jpg"
-             thumbs-thumbsdir
+             (thumbs-thumbsdir)
              (sxhash filename)
              (subst-char-in-string
               ?\s ?\_
@@ -562,11 +564,7 @@ Open another window."
 (defun thumbs-kill-buffer ()
   "Kill the current buffer."
   (interactive)
-  (let ((buffer (current-buffer)))
-    (condition-case nil
-        (delete-window (selected-window))
-      (error nil))
-    (kill-buffer buffer)))
+  (quit-window t (selected-window)))
 
 (defun thumbs-show-image-num (num)
   "Show the image with number NUM."
@@ -643,7 +641,7 @@ ACTION and ARG should be a valid convert command."
          t
          thumbs-temp-prefix))
   (let ((buffer-read-only nil)
-        (tmp (format "%s%s.jpg" thumbs-temp-file (thumbs-gensym))))
+        (tmp (thumbs-temp-file)))
     (erase-buffer)
     (thumbs-call-convert thumbs-current-image-filename
                          tmp
diff --git a/lisp/tmm.el b/lisp/tmm.el
index 51e04941730..aa47012c642 100644
--- a/lisp/tmm.el
+++ b/lisp/tmm.el
@@ -133,9 +133,8 @@ specify nil for this variable."
   :type '(choice integer (const nil))
   :group 'tmm)
 
-(require 'font-lock)
-(defface tmm-inactive-face
-  '((t :inherit font-lock-comment-face))
+(defface tmm-inactive
+  '((t :inherit shadow))
   "Face used for inactive menu items."
   :group 'tmm)
 
@@ -350,7 +349,7 @@ Stores a list of all the shortcuts in the free variable `tmm-short-cuts'."
         (setq next (next-single-char-property-change (point) 'mouse-face))
         (when (looking-at inactive-string)
           (remove-text-properties (point) next '(mouse-face))
-          (add-text-properties (point) next '(face tmm-inactive-face)))
+          (add-text-properties (point) next '(face tmm-inactive)))
         (goto-char next)))
     (set-buffer-modified-p nil)))