Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-17

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-417
 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-419
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-420
   Tweak permissions

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-421
 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-430
   Update from CVS

20 files changed, 501 insertions, 211 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 70f7255782a..effae29fc8f 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,112 @@
+2004-06-29  Kim F. Storm  <storm@cua.dk>
+
+        * progmodes/gdb-ui.el (breakpoint-enabled-bitmap-face)
+        (breakpoint-disabled-bitmap-face): Add :group 'gud.
+
+        * progmodes/ada-xref.el (ada-tight-gvd-integration):
+        Add :group 'ada.
+
+        * vc-arch.el (vc-arch-mode-line-rewrite): Add :group 'vc.
+
+2004-06-29  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (query-replace-read-args): Swallow a space after
+        everything except )]" which in most cases means after a symbol.
+
+        * emacs-lisp/pp.el (pp-buffer): Add autoload.
+
+2004-06-26  David Kastrup  <dak@gnu.org>
+
+        * replace.el (perform-replace): Highlight the match even in
+        non-query mode if there is potential replace string editing.
+
+2004-06-26  Kai Grossjohann  <kai.grossjohann@gmx.net>
+
+        * net/tramp.el (tramp-handle-file-remote-p): New implementation to
+        agree with new return value of `file-remote-p'.
+        This syncs with Tramp 2.0.42.
+
+        * net/ange-ftp.el (ange-ftp-file-remote-p): New return value,
+        according to new documentation of `file-remote-p'.
+
+        * files.el (file-remote-p): Fix doc to say that return value is
+        identification of remote system, if not nil.
+        (file-relative-name): Use new return value of `file-remote-p'.
+
+2004-06-26  Nick Roberts  <nickrob@gnu.org>
+
+        * progmodes/gdb-ui.el (gdb-toggle-breakpoint)
+        (gdb-goto-breakpoint): Fix breakage.
+
+2004-06-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * man.el (Man-getpage-in-background): Add windows-nt to the list
+        of systems where shell-file-name should be used instead of
+        literal "sh".
+
+2004-06-25  Sam Steingold  <sds@gnu.org>
+
+        * add-log.el (change-log-font-lock-keywords): Support Common Lisp
+        function names `(setf symbol)'.
+
+2004-06-24  Richard M. Stallman  <rms@gnu.org>
+
+        * replace.el (query-replace-read-args): Swallow space after \,SYMBOL.
+
+        * font-lock.el (font-lock-keywords): Change format of compiled values.
+        Document it.
+        (font-lock-add-keywords): If font-lock-keywords is compiled,
+        extract the uncompiled version, modify, then recompile.
+        (font-lock-remove-keywords): Likewise.
+        (font-lock-fontify-keywords-region): Handle changed format.
+        (font-lock-compile-keywords): Handle changed format.
+        (font-lock-set-defaults): Compile the keywords explicitly here.
+
+2004-06-24  David Kastrup  <dak@gnu.org>
+
+        * replace.el (query-replace-read-args): Implement `\,' and `\#'
+        replacements here.
+        (query-replace-regexp): Doc string explaining this and the new
+        `\?' replacement.  Remove `\,' and `\#' implementation here, as it
+        is better placed in `query-replace-read-args'.
+        (replace-regexp): Explain `\,', `\#' and `\?'.
+        (replace-match-data): New function for thorough reuse/destruction
+        of old match-data.
+        (replace-match-maybe-edit): Function for implementing `\?'
+        editing.
+        (perform-replace): Fix maintaining of the match stack including
+        already matched regions, implement `\?', fix various problems
+        with regions while editing and other stuff.
+        (replace-highlight): Simplified.
+
+2004-06-24  Daniel Pfeiffer  <occitan@esperanto.org>
+
+        * progmodes/grep.el (grep-error-screen-columns): New variable.
+        (grep-regexp-alist): Give it the full functionality of gnu style
+        compilation messages with line and column ranges.  Ask me for the
+        perl script I'm working on, that uses these.
+
+2004-06-23  Nick Roberts  <nickrob@gnu.org>
+
+        * comint.el: (comint-insert-clicked-input, comint-copy-old-input):
+        Remove.
+        (comint-insert-input, comint-mouse-insert-input): New functions
+        based on comint-insert-clicked-input for two bindings but just
+        one functionality.
+
+2004-06-23  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * net/goto-addr.el (goto-address-fontify): Fix help-echo text.
+
+2004-06-23  Lars Hansen  <larsh@math.ku.dk>
+
+        * files.el (write-contents-functions): Doc fix.
+
+2004-06-21  Juanma Barranquero  <lektu@terra.es>
+
+        * image.el (image-library-alist): Rewrite docstring in active
+        voice.
+
 2004-06-20  Richard M. Stallman  <rms@gnu.org>
 
         * mouse.el (mouse-set-region-1): Set transient-mark-mode to `only'.
diff --git a/lisp/add-log.el b/lisp/add-log.el
index 3c29e8a465e..26faea2ddc3 100644
--- a/lisp/add-log.el
+++ b/lisp/add-log.el
@@ -230,13 +230,16 @@ Note: The search is conducted only within 10%, at the beginning of the file."
      ;; Possibly further names in a list:
      ("\\=, \\([^ ,:([\n]+\\)" nil nil (1 'change-log-file-face))
      ;; Possibly a parenthesized list of names:
-     ("\\= (\\([^) ,\n]+\\)" nil nil (1 'change-log-list-face))
-     ("\\=, *\\([^) ,\n]+\\)" nil nil (1 'change-log-list-face)))
+     ("\\= (\\([^() ,\n]+\\|(\\(setf\\|SETF\\) [^() ,\n]+)\\)"
+      nil nil (1 'change-log-list-face))
+     ("\\=, *\\([^() ,\n]+\\|(\\(setf\\|SETF\\) [^() ,\n]+)\\)"
+      nil nil (1 'change-log-list-face)))
     ;;
     ;; Function or variable names.
-    ("^\t(\\([^) ,\n]+\\)"
+    ("^\t(\\([^() ,\n]+\\|(\\(setf\\|SETF\\) [^() ,\n]+)\\)"
      (1 'change-log-list-face)
-     ("\\=, *\\([^) ,\n]+\\)" nil nil (1 'change-log-list-face)))
+     ("\\=, *\\([^() ,\n]+\\|(\\(setf\\|SETF\\) [^() ,\n]+)\\)" nil nil
+      (1 'change-log-list-face)))
     ;;
     ;; Conditionals.
     ("\\[!?\\([^]\n]+\\)\\]\\(:\\| (\\)" (1 'change-log-conditionals-face))
diff --git a/lisp/comint.el b/lisp/comint.el
index 12d8e1fcbb7..8b5a107c7d7 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -571,7 +571,7 @@ Entry to this mode runs the hooks on `comint-mode-hook'."
   (define-key comint-mode-map "\C-c\C-c" 'comint-interrupt-subjob)
   (define-key comint-mode-map "\C-c\C-z" 'comint-stop-subjob)
   (define-key comint-mode-map "\C-c\C-\\" 'comint-quit-subjob)
-  (define-key comint-mode-map "\C-c\C-m" 'comint-copy-old-input)
+  (define-key comint-mode-map "\C-c\C-m" 'comint-insert-input)
   (define-key comint-mode-map "\C-c\C-o" 'comint-delete-output)
   (define-key comint-mode-map "\C-c\C-r" 'comint-show-output)
   (define-key comint-mode-map "\C-c\C-e" 'comint-show-maximum-output)
@@ -582,7 +582,7 @@ Entry to this mode runs the hooks on `comint-mode-hook'."
   (define-key comint-mode-map "\C-c\C-s" 'comint-write-output)
   (define-key comint-mode-map "\C-c." 'comint-insert-previous-argument)
   ;; Mouse Buttons:
-  (define-key comint-mode-map [mouse-2] 'comint-insert-clicked-input)
+  (define-key comint-mode-map [mouse-2] 'comint-mouse-insert-input)
   ;; Menu bars:
   ;; completion:
   (define-key comint-mode-map [menu-bar completion]
@@ -615,7 +615,7 @@ Entry to this mode runs the hooks on `comint-mode-hook'."
   (define-key comint-mode-map [menu-bar inout kill-input]
     '("Kill Current Input" . comint-kill-input))
   (define-key comint-mode-map [menu-bar inout copy-input]
-    '("Copy Old Input" . comint-copy-old-input))
+    '("Copy Old Input" . comint-insert-input))
   (define-key comint-mode-map [menu-bar inout forward-matching-history]
     '("Forward Matching Input..." . comint-forward-matching-input))
   (define-key comint-mode-map [menu-bar inout backward-matching-history]
@@ -798,11 +798,10 @@ buffer.  The hook `comint-exec-hook' is run after each exec."
         (set-process-coding-system proc decoding encoding))
     proc))
 
-
-(defun comint-insert-clicked-input (event)
-  "In a Comint buffer, set the current input to the clicked-on previous input."
-  (interactive "e")
-  (let ((pos (posn-point (event-end event))))
+(defun comint-insert-input ()
+  "In a Comint buffer, set the current input to the previous input at point."
+  (interactive)
+  (let ((pos (point)))
     (if (not (eq (get-char-property pos 'field) 'input))
         ;; No input at POS, fall back to the global definition.
         (let* ((keys (this-command-keys))
@@ -816,11 +815,16 @@ buffer.  The hook `comint-exec-hook' is run after each exec."
        (or (marker-position comint-accum-marker)
            (process-mark (get-buffer-process (current-buffer))))
        (point))
-      ;; Insert the clicked-upon input
+      ;; Insert the input at point
       (insert (buffer-substring-no-properties
                (previous-single-char-property-change (1+ pos) 'field)
                (next-single-char-property-change pos 'field))))))
 
+(defun comint-mouse-insert-input (event)
+  "In a Comint buffer, set the current input to the previous input you click on."
+  (interactive "e")
+  (mouse-set-point event)
+  (comint-insert-input)) 
 
 
 ;; Input history processing in a buffer
@@ -1858,17 +1862,6 @@ the current line with any initial string matching the regexp
       (comint-bol)
       (buffer-substring-no-properties (point) (line-end-position)))))
 
-(defun comint-copy-old-input ()
-  "Insert after prompt old input at point as new input to be edited.
-Calls `comint-get-old-input' to get old input."
-  (interactive)
-  (let ((input (funcall comint-get-old-input))
-        (process (get-buffer-process (current-buffer))))
-    (if (not process)
-        (error "Current buffer has no process")
-      (goto-char (process-mark process))
-      (insert input))))
-
 (defun comint-skip-prompt ()
   "Skip past the text matching regexp `comint-prompt-regexp'.
 If this takes us past the end of the current line, don't skip at all."
diff --git a/lisp/emacs-lisp/pp.el b/lisp/emacs-lisp/pp.el
index 61d31921e57..93e30fb0f55 100644
--- a/lisp/emacs-lisp/pp.el
+++ b/lisp/emacs-lisp/pp.el
@@ -54,6 +54,7 @@ to make output that `read' can handle, whenever this is possible."
           (buffer-string))
       (kill-buffer (current-buffer)))))
 
+;;;###autoload
 (defun pp-buffer ()
   "Prettify the current buffer with printed representation of a Lisp object."
   (goto-char (point-min))
diff --git a/lisp/files.el b/lisp/files.el
index 1804432ee45..1d500379925 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -393,7 +393,8 @@ updates before the buffer is saved, use `before-save-hook' .")
 (defvar write-contents-functions nil
   "List of functions to be called before writing out a buffer to a file.
 If one of them returns non-nil, the file is considered already written
-and the rest are not called.
+and the rest are not called and neither are the functions in
+`write-file-functions'.
 
 This variable is meant to be used for hooks that pertain to the
 buffer's contents, not to the particular visited file; thus,
@@ -649,7 +650,13 @@ This is an interface to the function `load'."
   (load library))
 
 (defun file-remote-p (file)
-  "Test whether FILE specifies a location on a remote system."
+  "Test whether FILE specifies a location on a remote system.
+Return an identification of the system if the location is indeed
+remote.  The identification of the system may comprise a method
+to access the system and its hostname, amongst other things.
+
+For example, the filename \"/user@host:/foo\" specifies a location
+on the system \"/user@host:\"."
   (let ((handler (find-file-name-handler file 'file-remote-p)))
     (if handler
         (funcall handler 'file-remote-p file)
@@ -2915,8 +2922,8 @@ on a DOS/Windows machine, it returns FILENAME on expanded form."
           (file-name-as-directory (expand-file-name (or directory
                                                         default-directory))))
     (setq filename (expand-file-name filename))
-    (let ((hf (find-file-name-handler filename 'file-remote-p))
-          (hd (find-file-name-handler directory 'file-remote-p)))
+    (let ((fremote (file-remote-p filename))
+          (dremote (file-remote-p directory)))
       (if ;; Conditions for separate trees
           (or
            ;; Test for different drives on DOS/Windows
@@ -2924,20 +2931,8 @@ on a DOS/Windows machine, it returns FILENAME on expanded form."
             ;; Should `cygwin' really be included here?  --stef
             (memq system-type '(ms-dos cygwin windows-nt))
             (not (eq t (compare-strings filename 0 2 directory 0 2))))
-           ;; Test for different remote file handlers
-           (not (eq hf hd))
            ;; Test for different remote file system identification
-           (and
-            hf
-            (let ((re (car (rassq hf file-name-handler-alist))))
-              (not
-               (equal
-                (and
-                 (string-match re filename)
-                 (substring filename 0 (match-end 0)))
-                (and
-                 (string-match re directory)
-                 (substring directory 0 (match-end 0))))))))
+           (not (equal fremote dremote)))
           filename
         (let ((ancestor ".")
               (filename-dir (file-name-as-directory filename)))
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 1f6127f3ea5..9d3fdd6de5f 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -340,7 +340,15 @@ If a number, only buffers greater than this size have fontification messages."
 
 (defvar font-lock-keywords nil
   "A list of the keywords to highlight.
-Each element should have one of these forms:
+There are two kinds of values: user-level, and compiled.
+
+A user-level keywords list is what a major mode or the user would
+set up.  Normally the list would come from `font-lock-defaults'.
+through selection of a fontification level and evaluation of any
+contained expressions.  You can also alter it by calling
+`font-lock-add-keywords' or `font-lock-remove-keywords' with MODE = nil.
+
+Each element in a user-level keywords list should have one of these forms:
 
  MATCHER
  (MATCHER . MATCH)
@@ -438,7 +446,14 @@ support modes like jit-lock or lazy-lock.
 
 This variable is set by major modes via the variable `font-lock-defaults'.
 Be careful when composing regexps for this list; a poorly written pattern can
-dramatically slow things down!")
+dramatically slow things down!
+
+A compiled keywords list starts with t.  It is produced internal
+by `font-lock-compile-keywords' from a user-level keywords list.
+Its second element is the user-level keywords list that was
+compiled.  The remaining elements have the same form as
+user-level keywords, but normally their values have been
+optimized.")
 
 (defvar font-lock-keywords-alist nil
   "*Alist of `font-lock-keywords' local to a `major-mode'.
@@ -659,16 +674,26 @@ see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
          (font-lock-update-removed-keyword-alist mode keywords append))
         (t
          ;; Otherwise set or add the keywords now.
+         ;; This is a no-op if it has been done already in this buffer.
          (font-lock-set-defaults)
-         (if (eq append 'set)
-             (setq font-lock-keywords keywords)
-           (font-lock-remove-keywords nil keywords) ;to avoid duplicates
-           (let ((old (if (eq (car-safe font-lock-keywords) t)
-                          (cdr font-lock-keywords)
-                        font-lock-keywords)))
-             (setq font-lock-keywords (if append
-                                          (append old keywords)
-                                        (append keywords old))))))))
+         (let ((was-compiled (eq (car font-lock-keywords) t)))
+           ;; Bring back the user-level (uncompiled) keywords.
+           (if was-compiled
+               (setq font-lock-keywords (cadr font-lock-keywords)))
+           ;; Now modify or replace them.
+           (if (eq append 'set)
+               (setq font-lock-keywords keywords)
+             (font-lock-remove-keywords nil keywords) ;to avoid duplicates
+             (let ((old (if (eq (car-safe font-lock-keywords) t)
+                            (cdr font-lock-keywords)
+                          font-lock-keywords)))
+               (setq font-lock-keywords (if append
+                                            (append old keywords)
+                                          (append keywords old)))))
+           ;; If the keywords were compiled before, compile them again.
+           (if was-compiled
+               (set (make-local-variable 'font-lock-keywords)
+                    (font-lock-compile-keywords keywords t)))))))
 
 (defun font-lock-update-removed-keyword-alist (mode keywords append)
   ;; Update `font-lock-removed-keywords-alist' when adding new
@@ -762,13 +787,21 @@ subtle problems due to details of the implementation."
         (t
          ;; Otherwise remove it immediately.
          (font-lock-set-defaults)
-         (setq font-lock-keywords (copy-sequence font-lock-keywords))
-         (dolist (keyword keywords)
-           (setq font-lock-keywords
-                 (delete keyword
-                         ;; The keywords might be compiled.
-                         (delete (font-lock-compile-keyword keyword)
-                                 font-lock-keywords)))))))
+         (let ((was-compiled (eq (car font-lock-keywords) t)))
+           ;; Bring back the user-level (uncompiled) keywords.
+           (if was-compiled
+               (setq font-lock-keywords (cadr font-lock-keywords)))
+
+           ;; Edit them.
+           (setq font-lock-keywords (copy-sequence font-lock-keywords))
+           (dolist (keyword keywords)
+             (setq font-lock-keywords
+                   (delete keyword font-lock-keywords)))
+
+           ;; If the keywords were compiled before, compile them again.
+           (if was-compiled
+               (set (make-local-variable 'font-lock-keywords)
+                    (font-lock-compile-keywords keywords t)))))))
 
 ;;; Font Lock Support mode.
 
@@ -1224,7 +1257,7 @@ START should be at the beginning of a line."
                                         font-lock-syntactic-keywords)))
   ;; Get down to business.
   (let ((case-fold-search font-lock-keywords-case-fold-search)
-        (keywords (cdr font-lock-syntactic-keywords))
+        (keywords (cddr font-lock-syntactic-keywords))
         keyword matcher highlights)
     (while keywords
       ;; Find an occurrence of `matcher' from `start' to `end'.
@@ -1349,7 +1382,7 @@ LOUDLY, if non-nil, allows progress-meter bar."
     (setq font-lock-keywords
           (font-lock-compile-keywords font-lock-keywords t)))
   (let ((case-fold-search font-lock-keywords-case-fold-search)
-        (keywords (cdr font-lock-keywords))
+        (keywords (cddr font-lock-keywords))
         (bufname (buffer-name)) (count 0)
         keyword matcher highlights)
     ;;
@@ -1394,14 +1427,16 @@ LOUDLY, if non-nil, allows progress-meter bar."
 ;; Various functions.
 
 (defun font-lock-compile-keywords (keywords &optional regexp)
-  "Compile KEYWORDS into the form (t KEYWORD ...).
-Here KEYWORD is of the form (MATCHER HIGHLIGHT ...) as shown in the
+  "Compile KEYWORDS into the form (t KEYWORDS COMPILED...)
+Here each COMPILED is of the form (MATCHER HIGHLIGHT ...) as shown in the
 `font-lock-keywords' doc string.
 If REGEXP is non-nil, it means these keywords are used for
 `font-lock-keywords' rather than for `font-lock-syntactic-keywords'."
   (if (eq (car-safe keywords) t)
       keywords
-    (setq keywords (cons t (mapcar 'font-lock-compile-keyword keywords)))
+    (setq keywords
+          (cons t (cons keywords
+                        (mapcar 'font-lock-compile-keyword keywords))))
     (if (and regexp
              (eq (or syntax-begin-function
                      font-lock-beginning-of-syntax-function)
@@ -1512,17 +1547,21 @@ Sets various variables using `font-lock-defaults' (or, if nil, using
       ;; Variable alist?
       (dolist (x (nthcdr 5 defaults))
         (set (make-local-variable (car x)) (cdr x)))
-      ;; Setup `font-lock-keywords' last because its value might depend
+      ;; Set up `font-lock-keywords' last because its value might depend
       ;; on other settings (e.g. font-lock-compile-keywords uses
       ;; font-lock-beginning-of-syntax-function).
       (set (make-local-variable 'font-lock-keywords)
-           (font-lock-compile-keywords (font-lock-eval-keywords keywords) t))
+           (font-lock-eval-keywords keywords))
       ;; Local fontification?
       (while local
         (font-lock-add-keywords nil (car (car local)) (cdr (car local)))
         (setq local (cdr local)))
       (when removed-keywords
-        (font-lock-remove-keywords nil removed-keywords)))))
+        (font-lock-remove-keywords nil removed-keywords))
+      ;; Now compile the keywords.
+      (unless (eq (car font-lock-keywords) t)
+        (set (make-local-variable 'font-lock-keywords)
+             (font-lock-compile-keywords font-lock-keywords t))))))
 
 ;;; Colour etc. support.
 
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 78c9f15f912..8169b014e16 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,10 @@
+2004-06-29  Kim F. Storm  <storm@cua.dk>
+
+        * nntp.el (nntp-authinfo-file): Add :group 'nntp.
+
+        * nnimap.el (nnimap-authinfo-file, nnimap-prune-cache):
+        Add :group 'nnimap.
+
 2004-05-18  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * mm-view.el (mm-insert-inline): Make it work in read-only buffer.
diff --git a/lisp/gnus/nnimap.el b/lisp/gnus/nnimap.el
index a7cf82317b5..ec9d42ee042 100644
--- a/lisp/gnus/nnimap.el
+++ b/lisp/gnus/nnimap.el
@@ -271,11 +271,13 @@ use this to make replies go directly to the group.")
                                           (string :format "Login: %v"))
                                     (cons :format "%v"
                                           (const :format "" "password")
-                                          (string :format "Password: %v")))))))
+                                          (string :format "Password: %v"))))))
+  :group 'nnimap)
 
 (defcustom nnimap-prune-cache t
   "If non-nil, nnimap check whether articles still exist on server before using data stored in NOV cache."
-  :type 'boolean)
+  :type 'boolean
+  :group 'nnimap)
 
 (defvar nnimap-request-list-method 'imap-mailbox-list
   "Method to use to request a list of all folders from the server.
diff --git a/lisp/gnus/nntp.el b/lisp/gnus/nntp.el
index 8791c652a45..5722ba8456a 100644
--- a/lisp/gnus/nntp.el
+++ b/lisp/gnus/nntp.el
@@ -174,7 +174,8 @@ server there that you can connect to.  See also
                                           (string :format "Login: %v"))
                                     (cons :format "%v"
                                           (const :format "" "password")
-                                          (string :format "Password: %v")))))))
+                                          (string :format "Password: %v"))))))
+  :group 'nntp)
 
 
 
@@ -223,7 +224,7 @@ noticing asynchronous data.")
 (defvar nntp-async-timer nil)
 (defvar nntp-async-process-list nil)
 
-(defvar nntp-ssl-program 
+(defvar nntp-ssl-program
   "openssl s_client -quiet -ssl3 -connect %s:%p"
 "A string containing commands for SSL connections.
 Within a string, %s is replaced with the server address and %p with
@@ -928,10 +929,10 @@ password contained in '~/.nntp-authinfo'."
 
 (defun nntp-open-ssl-stream (buffer)
   (let* ((process-connection-type nil)
-         (proc (start-process "nntpd" buffer 
+         (proc (start-process "nntpd" buffer
                               shell-file-name
                               shell-command-switch
-                              (format-spec nntp-ssl-program 
+                              (format-spec nntp-ssl-program
                                            (format-spec-make
                                             ?s nntp-address
                                             ?p nntp-port-number)))))
diff --git a/lisp/image.el b/lisp/image.el
index 88e38186d7b..ad8fcafe8de 100644
--- a/lisp/image.el
+++ b/lisp/image.el
@@ -54,10 +54,12 @@ a non-nil value, TYPE is the image's type.")
 
 Each element is a list (IMAGE-TYPE LIBRARY...), where the car is a symbol
 representing a supported image type, and the rest are strings giving
-alternate filenames for the corresponding external libraries to load.
-They are tried in the order they appear on the list; if none of them can
-be loaded, the running session of Emacs won't display the image type.
-No entries are needed for pbm and xbm images; they're always supported.")
+alternate filenames for the corresponding external libraries.
+
+Emacs tries to load the libraries in the order they appear on the
+list; if none is loaded, the running session of Emacs won't
+support the image type.  Types 'pbm and 'xbm don't need to be
+listed; they're always supported.")
 ;;;###autoload (put 'image-library-alist 'risky-local-variable t)
 
 (defun image-jpeg-p (data)
diff --git a/lisp/man.el b/lisp/man.el
index 5a07045dda9..cbfae21e44b 100644
--- a/lisp/man.el
+++ b/lisp/man.el
@@ -733,7 +733,9 @@ all sections related to a subject, put something appropriate into the
         (if (fboundp 'start-process)
             (set-process-sentinel
              (start-process manual-program buffer
-                            (if (eq system-type 'cygwin) shell-file-name "sh")
+                            (if (memq system-type '(cygwin windows-nt))
+                                shell-file-name
+                              "sh")
                             shell-command-switch
                             (format (Man-build-man-command) man-args))
              'Man-bgproc-sentinel)
diff --git a/lisp/net/ange-ftp.el b/lisp/net/ange-ftp.el
index 09448e87329..8e9d0bda5af 100644
--- a/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@ -4117,7 +4117,7 @@ directory, so that Emacs will know its current contents."
           tmp1))))
 
 (defun ange-ftp-file-remote-p (file)
-  (when (ange-ftp-ftp-name file) t))
+  (ange-ftp-replace-name-component file ""))
 
 (defun ange-ftp-load (file &optional noerror nomessage nosuffix)
   (if (ange-ftp-ftp-name file)
diff --git a/lisp/net/goto-addr.el b/lisp/net/goto-addr.el
index b77be84deb3..428da8cbe8a 100644
--- a/lisp/net/goto-addr.el
+++ b/lisp/net/goto-addr.el
@@ -168,7 +168,7 @@ and `goto-address-fontify-p'."
                 (overlay-put this-overlay
                              'mouse-face goto-address-url-mouse-face)
                 (overlay-put this-overlay
-                             'help-echo "mouse-2: follow URL")
+                             'help-echo "mouse-2, C-c RET: follow URL")
                 (overlay-put this-overlay
                              'keymap goto-address-highlight-keymap)
                 (overlay-put this-overlay 'goto-address t)))
@@ -182,7 +182,7 @@ and `goto-address-fontify-p'."
                 (overlay-put this-overlay 'mouse-face
                              goto-address-mail-mouse-face)
                 (overlay-put this-overlay
-                             'help-echo "mouse-2: mail this address")
+                             'help-echo "mouse-2, C-c RET: mail this address")
                 (overlay-put this-overlay
                              'keymap goto-address-highlight-keymap)
                 (overlay-put this-overlay 'goto-address t))))))))
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 769ad3f51f6..0414859c7eb 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -3542,7 +3542,14 @@ This will break if COMMAND prints a newline, followed by the value of
 
 (defun tramp-handle-file-remote-p (filename)
   "Like `file-remote-p' for tramp files."
-  (when (tramp-tramp-file-p filename) t))
+  (when (tramp-tramp-file-p filename)
+    (with-parsed-tramp-file-name filename nil
+      (make-tramp-file-name
+       :multi-method multi-method
+       :method method
+       :user user
+       :host host
+       :localname ""))))
 
 (defun tramp-handle-insert-file-contents
   (filename &optional visit beg end replace)
diff --git a/lisp/progmodes/ada-xref.el b/lisp/progmodes/ada-xref.el
index c7b5717a1bb..c9bfbd76c23 100644
--- a/lisp/progmodes/ada-xref.el
+++ b/lisp/progmodes/ada-xref.el
@@ -143,7 +143,8 @@ Otherwise, ask the user for the name of the project file to use."
 
 (defcustom ada-tight-gvd-integration nil
   "*If non-nil, a new Emacs frame will be swallowed in GVD when debugging.
-If GVD is not the debugger used, nothing happens.")
+If GVD is not the debugger used, nothing happens."
+  :type 'boolean :group 'ada)
 
 (defcustom ada-xref-search-with-egrep t
   "*If non-nil, use egrep to find the possible declarations for an entity.
@@ -506,12 +507,12 @@ All the directories are returned as absolute directories."
                             (equal ada-prj-default-project-file
                                    (car x))
                             ))))
-     
+
               ;; Parses all the known project files, and insert at
               ;; least the default one (in case
               ;; ada-xref-project-files is nil)
               (or ada-xref-project-files '(nil))))))
-      
+
     (easy-menu-add-item ada-mode-menu '() submenu)))
 
 
diff --git a/lisp/progmodes/gdb-ui.el b/lisp/progmodes/gdb-ui.el
index 2f267787707..1e2ef00580e 100644
--- a/lisp/progmodes/gdb-ui.el
+++ b/lisp/progmodes/gdb-ui.el
@@ -29,10 +29,9 @@
 ;; GDB through the GUD buffer in the usual way, but there are also further
 ;; buffers which control the execution and describe the state of your program.
 ;; It separates the input/output of your program from that of GDB, if
-;; required, and displays expressions and their current values in their own
-;; buffers. It also uses features of Emacs 21 such as the display margin for
-;; breakpoints, and the toolbar (see the GDB Graphical Interface section in
-;; the Emacs info manual).
+;; required, and watches expressions in the speedbar. It also uses features of
+;; Emacs 21 such as the fringe/display margin for breakpoints, and the toolbar
+;; (see the GDB Graphical Interface section in the Emacs info manual).
 
 ;; Start the debugger with M-x gdba.
 
@@ -40,7 +39,7 @@
 ;; Kingdon and uses GDB's annotation interface. You don't need to know about
 ;; annotations to use this mode as a debugger, but if you are interested
 ;; developing the mode itself, then see the Annotations section in the GDB
-;; info manual. 
+;; info manual.
 ;;
 ;; GDB developers plan to make the annotation interface obsolete. A new
 ;; interface called GDB/MI (machine interface) has been designed to replace
@@ -71,7 +70,7 @@
 (defvar gdb-variables '()
   "A list of variables that are local to the GUD buffer.")
 (defvar gdb-server-prefix nil)
- 
+
 ;;;###autoload
 (defun gdba (command-line)
   "Run gdb on program FILE in buffer *gud-FILE*.
@@ -228,7 +227,7 @@ speedbar."
         (if (string-equal expr (car var)) (throw 'already-watched nil)))
       (set-text-properties 0 (length expr) nil expr)
       (gdb-enqueue-input
-       (list 
+       (list
         (if (eq gud-minor-mode 'gdba)
             (concat "server interpreter mi \"-var-create - * "  expr "\"\n")
           (concat"-var-create - * "  expr "\n"))
@@ -327,7 +326,7 @@ speedbar."
   (if (not (member 'gdb-var-update gdb-pending-triggers))
       (progn
         (gdb-enqueue-input
-         (list 
+         (list
           (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
               "server interpreter mi \"-var-update *\"\n"
             "-var-update *\n")
@@ -363,7 +362,7 @@ speedbar."
                (varnum (cadr var)))
           (unless (string-match "\\." varnum)
             (gdb-enqueue-input
-             (list 
+             (list
               (if (with-current-buffer gud-comint-buffer
                     (eq gud-minor-mode 'gdba))
                   (concat "server interpreter mi \"-var-delete " varnum "\"\n")
@@ -487,7 +486,7 @@ The key should be one of the cars in `gdb-buffer-rules-assoc'."
           (set (make-local-variable 'gdb-buffer-type) key)
           (if (cdr (cdr rules))
               (funcall (car (cdr (cdr rules)))))
-          (set (make-local-variable 'gud-minor-mode) 
+          (set (make-local-variable 'gud-minor-mode)
                (with-current-buffer gud-comint-buffer gud-minor-mode))
           (set (make-local-variable 'tool-bar-map) gud-tool-bar-map)
           new))))
@@ -1077,13 +1076,15 @@ static char *magick[] = {
   '((t
      :inherit fringe
      :foreground "red"))
-  "Face for enabled breakpoint icon in fringe.")
+  "Face for enabled breakpoint icon in fringe."
+  :group 'gud)
 
 (defface breakpoint-disabled-bitmap-face
   '((t
      :inherit fringe
      :foreground "grey60"))
-  "Face for disabled breakpoint icon in fringe.")
+  "Face for disabled breakpoint icon in fringe."
+  :group 'gud)
 
 
 ;;-put breakpoint icons in relevant margins (even those set in the GUD buffer)
@@ -1207,8 +1208,8 @@ static char *magick[] = {
        (list
         (concat
          (if (eq ?y (char-after (match-beginning 2)))
-             gdb-server-prefix "disable "
-           gdb-server-prefix "enable ")
+             (concat gdb-server-prefix "disable ")
+           (concat gdb-server-prefix "enable "))
          (match-string 1) "\n")
         'ignore)))))
 
@@ -1226,10 +1227,12 @@ static char *magick[] = {
   (interactive)
   (save-excursion
     (beginning-of-line 1)
-    (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdbmi))
-        (looking-at "[0-9]*\\s-*\\S-*\\s-*\\S-*\\s-*.\\s-*\\S-*\\s-*\\(\\S-*\\):\\([0-9]+\\)")
-      (re-search-forward "in\\s-+\\S-+\\s-+at\\s-+" nil t)
-      (looking-at "\\(\\S-*\\):\\([0-9]+\\)")))
+    (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
+        (progn
+          (re-search-forward "in\\s-+\\S-+\\s-+at\\s-+" nil t)
+          (looking-at "\\(\\S-*\\):\\([0-9]+\\)"))
+    (looking-at
+     "[0-9]*\\s-*\\S-*\\s-*\\S-*\\s-*.\\s-*\\S-*\\s-*\\(\\S-*\\):\\([0-9]+\\)")))
   (if (match-string 2)
       (let ((line (match-string 2))
             (file (match-string 1)))
@@ -1836,7 +1839,7 @@ BUFFER nil or omitted means use the current buffer."
             (save-current-buffer
               (setq left-margin-width 2)
               (if (get-buffer-window (current-buffer) 'visible)
-                  (set-window-margins 
+                  (set-window-margins
                    (get-buffer-window (current-buffer) 'visible)
                    left-margin-width right-margin-width))))
           (put-image
@@ -1863,7 +1866,7 @@ BUFFER nil or omitted means use the current buffer."
         (save-current-buffer
           (setq left-margin-width 2)
           (if (get-buffer-window (current-buffer) 'visible)
-              (set-window-margins 
+              (set-window-margins
                (get-buffer-window (current-buffer) 'visible)
                left-margin-width right-margin-width))))
       (gdb-put-string (if enabled "B" "b") (1+ start)))))
@@ -1875,7 +1878,7 @@ BUFFER nil or omitted means use the current buffer."
   (when remove-margin
     (setq left-margin-width 0)
     (if (get-buffer-window (current-buffer) 'visible)
-        (set-window-margins 
+        (set-window-margins
          (get-buffer-window (current-buffer) 'visible)
          left-margin-width right-margin-width))))
 
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index aa9a50a2580..1916bde9ea1 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -146,6 +146,14 @@ The following place holders should be present in the string:
   :type 'boolean
   :group 'grep)
 
+(defcustom grep-error-screen-columns nil
+  "*If non-nil, column numbers in grep hits are screen columns.
+See `compilation-error-screen-columns'"
+  :type '(choice (const :tag "Default" nil)
+                 integer)
+  :version "21.4"
+  :group 'grep)
+
 ;;;###autoload
 (defcustom grep-setup-hook nil
   "List of hook functions run by `grep-process-setup' (see `run-hooks')."
@@ -216,7 +224,9 @@ Notice that using \\[next-error] or \\[compile-goto-error] modifies
 `complation-last-buffer' rather than `grep-last-buffer'.")
 
 (defvar grep-regexp-alist
-  '(("^\\(.+?\\)[:( \t]+\\([0-9]+\\)\\([:) \t]\\)\\(?:\\([0-9]+\\)\\(?:-\\([0-9]+\\)\\)?\\3\\)?" 1 2 (4 . 5))
+  '(("^\\(.+?\\)[:( \t]+\
+\\([0-9]+\\)\\([.:]?\\)\\([0-9]+\\)?\
+\\(?:-\\(?:\\([0-9]+\\)\\3\\)?\\.?\\([0-9]+\\)?\\)?[:) \t]" 1 (2 . 5) (4 . 6))
     ("^Binary file \\(.+\\) matches$" 1 nil nil 1))
   "Regexp used to match grep hits.  See `compilation-error-regexp-alist'.")
 
diff --git a/lisp/replace.el b/lisp/replace.el
index 89f55c2829e..c2305cdecc6 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -95,6 +95,35 @@ strings or patterns."
       (setq to (read-from-minibuffer (format "%s %s with: " string from)
                                      nil nil nil
                                      query-replace-to-history-variable from t)))
+    (when (and regexp-flag
+               (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]" to))
+      (let (pos list char)
+        (while
+            (progn
+              (setq pos (match-end 0))
+              (push (substring to 0 (- pos 2)) list)
+              (setq char (aref to (1- pos))
+                    to (substring to pos))
+              (cond ((eq char ?\#)
+                     (push '(number-to-string replace-count) list))
+                    ((eq char ?\,)
+                     (setq pos (read-from-string to))
+                     (push `(replace-quote ,(car pos)) list)
+                     (setq to (substring
+                               to (+ (cdr pos)
+                                     ;; Swallow a space after a symbol
+                                     ;; if there is a space.
+                                     (if (string-match
+                                          "^[^])\"] "
+                                          (substring to (1- (cdr pos))))
+                                         1 0))))))
+              (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]" to)))
+        (setq to (nreverse (delete "" (cons to list)))))
+      (replace-match-string-symbols to)
+      (setq to (cons 'replace-eval-replacement
+                     (if (> (length to) 1)
+                         (cons 'concat to)
+                       (car to)))))
     (list from to current-prefix-arg)))
 
 (defun query-replace (from-string to-string &optional delimited start end)
@@ -163,59 +192,35 @@ Fourth and fifth arg START and END specify the region to operate on.
 In TO-STRING, `\\&' stands for whatever matched the whole of REGEXP,
 and `\\=\\N' (where N is a digit) stands for
 whatever what matched the Nth `\\(...\\)' in REGEXP.
-
-When this function is called interactively, the replacement text
-can also contain `\\,' followed by a Lisp expression.  The escaped
-shorthands for `query-replace-regexp-eval' are also valid
-here: within the Lisp expression, you can use `\\&' for the whole
-match string, `\\N' for partial matches, `\\#&' and `\\#N' for
-the respective numeric values, and `\\#' for `replace-count'.
-
-If your Lisp expression is an identifier and the next
-letter in the replacement string would be interpreted as part of it,
-you can wrap it with an expression like `\\,(or \\#)'.  Incidentally,
-for this particular case you may also enter `\\#' in the replacement
-text directly.
-
-When you use `\\,' or `\\#' in the replacement, TO-STRING actually
-becomes a list with expanded shorthands.
-Use \\[repeat-complex-command] after this command to see details."
+`\\?' lets you edit the replacement text in the minibuffer
+at the given position for each replacement.
+
+In interactive calls, the replacement text can contain `\\,'
+followed by a Lisp expression.  Each
+replacement evaluates that expression to compute the replacement
+string.  Inside of that expression, `\\&' is a string denoting the
+whole match as a sting, `\\N' for a partial match, `\\#&' and `\\#N'
+for the whole or a partial match converted to a number with
+`string-to-number', and `\\#' itself for the number of replacements
+done so far (starting with zero).
+
+If the replacement expression is a symbol, write a space after it
+to terminate it.  One space there, if any, will be discarded.
+
+When using those Lisp features interactively in the replacement
+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 regexp" t)))
-     (list
-      (nth 0 common)
-      (if (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]"
-                        (nth 1 common))
-          (let ((to-string (nth 1 common)) pos to-expr char prompt)
-            (while (string-match
-                    "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]"
-                    to-string)
-              (setq pos (match-end 0))
-              (push (substring to-string 0 (- pos 2)) to-expr)
-              (setq char (aref to-string (1- pos))
-                    to-string (substring to-string pos))
-              (cond ((eq char ?\#)
-                     (push '(number-to-string replace-count) to-expr))
-                    ((eq char ?\,)
-                     (setq pos (read-from-string to-string))
-                     (push `(replace-quote ,(car pos)) to-expr)
-                     (setq to-string (substring to-string (cdr pos))))))
-            (setq to-expr (nreverse (delete "" (cons to-string to-expr))))
-            (replace-match-string-symbols to-expr)
-            (cons 'replace-eval-replacement 
-                  (if (> (length to-expr) 1)
-                      (cons 'concat to-expr)
-                    (car to-expr))))
-        (nth 1 common))
-      (nth 2 common)
-      ;; These are done separately here
-      ;; so that command-history will record these expressions
-      ;; rather than the values they had this time.
-      (if (and transient-mark-mode mark-active)
-          (region-beginning))
-      (if (and transient-mark-mode mark-active)
-          (region-end)))))
+     (list (nth 0 common) (nth 1 common) (nth 2 common)
+           ;; These are done separately here
+           ;; so that command-history will record these expressions
+           ;; rather than the values they had this time.
+           (if (and transient-mark-mode mark-active)
+               (region-beginning))
+           (if (and transient-mark-mode mark-active)
+               (region-end)))))
   (perform-replace regexp to-string t t delimited nil nil start end))
 
 (define-key esc-map [?\C-%] 'query-replace-regexp)
@@ -374,7 +379,27 @@ Fourth and fifth arg START and END specify the region to operate on.
 
 In TO-STRING, `\\&' stands for whatever matched the whole of REGEXP,
 and `\\=\\N' (where N is a digit) stands for
- whatever what matched the Nth `\\(...\\)' in REGEXP.
+whatever what matched the Nth `\\(...\\)' in REGEXP.
+`\\?' lets you edit the replacement text in the minibuffer
+at the given position for each replacement.
+
+In interactive calls, the replacement text may contain `\\,'
+followed by a Lisp expression used as part of the replacement
+text.  Inside of that expression, `\\&' is a string denoting the
+whole match, `\\N' a partial matches, `\\#&' and `\\#N' the
+respective numeric values from `string-to-number', and `\\#'
+itself for `replace-count', the number of replacements occured so
+far.
+
+If your Lisp expression is an identifier and the next letter in
+the replacement string would be interpreted as part of it, you
+can wrap it with an expression like `\\,(or \\#)'.  Incidentally,
+for this particular case you may also enter `\\#' in the
+replacement text directly.
+
+When using those Lisp features interactively in the replacement
+text, TO-STRING is actually made a list instead of a string.
+Use \\[repeat-complex-command] after this command for details.
 
 If `query-replace-interactive' is non-nil, the last incremental search
 regexp is used as REGEXP--you don't have to specify it with the minibuffer.
@@ -1115,6 +1140,49 @@ with the `noescape' argument set.
           (aset data 2 (if (consp next) next (aref data 3))))))
   (car (aref data 2)))
 
+(defun replace-match-data (integers reuse &optional new)
+  "Like `match-data', but markers in REUSE get invalidated.
+If NEW is non-NIL, it is set and returned instead of fresh data,
+but coerced to the correct value of INTEGERS."
+  (or (and new
+           (progn
+             (set-match-data new)
+             (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)))))))
+
+(defun replace-match-maybe-edit (newtext fixedcase literal noedit match-data)
+  "Make a replacement with `replace-match', editing `\\?'.
+NEXTEXT, FIXEDCASE, LITERAL are just passed on.  If NOEDIT is true, no
+check for `\\?' is made to save time.  MATCH-DATA is used for the
+replacement.  In case editing is done, it is changed to use markers.
+
+The return value is non-NIL if there has been no `\\?' or NOEDIT was
+passed in.  If LITERAL is set, no checking is done, anyway."
+  (unless (or literal noedit)
+    (setq noedit t)
+    (while (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\\\?\\)"
+                         newtext)
+      (setq newtext
+            (read-input "Edit replacement string: "
+                        (prog1
+                            (cons
+                             (replace-match "" t t newtext 3)
+                             (1+ (match-beginning 3)))
+                          (setq match-data
+                                (replace-match-data
+                                 nil match-data match-data))))
+            noedit nil)))
+  (set-match-data match-data)
+  (replace-match newtext fixedcase literal)
+  noedit)
+
 (defun perform-replace (from-string replacements
                         query-flag regexp-flag delimited-flag
                         &optional repeat-count map start end)
@@ -1145,6 +1213,7 @@ make, or the user didn't cancel the call."
         (search-string from-string)
         (real-match-data nil)           ; the match data for the current match
         (next-replacement nil)
+        (noedit nil)
         (keep-going t)
         (stack nil)
         (replace-count 0)
@@ -1201,7 +1270,9 @@ make, or the user didn't cancel the call."
                     (setq real-match-data
                           (if (consp match-again)
                               (progn (goto-char (nth 1 match-again))
-                                     match-again)
+                                     (replace-match-data t
+                                      real-match-data
+                                      match-again))
                             (and (or match-again
                                      ;; MATCH-AGAIN non-nil means we
                                      ;; accept an adjacent match.  If
@@ -1217,7 +1288,7 @@ make, or the user didn't cancel the call."
                                  (funcall search-function search-string limit t)
                                  ;; For speed, use only integers and
                                  ;; reuse the list used last time.
-                                 (match-data t real-match-data)))))
+                                 (replace-match-data t real-match-data)))))
           ;; Optionally ignore matches that have a read-only property.
           (unless (and query-replace-skip-read-only
                        (text-property-not-all
@@ -1249,16 +1320,27 @@ make, or the user didn't cancel the call."
               (set-match-data real-match-data)
               (setq next-replacement
                     (funcall (car replacements) (cdr replacements)
-                             replace-count)))
+                             replace-count)
+                    noedit nil))
             (if (not query-flag)
-                (let ((inhibit-read-only query-replace-skip-read-only))
-                  (set-match-data real-match-data)
-                  (replace-match next-replacement nocasify literal)
-                  (setq replace-count (1+ replace-count)))
+                (let ((inhibit-read-only
+                       query-replace-skip-read-only))
+                  (unless noedit
+                    (replace-highlight (nth 0 real-match-data)
+                                       (nth 1 real-match-data)))
+                  (setq noedit
+                        (replace-match-maybe-edit
+                         next-replacement nocasify literal
+                         noedit real-match-data)
+                        replace-count (1+ replace-count)))
               (undo-boundary)
               (let (done replaced key def)
                 ;; Loop reading commands until one of them sets done,
-                ;; which means it has finished handling this occurrence.
+                ;; which means it has finished handling this
+                ;; occurrence.  Any command that sets `done' should
+                ;; leave behind proper match data for the stack.
+                ;; Commands not setting `done' need to adjust
+                ;; `real-match-data'.
                 (while (not done)
                   (set-match-data real-match-data)
                   (replace-highlight (match-beginning 0) (match-end 0))
@@ -1290,37 +1372,49 @@ make, or the user didn't cancel the call."
                         ((eq def 'backup)
                          (if stack
                              (let ((elt (pop stack)))
-                               (goto-char (car elt))
-                               (setq replaced (eq t (cdr elt)))
-                               (or replaced
-                                   (set-match-data (cdr elt))))
+                               (goto-char (nth 0 elt))
+                               (setq replaced (nth 1 elt)
+                                     real-match-data
+                                     (replace-match-data
+                                      t real-match-data
+                                      (nth 2 elt))))
                            (message "No previous match")
                            (ding 'no-terminate)
                            (sit-for 1)))
                         ((eq def 'act)
                          (or replaced
-                             (progn
-                               (replace-match next-replacement nocasify literal)
-                               (setq replace-count (1+ replace-count))))
+                             (setq noedit
+                                   (replace-match-maybe-edit
+                                    next-replacement nocasify literal
+                                    noedit real-match-data)
+                                   replace-count (1+ replace-count)))
                          (setq done t replaced t))
                         ((eq def 'act-and-exit)
                          (or replaced
-                             (progn
-                               (replace-match next-replacement nocasify literal)
-                               (setq replace-count (1+ replace-count))))
+                             (setq noedit
+                                   (replace-match-maybe-edit
+                                    next-replacement nocasify literal
+                                    noedit real-match-data)
+                                   replace-count (1+ replace-count)))
                          (setq keep-going nil)
                          (setq done t replaced t))
                         ((eq def 'act-and-show)
                          (if (not replaced)
-                             (progn
-                               (replace-match next-replacement nocasify literal)
-                               (setq replace-count (1+ replace-count))
-                               (setq replaced t))))
+                             (setq noedit
+                                   (replace-match-maybe-edit
+                                    next-replacement nocasify literal
+                                    noedit real-match-data)
+                                   replace-count (1+ replace-count)
+                                   real-match-data (replace-match-data
+                                                    t real-match-data)
+                                   replaced t)))
                         ((eq def 'automatic)
                          (or replaced
-                             (progn
-                               (replace-match next-replacement nocasify literal)
-                               (setq replace-count (1+ replace-count))))
+                             (setq noedit
+                                   (replace-match-maybe-edit
+                                    next-replacement nocasify literal
+                                    noedit real-match-data)
+                                   replace-count (1+ replace-count)))
                          (setq done t query-flag nil replaced t))
                         ((eq def 'skip)
                          (setq done t))
@@ -1328,36 +1422,45 @@ make, or the user didn't cancel the call."
                          (recenter nil))
                         ((eq def 'edit)
                          (let ((opos (point-marker)))
+                           (setq real-match-data (replace-match-data
+                                                  nil real-match-data
+                                                  real-match-data))
                            (goto-char (match-beginning 0))
                            (save-excursion
-                             (funcall search-function search-string limit t)
-                             (setq real-match-data (match-data)))
-                           (save-excursion
                              (save-window-excursion
                                (recursive-edit)))
-                           (goto-char opos))
-                         (set-match-data real-match-data)
+                           (goto-char opos)
+                           (set-marker opos nil))
                          ;; Before we make the replacement,
                          ;; decide whether the search string
                          ;; can match again just after this match.
                          (if (and regexp-flag nonempty-match)
                              (setq match-again (and (looking-at search-string)
                                                     (match-data)))))
-
                         ;; Edit replacement.
                         ((eq def 'edit-replacement)
-                         (setq next-replacement
+                         (setq real-match-data (replace-match-data
+                                                nil real-match-data
+                                                real-match-data)
+                               next-replacement
                                (read-input "Edit replacement string: "
-                                           next-replacement))
-                         (or replaced
-                             (replace-match next-replacement nocasify literal))
+                                           next-replacement)
+                               noedit nil)
+                         (if replaced
+                             (set-match-data real-match-data)
+                           (setq noedit
+                                 (replace-match-maybe-edit
+                                  next-replacement nocasify literal noedit
+                                  real-match-data)
+                                 replaced t))
                          (setq done t))
 
                         ((eq def 'delete-and-edit)
-                         (delete-region (match-beginning 0) (match-end 0))
-                         (set-match-data
-                          (prog1 (match-data)
-                            (save-excursion (recursive-edit))))
+                         (replace-match "" t t)
+                         (setq real-match-data (replace-match-data
+                                                nil real-match-data))
+                         (replace-dehighlight)
+                         (save-excursion (recursive-edit))
                          (setq replaced t))
                         ;; Note: we do not need to treat `exit-prefix'
                         ;; specially here, since we reread
@@ -1372,10 +1475,23 @@ make, or the user didn't cancel the call."
                 ;; Record previous position for ^ when we move on.
                 ;; Change markers to numbers in the match data
                 ;; since lots of markers slow down editing.
-                (setq stack
-                      (cons (cons (point)
-                                  (or replaced (match-data t)))
-                            stack))))))
+                (push (list (point) replaced
+;;; If the replacement has already happened, all we need is the
+;;; current match start and end.  We could get this with a trivial
+;;; match like
+;;; (save-excursion (goto-char (match-beginning 0))
+;;;                 (search-forward (match-string 0))
+;;;                 (match-data t))
+;;; if we really wanted to avoid manually constructing match data.
+;;; Adding current-buffer is necessary so that match-data calls can
+;;; return markers which are appropriate for editing.
+                            (if replaced
+                                (list
+                                 (match-beginning 0)
+                                 (match-end 0)
+                                 (current-buffer))
+                              (match-data t)))
+                      stack)))))
 
       ;; The code preventing adjacent regexp matches in the condition
       ;; of the while-loop above will haven taken us one character
@@ -1405,14 +1521,12 @@ make, or the user didn't cancel the call."
 
 (defun replace-highlight (start end)
   (and query-replace-highlight
-       (progn
-         (or replace-overlay
-             (progn
-               (setq replace-overlay (make-overlay start end))
-               (overlay-put replace-overlay 'face
-                            (if (facep 'query-replace)
-                                'query-replace 'region))))
-         (move-overlay replace-overlay start end (current-buffer)))))
+       (if replace-overlay
+           (move-overlay replace-overlay start end (current-buffer))
+         (setq replace-overlay (make-overlay start end))
+         (overlay-put replace-overlay 'face
+                      (if (facep 'query-replace)
+                          'query-replace 'region)))))
 
 ;;; arch-tag: 16b4cd61-fd40-497b-b86f-b667c4cf88e4
 ;;; replace.el ends here
diff --git a/lisp/vc-arch.el b/lisp/vc-arch.el
index a439174556e..5f24599241c 100644
--- a/lisp/vc-arch.el
+++ b/lisp/vc-arch.el
@@ -309,7 +309,8 @@ Return non-nil if FILE is unchanged."
 (defcustom vc-arch-mode-line-rewrite
   '(("\\`.*--\\(.*--.*\\)--\\(v?\\).*-\\([0-9]+\\)\\'" . "\\2\\3[\\1]"))
   "Rewrite rules to shorten Arch's revision names on the mode-line."
-  :type '(repeat (cons regexp string)))
+  :type '(repeat (cons regexp string))
+  :group 'vc)
 
 (defun vc-arch-mode-line-string (file)
   "Return string for placement in modeline by `vc-mode-line' for FILE."
diff --git a/lisp/woman.el b/lisp/woman.el
index ba511bca1ae..cea1c61bcc4 100644
--- a/lisp/woman.el
+++ b/lisp/woman.el
@@ -5,7 +5,7 @@
 ;; Author: Francis J. Wright <F.J.Wright@qmul.ac.uk>
 ;; Maintainer: Francis J. Wright <F.J.Wright@qmul.ac.uk>
 ;; Keywords: help, unix
-;; Adapted-By: Eli Zaretskii <eliz@is.elta.co.il>
+;; Adapted-By: Eli Zaretskii <eliz@gnu.org>
 ;; Version: see `woman-version'
 ;; URL: http://centaur.maths.qmul.ac.uk/Emacs/WoMan/