is used as a variable to hold a history list for the strings
or patterns to be replaced."
:group 'matching
- :type 'symbol)
+ :type 'symbol
+ :version "20.3")
(defcustom query-replace-to-history-variable 'query-replace-history
"History list to use for the TO argument of query-replace commands.
is used as a variable to hold a history list for replacement
strings or patterns."
:group 'matching
- :type 'symbol)
+ :type 'symbol
+ :version "20.3")
(defun query-replace-read-args (string regexp-flag)
(let (from to)
string is used as FROM-STRING--you don't have to specify it with the
minibuffer.
-Preserves case in each replacement if `case-replace' and `case-fold-search'
+Replacement transfers the case of the old text to the new text,
+if `case-replace' and `case-fold-search'
are non-nil and FROM-STRING has no uppercase letters.
\(Preserving case means that if the string matched is all caps, or capitalized,
then its replacement is upcased or capitalized.)
whatever what matched the Nth `\\(...\\)' in REGEXP."
(interactive (query-replace-read-args "Query replace regexp" t))
(perform-replace regexp to-string t t arg))
+(define-key esc-map [?\C-%] 'query-replace-regexp)
(defun map-query-replace-regexp (regexp to-strings &optional arg)
"Replace some matches for REGEXP with various strings, in rotation.
(defun keep-lines (regexp)
"Delete all lines except those containing matches for REGEXP.
A match split across lines preserves all the lines it lies in.
-Applies to all lines after point."
+Applies to all lines after point.
+
+If REGEXP contains upper case characters (excluding those preceded by `\\'),
+the matching is case-sensitive."
(interactive (list (read-from-minibuffer
"Keep lines (containing match for regexp): "
nil nil nil 'regexp-history nil t)))
(save-excursion
(or (bolp) (forward-line 1))
- (let ((start (point)))
+ (let ((start (point))
+ (case-fold-search (and case-fold-search
+ (isearch-no-upper-case-p regexp t))))
(while (not (eobp))
;; Start is first char not preserved by previous match.
(if (not (re-search-forward regexp nil 'move))
(defun flush-lines (regexp)
"Delete lines containing matches for REGEXP.
If a match is split across lines, all the lines it lies in are deleted.
-Applies to lines after point."
+Applies to lines after point.
+
+If REGEXP contains upper case characters (excluding those preceded by `\\'),
+the matching is case-sensitive."
(interactive (list (read-from-minibuffer
"Flush lines (containing match for regexp): "
nil nil nil 'regexp-history nil t)))
- (save-excursion
- (while (and (not (eobp))
- (re-search-forward regexp nil t))
- (delete-region (save-excursion (goto-char (match-beginning 0))
- (beginning-of-line)
- (point))
- (progn (forward-line 1) (point))))))
+ (let ((case-fold-search (and case-fold-search
+ (isearch-no-upper-case-p regexp t))))
+ (save-excursion
+ (while (and (not (eobp))
+ (re-search-forward regexp nil t))
+ (delete-region (save-excursion (goto-char (match-beginning 0))
+ (beginning-of-line)
+ (point))
+ (progn (forward-line 1) (point)))))))
(defalias 'count-matches 'how-many)
(defun how-many (regexp)
- "Print number of matches for REGEXP following point."
- (interactive (list(read-from-minibuffer
- "How many matches for (regexp): "
- nil nil nil 'regexp-history nil t)))
- (let ((count 0) opoint)
+ "Print number of matches for REGEXP following point.
+
+If REGEXP contains upper case characters (excluding those preceded by `\\'),
+the matching is case-sensitive."
+ (interactive (list (read-from-minibuffer
+ "How many matches for (regexp): "
+ nil nil nil 'regexp-history nil t)))
+ (let ((count 0) opoint
+ (case-fold-search (and case-fold-search
+ (isearch-no-upper-case-p regexp t))))
(save-excursion
(while (and (not (eobp))
(progn (setq opoint (point))
(format "%d lines" occur-num-matches))))
(insert message-string)
(if (interactive-p)
- (message "%s matched" message-string)))))))))
+ (message "%s matched" message-string)))
+ (setq buffer-read-only t)))))))
\f
;; It would be nice to use \\[...], but there is no reasonable way
;; to make that display both SPC and Y.
(setq replacement-index (% (1+ replacement-index) (length replacements)))))
(if (not query-flag)
(progn
- (store-match-data real-match-data)
+ (set-match-data real-match-data)
(replace-match next-replacement nocasify literal)
(setq replace-count (1+ replace-count)))
(undo-boundary)
;; Loop reading commands until one of them sets done,
;; which means it has finished handling this occurrence.
(while (not done)
- (store-match-data real-match-data)
+ (set-match-data real-match-data)
(replace-highlight (match-beginning 0) (match-end 0))
;; Bind message-log-max so we don't fill up the message log
;; with a bunch of identical messages.
(setq key (read-event))
;; Necessary in case something happens during read-event
;; that clobbers the match data.
- (store-match-data real-match-data)
+ (set-match-data real-match-data)
(setq key (vector key))
(setq def (lookup-key map key))
;; Restore the match data while we process the command.
(goto-char (car elt))
(setq replaced (eq t (cdr elt)))
(or replaced
- (store-match-data (cdr elt)))
+ (set-match-data (cdr elt)))
(setq stack (cdr stack)))
(message "No previous match")
(ding 'no-terminate)
((eq def 'recenter)
(recenter nil))
((eq def 'edit)
- (store-match-data
- (prog1 (match-data)
- (save-excursion (recursive-edit))))
+ (let ((opos (point-marker)))
+ (goto-char (match-beginning 0))
+ (save-excursion
+ (funcall search-function search-string limit t)
+ (setq real-match-data (match-data)))
+ (save-excursion (recursive-edit))
+ (goto-char opos))
+ (set-match-data real-match-data)
;; Before we make the replacement,
;; decide whether the search string
;; can match again just after this match.
(match-data)))))
((eq def 'delete-and-edit)
(delete-region (match-beginning 0) (match-end 0))
- (store-match-data
+ (set-match-data
(prog1 (match-data)
(save-excursion (recursive-edit))))
(setq replaced t))