lisp/replace.el

   1 ;;; replace.el --- replace commands for Emacs.
   2
   3 ;; Copyright (C) 1985, 1986, 1987, 1992, 1994 Free Software Foundation, Inc.
   4
   5 ;; This file is part of GNU Emacs.
   6
   7 ;; GNU Emacs is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published by
   9 ;; the Free Software Foundation; either version 2, or (at your option)
  10 ;; any later version.
  11
  12 ;; GNU Emacs is distributed in the hope that it will be useful,
  13 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 ;; GNU General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  19 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 ;;; Commentary:
  22
  23 ;; This package supplies the string and regular-expression replace functions
  24 ;; documented in the Emacs user's manual.
  25
  26 ;;; Code:
  27
  28 (defconst case-replace t "\
  29 *Non-nil means query-replace should preserve case in replacements.")
  30
  31 (defvar query-replace-history nil)
  32
  33 (defun query-replace-read-args (string)
  34   (let (from to)
  35     (setq from (read-from-minibuffer (format "%s: " string)
  36                                      nil nil nil
  37                                      'query-replace-history))
  38     (setq to (read-from-minibuffer (format "%s %s with: " string from)
  39                                    nil nil nil
  40                                    'query-replace-history))
  41     (list from to current-prefix-arg)))
  42
  43 (defun query-replace (from-string to-string &optional arg)
  44   "Replace some occurrences of FROM-STRING with TO-STRING.
  45 As each match is found, the user must type a character saying
  46 what to do with it.  For directions, type \\[help-command] at that time.
  47
  48 Preserves case in each replacement if  case-replace  and  case-fold-search
  49 are non-nil and FROM-STRING has no uppercase letters.
  50 Third arg DELIMITED (prefix arg if interactive) non-nil means replace
  51 only matches surrounded by word boundaries.
  52
  53 To customize possible responses, change the \"bindings\" in `query-replace-map'."
  54   (interactive (query-replace-read-args "Query replace"))
  55   (perform-replace from-string to-string t nil arg)
  56   (or unread-command-events (message "Done")))
  57 (define-key esc-map "%" 'query-replace)
  58
  59 (defun query-replace-regexp (regexp to-string &optional arg)
  60   "Replace some things after point matching REGEXP with TO-STRING.
  61 As each match is found, the user must type a character saying
  62 what to do with it.  For directions, type \\[help-command] at that time.
  63
  64 Preserves case in each replacement if  case-replace  and  case-fold-search
  65 are non-nil and REGEXP has no uppercase letters.
  66 Third arg DELIMITED (prefix arg if interactive) non-nil means replace
  67 only matches surrounded by word boundaries.
  68 In TO-STRING, \\& means insert what matched REGEXP,
  69 and \\=\\<n> means insert what matched <n>th \\(...\\) in REGEXP."
  70   (interactive (query-replace-read-args "Query replace regexp"))
  71   (perform-replace regexp to-string t t arg)
  72   (or unread-command-events (message "Done")))
  73
  74 (defun map-query-replace-regexp (regexp to-strings &optional arg)
  75   "Replace some matches for REGEXP with various strings, in rotation.
  76 The second argument TO-STRINGS contains the replacement strings, separated
  77 by spaces.  This command works like `query-replace-regexp' except
  78 that each successive replacement uses the next successive replacement string,
  79 wrapping around from the last such string to the first.
  80
  81 Non-interactively, TO-STRINGS may be a list of replacement strings.
  82
  83 A prefix argument N says to use each replacement string N times
  84 before rotating to the next."
  85   (interactive
  86    (let (from to)
  87      (setq from (read-from-minibuffer "Map query replace (regexp): "
  88                                       nil nil nil
  89                                       'query-replace-history))
  90      (setq to (read-from-minibuffer
  91                (format "Query replace %s with (space-separated strings): "
  92                        from)
  93                nil nil nil
  94                'query-replace-history))
  95      (list from to current-prefix-arg)))
  96   (let (replacements)
  97     (if (listp to-strings)
  98         (setq replacements to-strings)
  99       (while (/= (length to-strings) 0)
 100         (if (string-match " " to-strings)
 101             (setq replacements
 102                   (append replacements
 103                           (list (substring to-strings 0
 104                                            (string-match " " to-strings))))
 105                   to-strings (substring to-strings
 106                                        (1+ (string-match " " to-strings))))
 107           (setq replacements (append replacements (list to-strings))
 108                 to-strings ""))))
 109     (perform-replace regexp replacements t t nil arg))
 110   (or unread-command-events (message "Done")))
 111
 112 (defun replace-string (from-string to-string &optional delimited)
 113   "Replace occurrences of FROM-STRING with TO-STRING.
 114 Preserve case in each match if `case-replace' and `case-fold-search'
 115 are non-nil and FROM-STRING has no uppercase letters.
 116 Third arg DELIMITED (prefix arg if interactive) non-nil means replace
 117 only matches surrounded by word boundaries.
 118
 119 This function is usually the wrong thing to use in a Lisp program.
 120 What you probably want is a loop like this:
 121   (while (search-forward OLD-STRING nil t)
 122     (replace-match REPLACEMENT nil t))
 123 which will run faster and will not set the mark or print anything."
 124   (interactive (query-replace-read-args "Replace string"))
 125   (perform-replace from-string to-string nil nil delimited)
 126   (or unread-command-events (message "Done")))
 127
 128 (defun replace-regexp (regexp to-string &optional delimited)
 129   "Replace things after point matching REGEXP with TO-STRING.
 130 Preserve case in each match if case-replace and case-fold-search
 131 are non-nil and REGEXP has no uppercase letters.
 132 Third arg DELIMITED (prefix arg if interactive) non-nil means replace
 133 only matches surrounded by word boundaries.
 134 In TO-STRING, \\& means insert what matched REGEXP,
 135 and \\=\\<n> means insert what matched <n>th \\(...\\) in REGEXP.
 136
 137 This function is usually the wrong thing to use in a Lisp program.
 138 What you probably want is a loop like this:
 139   (while (re-search-forward REGEXP nil t)
 140     (replace-match REPLACEMENT nil nil))
 141 which will run faster and will not set the mark or print anything."
 142   (interactive (query-replace-read-args "Replace regexp"))
 143   (perform-replace regexp to-string nil t delimited)
 144   (or unread-command-events (message "Done")))
 145 \f
 146 (defvar regexp-history nil
 147   "History list for some commands that read regular expressions.")
 148
 149 (defalias 'delete-non-matching-lines 'keep-lines)
 150 (defun keep-lines (regexp)
 151   "Delete all lines except those containing matches for REGEXP.
 152 A match split across lines preserves all the lines it lies in.
 153 Applies to all lines after point."
 154   (interactive (list (read-from-minibuffer
 155                       "Keep lines (containing match for regexp): "
 156                       nil nil nil 'regexp-history)))
 157   (save-excursion
 158     (or (bolp) (forward-line 1))
 159     (let ((start (point)))
 160       (while (not (eobp))
 161         ;; Start is first char not preserved by previous match.
 162         (if (not (re-search-forward regexp nil 'move))
 163             (delete-region start (point-max))
 164           (let ((end (save-excursion (goto-char (match-beginning 0))
 165                                      (beginning-of-line)
 166                                      (point))))
 167             ;; Now end is first char preserved by the new match.
 168             (if (< start end)
 169                 (delete-region start end))))
 170         (setq start (save-excursion (forward-line 1)
 171                                     (point)))
 172         ;; If the match was empty, avoid matching again at same place.
 173         (and (not (eobp)) (= (match-beginning 0) (match-end 0))
 174              (forward-char 1))))))
 175
 176 (defalias 'delete-matching-lines 'flush-lines)
 177 (defun flush-lines (regexp)
 178   "Delete lines containing matches for REGEXP.
 179 If a match is split across lines, all the lines it lies in are deleted.
 180 Applies to lines after point."
 181   (interactive (list (read-from-minibuffer
 182                       "Flush lines (containing match for regexp): "
 183                       nil nil nil 'regexp-history)))
 184   (save-excursion
 185     (while (and (not (eobp))
 186                 (re-search-forward regexp nil t))
 187       (delete-region (save-excursion (goto-char (match-beginning 0))
 188                                      (beginning-of-line)
 189                                      (point))
 190                      (progn (forward-line 1) (point))))))
 191
 192 (defalias 'count-matches 'how-many)
 193 (defun how-many (regexp)
 194   "Print number of matches for REGEXP following point."
 195   (interactive (list (read-from-minibuffer
 196                       "How many matches for (regexp): "
 197                       nil nil nil 'regexp-history)))
 198   (let ((count 0) opoint)
 199     (save-excursion
 200      (while (and (not (eobp))
 201                  (progn (setq opoint (point))
 202                         (re-search-forward regexp nil t)))
 203        (if (= opoint (point))
 204            (forward-char 1)
 205          (setq count (1+ count))))
 206      (message "%d occurrences" count))))
 207 \f
 208 (defvar occur-mode-map ())
 209 (if occur-mode-map
 210     ()
 211   (setq occur-mode-map (make-sparse-keymap))
 212   (define-key occur-mode-map [mouse-2] 'occur-mode-mouse-goto)
 213   (define-key occur-mode-map "\C-c\C-c" 'occur-mode-goto-occurrence))
 214
 215 (defvar occur-buffer nil)
 216 (defvar occur-nlines nil)
 217 (defvar occur-pos-list nil)
 218
 219 (defun occur-mode ()
 220   "Major mode for output from \\[occur].
 221 Move point to one of the occurrences in this buffer,
 222 then use \\[occur-mode-goto-occurrence] to go to the same occurrence
 223 in the buffer that the occurrences were found in.
 224 Or click \\<occur-mode-map>\\[occur-mode-mouse-goto] on an occurrence line.
 225 \\{occur-mode-map}"
 226   (kill-all-local-variables)
 227   (use-local-map occur-mode-map)
 228   (setq major-mode 'occur-mode)
 229   (setq mode-name "Occur")
 230   (make-local-variable 'occur-buffer)
 231   (make-local-variable 'occur-nlines)
 232   (make-local-variable 'occur-pos-list)
 233   (run-hooks 'occur-mode-hook))
 234
 235 (defun occur-mode-mouse-goto (event)
 236   "In Occur mode, go to the occurrence whose line you click on."
 237   (interactive "e")
 238   (let (buffer pos)
 239     (save-excursion
 240       (set-buffer (window-buffer (posn-window (event-end event))))
 241       (save-excursion
 242         (goto-char (posn-point (event-end event)))
 243         (setq pos (occur-mode-find-occurrence))
 244         (setq buffer occur-buffer)))
 245     (pop-to-buffer buffer)
 246     (goto-char (marker-position pos))))
 247
 248 (defun occur-mode-find-occurrence ()
 249   (if (or (null occur-buffer)
 250           (null (buffer-name occur-buffer)))
 251       (progn
 252         (setq occur-buffer nil
 253               occur-pos-list nil)
 254         (error "Buffer in which occurrences were found is deleted")))
 255   (let* ((line-count
 256           (count-lines (point-min)
 257                        (save-excursion
 258                          (beginning-of-line)
 259                          (point))))
 260          (occur-number (save-excursion
 261                          (beginning-of-line)
 262                          (/ (1- line-count)
 263                             (cond ((< occur-nlines 0)
 264                                    (- 2 occur-nlines))
 265                                   ((> occur-nlines 0)
 266                                    (+ 2 (* 2 occur-nlines)))
 267                                   (t 1)))))
 268          (pos (nth occur-number occur-pos-list)))
 269     (if (< line-count 1)
 270         (error "No occurrence on this line"))
 271     (or pos
 272         (error "No occurrence on this line"))
 273     pos))
 274
 275 (defun occur-mode-goto-occurrence ()
 276   "Go to the occurrence the current line describes."
 277   (interactive)
 278   (let ((pos (occur-mode-find-occurrence)))
 279     (pop-to-buffer occur-buffer)
 280     (goto-char (marker-position pos))))
 281 \f
 282 (defvar list-matching-lines-default-context-lines 0
 283   "*Default number of context lines to include around a `list-matching-lines'
 284 match.  A negative number means to include that many lines before the match.
 285 A positive number means to include that many lines both before and after.")
 286
 287 (defalias 'list-matching-lines 'occur)
 288
 289 (defun occur (regexp &optional nlines)
 290   "Show all lines in the current buffer containing a match for REGEXP.
 291
 292 If a match spreads across multiple lines, all those lines are shown.
 293
 294 Each line is displayed with NLINES lines before and after, or -NLINES
 295 before if NLINES is negative.
 296 NLINES defaults to `list-matching-lines-default-context-lines'.
 297 Interactively it is the prefix arg.
 298
 299 The lines are shown in a buffer named `*Occur*'.
 300 It serves as a menu to find any of the occurrences in this buffer.
 301 \\[describe-mode] in that buffer will explain how."
 302   (interactive (list (let* ((default (car regexp-history))
 303                             (input
 304                              (read-from-minibuffer
 305                               (if default
 306                                   (format "List lines matching regexp (default `%s'): " default)
 307                                 "List lines matching regexp: ")
 308                               nil nil nil
 309                               'regexp-history)))
 310                        (if (> (length input) 0) input
 311                          (setcar regexp-history default)))
 312                      current-prefix-arg))
 313   (setq nlines (if nlines (prefix-numeric-value nlines)
 314                  list-matching-lines-default-context-lines))
 315   (let ((first t)
 316         (buffer (current-buffer))
 317         (linenum 1)
 318         (prevpos (point-min))
 319         (final-context-start (make-marker)))
 320 ;;;     (save-excursion
 321 ;;;       (beginning-of-line)
 322 ;;;       (setq linenum (1+ (count-lines (point-min) (point))))
 323 ;;;       (setq prevpos (point)))
 324     (with-output-to-temp-buffer "*Occur*"
 325       (save-excursion
 326         (set-buffer standard-output)
 327         (insert "Lines matching ")
 328         (prin1 regexp)
 329         (insert " in buffer " (buffer-name buffer) ?. ?\n)
 330         (occur-mode)
 331         (setq occur-buffer buffer)
 332         (setq occur-nlines nlines)
 333         (setq occur-pos-list ()))
 334       (if (eq buffer standard-output)
 335           (goto-char (point-max)))
 336       (save-excursion
 337         (beginning-of-buffer)
 338         ;; Find next match, but give up if prev match was at end of buffer.
 339         (while (and (not (= prevpos (point-max)))
 340                     (re-search-forward regexp nil t))
 341           (goto-char (match-beginning 0))
 342           (beginning-of-line)
 343           (save-match-data
 344             (setq linenum (+ linenum (count-lines prevpos (point)))))
 345           (setq prevpos (point))
 346           (goto-char (match-end 0))
 347           (let* ((start (save-excursion
 348                           (goto-char (match-beginning 0))
 349                           (forward-line (if (< nlines 0) nlines (- nlines)))
 350                           (point)))
 351                  (end (save-excursion
 352                         (goto-char (match-end 0))
 353                         (if (> nlines 0)
 354                             (forward-line (1+ nlines))
 355                             (forward-line 1))
 356                         (point)))
 357                  (tag (format "%3d" linenum))
 358                  (empty (make-string (length tag) ?\ ))
 359                  tem)
 360             (save-excursion
 361               (setq tem (make-marker))
 362               (set-marker tem (point))
 363               (set-buffer standard-output)
 364               (setq occur-pos-list (cons tem occur-pos-list))
 365               (or first (zerop nlines)
 366                   (insert "--------\n"))
 367               (setq first nil)
 368               (insert-buffer-substring buffer start end)
 369               (backward-char (- end start))
 370               (setq tem nlines)
 371               (while (> tem 0)
 372                 (insert empty ?:)
 373                 (forward-line 1)
 374                 (setq tem (1- tem)))
 375               (let ((this-linenum linenum))
 376                 (set-marker final-context-start
 377                             (+ (point) (- (match-end 0) (match-beginning 0))))
 378                 (while (< (point) final-context-start)
 379                   (if (null tag)
 380                       (setq tag (format "%3d" this-linenum)))
 381                   (insert tag ?:)
 382                   (put-text-property (save-excursion
 383                                        (beginning-of-line)
 384                                        (point))
 385                                      (save-excursion
 386                                        (end-of-line)
 387                                        (point))
 388                                      'mouse-face 'highlight)
 389                   (setq tag nil)
 390                   (forward-line 1)
 391                   (setq this-linenum (1+ this-linenum))))
 392               (while (< tem nlines)
 393                 (insert empty ?:)
 394                 (forward-line 1)
 395                 (setq tem (1+ tem))))
 396             (forward-line 1)))
 397         (set-buffer standard-output)
 398         ;; Put positions in increasing order to go with buffer.
 399         (setq occur-pos-list (nreverse occur-pos-list))
 400         (if (interactive-p)
 401             (message "%d matching lines." (length occur-pos-list)))))))
 402 \f
 403 ;; It would be nice to use \\[...], but there is no reasonable way
 404 ;; to make that display both SPC and Y.
 405 (defconst query-replace-help
 406   "Type Space or `y' to replace one match, Delete or `n' to skip to next,
 407 RET or `q' to exit, Period to replace one match and exit,
 408 Comma to replace but not move point immediately,
 409 C-r to enter recursive edit (\\[exit-recursive-edit] to get out again),
 410 C-w to delete match and recursive edit,
 411 C-l to clear the screen, redisplay, and offer same replacement again,
 412 ! to replace all remaining matches with no more questions,
 413 ^ to move point back to previous match."
 414   "Help message while in query-replace")
 415
 416 (defvar query-replace-map (make-sparse-keymap)
 417   "Keymap that defines the responses to questions in `query-replace'.
 418 The \"bindings\" in this map are not commands; they are answers.
 419 The valid answers include `act', `skip', `act-and-show',
 420 `exit', `act-and-exit', `edit', `delete-and-edit', `recenter',
 421 `automatic', `backup', and `help'.")
 422
 423 (define-key query-replace-map " " 'act)
 424 (define-key query-replace-map "\d" 'skip)
 425 (define-key query-replace-map [delete] 'skip)
 426 (define-key query-replace-map [backspace] 'skip)
 427 (define-key query-replace-map "y" 'act)
 428 (define-key query-replace-map "n" 'skip)
 429 (define-key query-replace-map "," 'act-and-show)
 430 (define-key query-replace-map "q" 'exit)
 431 (define-key query-replace-map "\r" 'exit)
 432 (define-key query-replace-map [return] 'exit)
 433 (define-key query-replace-map "." 'act-and-exit)
 434 (define-key query-replace-map "\C-r" 'edit)
 435 (define-key query-replace-map "\C-w" 'delete-and-edit)
 436 (define-key query-replace-map "\C-l" 'recenter)
 437 (define-key query-replace-map "!" 'automatic)
 438 (define-key query-replace-map "^" 'backup)
 439 (define-key query-replace-map "\C-h" 'help)
 440 (define-key query-replace-map "?" 'help)
 441 (define-key query-replace-map "\C-g" 'quit)
 442 (define-key query-replace-map "\C-]" 'quit)
 443
 444 (defun perform-replace (from-string replacements
 445                         query-flag regexp-flag delimited-flag
 446                         &optional repeat-count map)
 447   "Subroutine of `query-replace'.  Its complexity handles interactive queries.
 448 Don't use this in your own program unless you want to query and set the mark
 449 just as `query-replace' does.  Instead, write a simple loop like this:
 450   (while (re-search-forward \"foo[ \t]+bar\" nil t)
 451     (replace-match \"foobar\" nil nil))
 452 which will run faster and probably do exactly what you want."
 453   (or map (setq map query-replace-map))
 454   (let ((nocasify (not (and case-fold-search case-replace
 455                             (string-equal from-string
 456                                           (downcase from-string)))))
 457         (literal (not regexp-flag))
 458         (search-function (if regexp-flag 're-search-forward 'search-forward))
 459         (search-string from-string)
 460         (real-match-data nil)           ; the match data for the current match
 461         (next-replacement nil)
 462         (replacement-index 0)
 463         (keep-going t)
 464         (stack nil)
 465         (next-rotate-count 0)
 466         (replace-count 0)
 467         (lastrepl nil)                  ;Position after last match considered.
 468         (match-again t))
 469     (if (stringp replacements)
 470         (setq next-replacement replacements)
 471       (or repeat-count (setq repeat-count 1)))
 472     (if delimited-flag
 473         (setq search-function 're-search-forward
 474               search-string (concat "\\b"
 475                                     (if regexp-flag from-string
 476                                       (regexp-quote from-string))
 477                                     "\\b")))
 478     (push-mark)
 479     (undo-boundary)
 480     (unwind-protect
 481         ;; Loop finding occurrences that perhaps should be replaced.
 482         (while (and keep-going
 483                     (not (eobp))
 484                     (funcall search-function search-string nil t)
 485                     ;; If the search string matches immediately after
 486                     ;; the previous match, but it did not match there
 487                     ;; before the replacement was done, ignore the match.
 488                     (if (or (eq lastrepl (point))
 489                             (and regexp-flag
 490                                  (eq lastrepl (match-beginning 0))
 491                                  (not match-again)))
 492                         (if (eobp)
 493                             nil
 494                           ;; Don't replace the null string
 495                           ;; right after end of previous replacement.
 496                           (forward-char 1)
 497                           (funcall search-function search-string nil t))
 498                       t))
 499
 500           ;; Save the data associated with the real match.
 501           (setq real-match-data (match-data))
 502
 503           ;; Before we make the replacement, decide whether the search string
 504           ;; can match again just after this match.
 505           (if regexp-flag
 506               (setq match-again (looking-at search-string)))
 507           ;; If time for a change, advance to next replacement string.
 508           (if (and (listp replacements)
 509                    (= next-rotate-count replace-count))
 510               (progn
 511                 (setq next-rotate-count
 512                       (+ next-rotate-count repeat-count))
 513                 (setq next-replacement (nth replacement-index replacements))
 514                 (setq replacement-index (% (1+ replacement-index) (length replacements)))))
 515           (if (not query-flag)
 516               (progn
 517                 (store-match-data real-match-data)
 518                 (replace-match next-replacement nocasify literal)
 519                 (setq replace-count (1+ replace-count)))
 520             (undo-boundary)
 521             (let (done replaced key def)
 522               ;; Loop reading commands until one of them sets done,
 523               ;; which means it has finished handling this occurrence.
 524               (while (not done)
 525                 (replace-highlight (match-beginning 0) (match-end 0))
 526                 (message (substitute-command-keys
 527                           "Query replacing %s with %s: (\\<query-replace-map>\\[help] for help) ")
 528                          from-string next-replacement)
 529                 (setq key (read-event))
 530                 (setq key (vector key))
 531                 (setq def (lookup-key map key))
 532                 ;; Restore the match data while we process the command.
 533                 (store-match-data real-match-data)
 534                 (cond ((eq def 'help)
 535                        (with-output-to-temp-buffer "*Help*"
 536                          (princ
 537                           (concat "Query replacing "
 538                                   (if regexp-flag "regexp " "")
 539                                   from-string " with "
 540                                   next-replacement ".\n\n"
 541                                   (substitute-command-keys
 542                                    query-replace-help)))))
 543                       ((eq def 'exit)
 544                        (setq keep-going nil)
 545                        (setq done t))
 546                       ((eq def 'backup)
 547                        (if stack
 548                            (let ((elt (car stack)))
 549                              (goto-char (car elt))
 550                              (setq replaced (eq t (cdr elt)))
 551                              (or replaced
 552                                  (store-match-data (cdr elt)))
 553                              (setq stack (cdr stack)))
 554                          (message "No previous match")
 555                          (ding 'no-terminate)
 556                          (sit-for 1)))
 557                       ((eq def 'act)
 558                        (or replaced
 559                            (replace-match next-replacement nocasify literal))
 560                        (setq done t replaced t))
 561                       ((eq def 'act-and-exit)
 562                        (or replaced
 563                            (replace-match next-replacement nocasify literal))
 564                        (setq keep-going nil)
 565                        (setq done t replaced t))
 566                       ((eq def 'act-and-show)
 567                        (if (not replaced)
 568                            (progn
 569                              (replace-match next-replacement nocasify literal)
 570                              (setq replaced t))))
 571                       ((eq def 'automatic)
 572                        (or replaced
 573                            (replace-match next-replacement nocasify literal))
 574                        (setq done t query-flag nil replaced t))
 575                       ((eq def 'skip)
 576                        (setq done t))
 577                       ((eq def 'recenter)
 578                        (recenter nil))
 579                       ((eq def 'edit)
 580                        (store-match-data
 581                         (prog1 (match-data)
 582                           (save-excursion (recursive-edit))))
 583                        ;; Before we make the replacement,
 584                        ;; decide whether the search string
 585                        ;; can match again just after this match.
 586                        (if regexp-flag
 587                            (setq match-again (looking-at search-string))))
 588                       ((eq def 'delete-and-edit)
 589                        (delete-region (match-beginning 0) (match-end 0))
 590                        (store-match-data
 591                         (prog1 (match-data)
 592                           (save-excursion (recursive-edit))))
 593                        (setq replaced t))
 594                       (t
 595                        (setq keep-going nil)
 596                        (setq unread-command-events
 597                              (append (listify-key-sequence key)
 598                                      unread-command-events))
 599                        (setq done t))))
 600               ;; Record previous position for ^ when we move on.
 601               ;; Change markers to numbers in the match data
 602               ;; since lots of markers slow down editing.
 603               (setq stack
 604                     (cons (cons (point)
 605                                 (or replaced
 606                                     (mapcar (lambda (elt)
 607                                               (and elt
 608                                                    (prog1 (marker-position elt)
 609                                                      (set-marker elt nil))))
 610                                      (match-data))))
 611                           stack))
 612               (if replaced (setq replace-count (1+ replace-count)))))
 613           (setq lastrepl (point)))
 614       (replace-dehighlight))
 615   (and keep-going stack)))
 616
 617 (defvar query-replace-highlight nil
 618   "*Non-nil means to highlight words during query replacement.")
 619
 620 (defvar replace-overlay nil)
 621
 622 (defun replace-dehighlight ()
 623   (and replace-overlay
 624        (progn
 625          (delete-overlay replace-overlay)
 626          (setq replace-overlay nil))))
 627
 628 (defun replace-highlight (start end)
 629   (and query-replace-highlight
 630        (progn
 631          (or replace-overlay
 632              (progn
 633                (setq replace-overlay (make-overlay start end))
 634                (overlay-put replace-overlay 'face
 635                             (if (internal-find-face 'query-replace)
 636                                 'query-replace 'region))))
 637          (move-overlay replace-overlay start end (current-buffer)))))
 638
 639 ;;; replace.el ends here