Much whitespace and capitalization change.

[gnu-emacs] / lisp / replace.el

diff --git a/lisp/replace.el b/lisp/replace.el
index a7c8b859402627e8813270d4c1cf2bb31871cf17..97b05cbc80ab2883192c57f10f6673ade61f055e 100644 (file)
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -92,9 +92,10 @@ wants to replace FROM with TO."
                 (format "%s: " string))
               nil nil nil
               query-replace-from-history-variable
-              nil t))))
+              nil t t))))
       (if (and (zerop (length from)) lastto lastfrom)
-         (cons lastfrom lastto)
+         (cons lastfrom
+               (query-replace-compile-replacement lastto regexp-flag))
        ;; Warn if user types \n or \t, but don't reject the input.
        (and regexp-flag
             (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\[nt]\\)" from)
@@ -107,15 +108,12 @@ wants to replace FROM with TO."
               (sit-for 2)))
        from))))
 
-(defun query-replace-read-to (from string regexp-flag)
-  "Query and return the `from' argument of a query-replace operation."
-  (let ((to (save-excursion
-             (read-from-minibuffer
-              (format "%s %s with: " string (query-replace-descr from))
-              nil nil nil
-              query-replace-to-history-variable from t))))
-    (when (and regexp-flag
-              (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]" to))
+(defun query-replace-compile-replacement (to regexp-flag)
+  "Maybe convert a regexp replacement TO to Lisp.
+Returns a list suitable for `perform-replace' if necessary,
+the original string if not."
+  (if (and regexp-flag
+          (string-match "\\(\\`\\|[^\\]\\)\\(\\\\\\\\\\)*\\\\[,#]" to))
       (let (pos list char)
        (while
            (progn
@@ -142,14 +140,25 @@ wants to replace FROM with TO."
                              (cdr pos))))
                       (setq to (substring to end)))))
              (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)))))
+       (setq to (nreverse (delete "" (cons to list))))
+       (replace-match-string-symbols to)
+       (cons 'replace-eval-replacement
+             (if (cdr to)
+                 (cons 'concat to)
+               (car to))))
     to))
 
+
+(defun query-replace-read-to (from string regexp-flag)
+  "Query and return the `to' argument of a query-replace operation."
+  (query-replace-compile-replacement
+   (save-excursion
+     (read-from-minibuffer
+      (format "%s %s with: " string (query-replace-descr from))
+      nil nil nil
+      query-replace-to-history-variable from t t))
+   regexp-flag))
+
 (defun query-replace-read-args (string regexp-flag &optional noerror)
   (unless noerror
     (barf-if-buffer-read-only))
@@ -287,6 +296,7 @@ Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches that are surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on."
   (interactive
+   (progn
    (barf-if-buffer-read-only)
    (let* ((from
           ;; Let-bind the history var to disable the "foo -> bar" default.
@@ -305,7 +315,7 @@ Fourth and fifth arg START and END specify the region to operate on."
           (if (and transient-mark-mode mark-active)
               (region-beginning))
           (if (and transient-mark-mode mark-active)
-              (region-end)))))
+              (region-end))))))
   (perform-replace regexp (cons 'replace-eval-replacement to-expr)
                   t 'literal delimited nil nil start end))
 
@@ -608,6 +618,7 @@ end of the buffer."
     (define-key map "g" 'revert-buffer)
     (define-key map "q" 'quit-window)
     (define-key map "z" 'kill-this-buffer)
+    (define-key map "\C-c\C-f" 'next-error-follow-minor-mode)
     map)
   "Keymap for `occur-mode'.")
 
@@ -731,6 +742,8 @@ Compatibility function for \\[next-error] invocations."
        #'previous-single-property-change
      #'next-single-property-change)
    "No more matches")
+  ;; In case the *Occur* buffer is visible in a nonselected window.
+  (set-window-point (get-buffer-window (current-buffer)) (point))
   (occur-mode-goto-occurrence))
 
 \f
@@ -785,7 +798,8 @@ If the value is nil, don't highlight the buffer names specially."
                 nil
                 nil
                 nil
-                'regexp-history)))
+                'regexp-history
+                default)))
          (if (equal input "")
              default
            input))
@@ -1007,9 +1021,11 @@ See also `multi-occur'."
                              ;; concatenate them all together.
                              (apply #'concat
                                     (nconc
-                                     (occur-engine-add-prefix (nreverse (cdr (occur-accumulate-lines (- (1+ nlines)) keep-props))))
+                                     (occur-engine-add-prefix (nreverse (cdr (occur-accumulate-lines (- (1+ (abs nlines))) keep-props))))
                                      (list out-line)
-                                     (occur-engine-add-prefix (cdr (occur-accumulate-lines (1+ nlines) keep-props))))))))
+                                     (if (> nlines 0)
+                                         (occur-engine-add-prefix
+                                          (cdr (occur-accumulate-lines (1+ nlines) keep-props)))))))))
                      ;; Actually insert the match display data
                      (with-current-buffer out-buf
                        (let ((beg (point))
@@ -1377,7 +1393,9 @@ make, or the user didn't cancel the call."
                  ;; Bind message-log-max so we don't fill up the message log
                  ;; with a bunch of identical messages.
                  (let ((message-log-max nil))
-                   (message message from-string next-replacement))
+                   (message message
+                             (query-replace-descr from-string)
+                             (query-replace-descr next-replacement)))
                  (setq key (read-event))
                  ;; Necessary in case something happens during read-event
                  ;; that clobbers the match data.