;; along with GNU Emacs; see the file COPYING. If not, write to
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+;;; Commentary:
+
+;; This package supplies the string and regular-expression replace functions
+;; documented in the Emacs user's manual.
+
;;; Code:
(defconst case-replace t "\
(interactive (query-replace-read-args "Replace regexp"))
(perform-replace regexp to-string nil t delimited)
(or unread-command-events (message "Done")))
+\f
+(defvar regexp-history nil
+ "History list for some commands that read regular expressions.")
-(fset 'delete-non-matching-lines 'keep-lines)
+(defalias 'delete-non-matching-lines 'keep-lines)
(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."
- (interactive "sKeep lines (containing match for regexp): ")
+ (interactive (list (read-from-minibuffer
+ "Keep lines (containing match for regexp): "
+ nil nil nil 'regexp-history)))
(save-excursion
(or (bolp) (forward-line 1))
(let ((start (point)))
(and (not (eobp)) (= (match-beginning 0) (match-end 0))
(forward-char 1))))))
-(fset 'delete-matching-lines 'flush-lines)
+(defalias 'delete-matching-lines 'flush-lines)
(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."
- (interactive "sFlush lines (containing match for regexp): ")
+ (interactive (list (read-from-minibuffer
+ "Flush lines (containing match for regexp): "
+ nil nil nil 'regexp-history)))
(save-excursion
(while (and (not (eobp))
(re-search-forward regexp nil t))
(point))
(progn (forward-line 1) (point))))))
-(fset 'count-matches 'how-many)
+(defalias 'count-matches 'how-many)
(defun how-many (regexp)
"Print number of matches for REGEXP following point."
- (interactive "sHow many matches for (regexp): ")
+ (interactive (list (read-from-minibuffer
+ "How many matches for (regexp): "
+ nil nil nil 'regexp-history)))
(let ((count 0) opoint)
(save-excursion
(while (and (not (eobp))
(forward-char 1)
(setq count (1+ count))))
(message "%d occurrences" count))))
-
+\f
(defvar occur-mode-map ())
(if occur-mode-map
()
(defvar occur-buffer nil)
(defvar occur-nlines nil)
(defvar occur-pos-list nil)
-(defvar occur-last-string "")
(defun occur-mode ()
"Major mode for output from \\[occur].
(setq mode-name "Occur")
(make-local-variable 'occur-buffer)
(make-local-variable 'occur-nlines)
- (make-local-variable 'occur-pos-list))
+ (make-local-variable 'occur-pos-list)
+ (run-hooks 'occur-mode-hook))
(defun occur-mode-goto-occurrence ()
"Go to the line this occurrence was found in, in the buffer it was found in."
(+ 2 (* 2 occur-nlines)))
(t 1)))))
(pos (nth occur-number occur-pos-list)))
+ (or pos
+ (error "No occurrence on this line"))
(pop-to-buffer occur-buffer)
(goto-char (marker-position pos))))
-
+\f
(defvar list-matching-lines-default-context-lines 0
"*Default number of context lines to include around a `list-matching-lines'
match. A negative number means to include that many lines before the match.
A positive number means to include that many lines both before and after.")
-(fset 'list-matching-lines 'occur)
+(defalias 'list-matching-lines 'occur)
(defun occur (regexp &optional nlines)
"Show all lines in the current buffer containing a match for REGEXP.
-Interactively, REGEXP defaults to the last REGEXP
-used interactively with \\[occur].
If a match spreads across multiple lines, all those lines are shown.
NLINES defaults to `list-matching-lines-default-context-lines'.
Interactively it is the prefix arg.
-The lines are shown in a buffer named *Occur*.
+The lines are shown in a buffer named `*Occur*'.
It serves as a menu to find any of the occurrences in this buffer.
\\[describe-mode] in that buffer will explain how."
- (interactive (list (setq occur-last-string
- (read-string "List lines matching regexp: "
- occur-last-string))
+ (interactive (list (let* ((default (car regexp-history))
+ (input
+ (read-from-minibuffer
+ (if default
+ (format "List lines matching regexp (default `%s'): " default)
+ "List lines matching regexp: ")
+ nil nil nil
+ 'regexp-history)))
+ (if (> (length input) 0) input
+ (setcar regexp-history default)))
current-prefix-arg))
(setq nlines (if nlines (prefix-numeric-value nlines)
list-matching-lines-default-context-lines))
(re-search-forward regexp nil t))
(goto-char (match-beginning 0))
(beginning-of-line)
- (setq linenum (+ linenum (count-lines prevpos (point))))
+ (save-match-data
+ (setq linenum (+ linenum (count-lines prevpos (point)))))
(setq prevpos (point))
(goto-char (match-end 0))
(let* ((start (save-excursion
;; to make that display both SPC and Y.
(defconst query-replace-help
"Type Space or `y' to replace one match, Delete or `n' to skip to next,
-ESC or `q' to exit, Period to replace one match and exit,
+RET or `q' to exit, Period to replace one match and exit,
Comma to replace but not move point immediately,
C-r to enter recursive edit (\\[exit-recursive-edit] to get out again),
C-w to delete match and recursive edit,
(define-key query-replace-map " " 'act)
(define-key query-replace-map "\d" 'skip)
(define-key query-replace-map [delete] 'skip)
+(define-key query-replace-map [backspace] 'skip)
(define-key query-replace-map "y" 'act)
(define-key query-replace-map "n" 'skip)
(define-key query-replace-map "," 'act-and-show)
-(define-key query-replace-map "\e" 'exit)
(define-key query-replace-map "q" 'exit)
+(define-key query-replace-map "\r" 'exit)
+(define-key query-replace-map [return] 'exit)
(define-key query-replace-map "." 'act-and-exit)
(define-key query-replace-map "\C-r" 'edit)
(define-key query-replace-map "\C-w" 'delete-and-edit)
(define-key query-replace-map "^" 'backup)
(define-key query-replace-map "\C-h" 'help)
(define-key query-replace-map "?" 'help)
-;; Cause all other types of events to be unread immediately,
-;; without regard to the global map.
-(define-key query-replace-map [t] 'ignore)
+(define-key query-replace-map "\C-g" 'quit)
+(define-key query-replace-map "\C-]" 'quit)
(defun perform-replace (from-string replacements
query-flag regexp-flag delimited-flag
(replace-match next-replacement nocasify literal)
(setq replace-count (1+ replace-count)))
(undo-boundary)
- (let (done replaced key)
+ (let (done replaced key def)
;; Loop reading commands until one of them sets done,
;; which means it has finished handling this occurrence.
(while (not done)
- (message "Query replacing %s with %s: "
+ (message (substitute-command-keys
+ "Query replacing %s with %s: (\\<query-replace-map>\\[help] for help) ")
from-string next-replacement)
- (setq key (vector (read-event)))
+ (setq key (read-event))
+ (setq key (vector key))
(setq def (lookup-key map key))
;; Restore the match data while we process the command.
(store-match-data real-match-data)
HCoop / bpt / emacs.git / blobdiff