[Emacs-diffs] Changes to emacs/lisp/replace.el

[Luc Teirlinck]

Index: emacs/lisp/replace.el
diff -c emacs/lisp/replace.el:1.213 emacs/lisp/replace.el:1.214
*** emacs/lisp/replace.el:1.213 Fri Jun 24 02:39:59 2005
--- emacs/lisp/replace.el       Sun Jun 26 02:38:08 2005
***************
*** 516,536 ****
  Prompt for a regexp with PROMPT.
  Value is a list, (REGEXP)."
    (list (read-from-minibuffer prompt nil nil nil
!                             'regexp-history nil t)))
  
! (defun keep-lines (regexp &optional rstart rend)
    "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.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
  
  Second and third arg RSTART and REND specify the region to operate on.
  
  Interactively, in Transient Mark mode when the mark is active, operate
! on the contents of the region.  Otherwise, operate from point to the
! end of the buffer."
  
    (interactive
     (progn
--- 516,547 ----
  Prompt for a regexp with PROMPT.
  Value is a list, (REGEXP)."
    (list (read-from-minibuffer prompt nil nil nil
!                             'regexp-history nil t)
!       nil nil t))
  
! (defun keep-lines (regexp &optional rstart rend interactive)
    "Delete all lines except those containing matches for REGEXP.
  A match split across lines preserves all the lines it lies in.
! When called from Lisp (and usually interactively as well, see below)
! applies to all lines starting after point.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
  
  Second and third arg RSTART and REND specify the region to operate on.
+ This command operates on (the accessible part of) all lines whose
+ accessible part is entirely contained in the region determined by RSTART
+ and REND.  (A newline ending a line counts as part of that line.)
  
  Interactively, in Transient Mark mode when the mark is active, operate
! on all lines whose accessible part is entirely contained in the region.
! Otherwise, the command applies to all lines starting after point.
! When calling this function from Lisp, you can pretend that it was
! called interactively by passing a non-nil INTERACTIVE argument.
! 
! This function starts looking for the next match from the end of
! the previous match.  Hence, it ignores matches that overlap
! a previously found match."
  
    (interactive
     (progn
***************
*** 539,548 ****
    (if rstart
        (progn
        (goto-char (min rstart rend))
!       (setq rend (copy-marker (max rstart rend))))
!     (if (and transient-mark-mode mark-active)
        (setq rstart (region-beginning)
!             rend (copy-marker (region-end)))
        (setq rstart (point)
            rend (point-max-marker)))
      (goto-char rstart))
--- 550,569 ----
    (if rstart
        (progn
        (goto-char (min rstart rend))
!       (setq rend
!             (progn
!               (save-excursion
!                 (goto-char (max rstart rend))
!                 (unless (or (bolp) (eobp))
!                   (forward-line 0))
!                 (point-marker)))))
!     (if (and interactive transient-mark-mode mark-active)
        (setq rstart (region-beginning)
!             rend (progn
!                    (goto-char (region-end))
!                    (unless (or (bolp) (eobp))
!                      (forward-line 0))
!                    (point-marker)))
        (setq rstart (point)
            rend (point-max-marker)))
      (goto-char rstart))
***************
*** 556,562 ****
        (if (not (re-search-forward regexp rend 'move))
            (delete-region start rend)
          (let ((end (save-excursion (goto-char (match-beginning 0))
!                                    (beginning-of-line)
                                     (point))))
            ;; Now end is first char preserved by the new match.
            (if (< start end)
--- 577,583 ----
        (if (not (re-search-forward regexp rend 'move))
            (delete-region start rend)
          (let ((end (save-excursion (goto-char (match-beginning 0))
!                                    (forward-line 0)
                                     (point))))
            ;; Now end is first char preserved by the new match.
            (if (< start end)
***************
*** 566,587 ****
        ;; If the match was empty, avoid matching again at same place.
        (and (< (point) rend)
             (= (match-beginning 0) (match-end 0))
!            (forward-char 1))))))
  
  
! (defun flush-lines (regexp &optional rstart rend)
!   "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.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
  
  Second and third arg RSTART and REND specify the region to operate on.
  
  Interactively, in Transient Mark mode when the mark is active, operate
  on the contents of the region.  Otherwise, operate from point to the
! end of the buffer."
  
    (interactive
     (progn
--- 587,620 ----
        ;; If the match was empty, avoid matching again at same place.
        (and (< (point) rend)
             (= (match-beginning 0) (match-end 0))
!            (forward-char 1)))))
!   (set-marker rend nil)
!   nil)
  
  
! (defun flush-lines (regexp &optional rstart rend interactive)
!  "Delete lines containing matches for REGEXP.
! When called from Lisp (and usually when called interactively as
! well, see below), applies to the part of the buffer after point.
! The line point is in is deleted if and only if it contains a
! match for regexp starting after point.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
  
  Second and third arg RSTART and REND specify the region to operate on.
+ Lines partially contained in this region are deleted if and only if
+ they contain a match entirely contained in it.
  
  Interactively, in Transient Mark mode when the mark is active, operate
  on the contents of the region.  Otherwise, operate from point to the
! end of (the accessible portion of) the buffer.  When calling this function
! from Lisp, you can pretend that it was called interactively by passing
! a non-nil INTERACTIVE argument.
! 
! If a match is split across lines, all the lines it lies in are deleted.
! They are deleted _before_ looking for the next match.  Hence, a match
! starting on the same line at which another match ended is ignored."
  
    (interactive
     (progn
***************
*** 591,597 ****
        (progn
        (goto-char (min rstart rend))
        (setq rend (copy-marker (max rstart rend))))
!     (if (and transient-mark-mode mark-active)
        (setq rstart (region-beginning)
              rend (copy-marker (region-end)))
        (setq rstart (point)
--- 624,630 ----
        (progn
        (goto-char (min rstart rend))
        (setq rend (copy-marker (max rstart rend))))
!     (if (and interactive transient-mark-mode mark-active)
        (setq rstart (region-beginning)
              rend (copy-marker (region-end)))
        (setq rstart (point)
***************
*** 603,615 ****
        (while (and (< (point) rend)
                  (re-search-forward regexp rend t))
        (delete-region (save-excursion (goto-char (match-beginning 0))
!                                      (beginning-of-line)
                                       (point))
!                      (progn (forward-line 1) (point)))))))
  
  
! (defun how-many (regexp &optional rstart rend)
!   "Print number of matches for REGEXP following point.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
--- 636,653 ----
        (while (and (< (point) rend)
                  (re-search-forward regexp rend t))
        (delete-region (save-excursion (goto-char (match-beginning 0))
!                                      (forward-line 0)
                                       (point))
!                      (progn (forward-line 1) (point))))))
!   (set-marker rend nil)
!   nil)
  
  
! (defun how-many (regexp &optional rstart rend interactive)
!   "Print and return number of matches for REGEXP following point.
! When called from Lisp and INTERACTIVE is omitted or nil, just return
! the number, do not print it; if INTERACTIVE is t, the function behaves
! in all respects has if it had been called interactively.
  
  If REGEXP contains upper case characters (excluding those preceded by `\\'),
  the matching is case-sensitive.
***************
*** 618,635 ****
  
  Interactively, in Transient Mark mode when the mark is active, operate
  on the contents of the region.  Otherwise, operate from point to the
! end of the buffer."
  
    (interactive
     (keep-lines-read-args "How many matches for (regexp): "))
    (save-excursion
      (if rstart
!       (goto-char (min rstart rend))
!       (if (and transient-mark-mode mark-active)
          (setq rstart (region-beginning)
!               rend (copy-marker (region-end)))
        (setq rstart (point)
!             rend (point-max-marker)))
        (goto-char rstart))
      (let ((count 0)
          opoint
--- 656,679 ----
  
  Interactively, in Transient Mark mode when the mark is active, operate
  on the contents of the region.  Otherwise, operate from point to the
! end of (the accessible portion of) the buffer.
! 
! This function starts looking for the next match from the end of
! the previous match.  Hence, it ignores matches that overlap
! a previously found match."
  
    (interactive
     (keep-lines-read-args "How many matches for (regexp): "))
    (save-excursion
      (if rstart
!       (progn
!         (goto-char (min rstart rend))
!         (setq rend (max rstart rend)))
!       (if (and interactive transient-mark-mode mark-active)
          (setq rstart (region-beginning)
!               rend (region-end))
        (setq rstart (point)
!             rend (point-max)))
        (goto-char rstart))
      (let ((count 0)
          opoint
***************
*** 641,647 ****
        (if (= opoint (point))
            (forward-char 1)
          (setq count (1+ count))))
!       (message "%d occurrences" count))))
  
  
  (defvar occur-mode-map
--- 685,694 ----
        (if (= opoint (point))
            (forward-char 1)
          (setq count (1+ count))))
!       (when interactive (message "%d occurrence%s"
!                                count
!                                (if (= count 1) "" "s")))
!       count)))
  
  
  (defvar occur-mode-map
***************
*** 892,899 ****
  
  (defun occur (regexp &optional nlines)
    "Show all lines in the current buffer containing a match for REGEXP.
! 
! If a match spreads across multiple lines, all those lines are shown.
  
  Each line is displayed with NLINES lines before and after, or -NLINES
  before if NLINES is negative.
--- 939,945 ----
  
  (defun occur (regexp &optional nlines)
    "Show all lines in the current buffer containing a match for REGEXP.
! This function can not handle matches that span more than one line.
  
  Each line is displayed with NLINES lines before and after, or -NLINES
  before if NLINES is negative.
***************
*** 1603,1617 ****
                ;; Change markers to numbers in the match data
                ;; since lots of markers slow down editing.
                (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)
--- 1649,1663 ----
                ;; Change markers to numbers in the match data
                ;; since lots of markers slow down editing.
                (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)