code.delx.au - gnu-emacs/blob - lisp/diff.el

   1 ;; "DIFF" mode for handling output from unix diff utility.
   2 ;; Copyright (C) 1990 Free Software Foundation, Inc.
   3 ;; Written fpb@ittc.wec.com 1/27/89
   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 1, 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 ;; todo: diff-switches flexibility:
  22 ;; (defconst diff-switches-function
  23 ;;   '(lambda (file)
  24 ;;     (if (string-match "\\.el$" file)
  25 ;;       "-c -F\"^(\""
  26 ;;       "-p"))
  27 ;;  "Function to return switches to pass to the `diff' utility, in \\[diff].
  28 ;; This function is called with one arg, a file name, and returns a string
  29 ;; containing 0 or more arguments which are passed on to `diff'.
  30 ;; NOTE: This is not an ordinary hook; it may not be a list of functions.")
  31
  32 (defvar diff-switches nil
  33   "*A list of switches to pass to the diff program.")
  34
  35 (defvar diff-search-pattern "^\\([0-9]\\|\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\*\\)"
  36   "Regular expression that delineates difference regions in diffs.")
  37
  38 ;; Initialize the keymap if it isn't already
  39 (if (boundp 'diff-mode-map)
  40     nil
  41   (setq diff-mode-map (make-keymap))
  42   (suppress-keymap diff-mode-map)
  43   (define-key diff-mode-map "?" 'describe-mode)
  44   (define-key diff-mode-map "." 'diff-beginning-of-diff)
  45   (define-key diff-mode-map " " 'scroll-up)
  46   (define-key diff-mode-map "\177" 'scroll-down)
  47   (define-key diff-mode-map "n" 'diff-next-difference)
  48   (define-key diff-mode-map "p" 'diff-previous-difference)
  49   (define-key diff-mode-map "j" 'diff-show-difference))
  50
  51 ;;;###autoload
  52 (defun diff (old new)
  53   "Find and display the differences between OLD and NEW files.
  54 Interactively you are prompted with the current buffer's file name for NEW
  55 and what appears to be it's backup for OLD."
  56   (interactive
  57    (let (oldf newf)
  58      (reverse
  59       (list
  60        (setq newf (buffer-file-name)
  61              newf (if (and newf (file-exists-p newf))
  62                           (read-file-name
  63                            (concat "Diff new file: ("
  64                                    (file-name-nondirectory newf) ") ")
  65                            nil newf t)
  66                         (read-file-name "Diff new file: " nil nil t)))
  67        (setq oldf (file-newest-backup newf)
  68              oldf (if (and oldf (file-exists-p oldf))
  69                           (read-file-name
  70                            (concat "Diff original file: ("
  71                                    (file-name-nondirectory oldf) ") ")
  72                            (file-name-directory oldf) oldf t)
  73                         (read-file-name "Diff original file: "
  74                                         (file-name-directory newf) nil t)))))))
  75   (message "Comparing files %s %s..." new old)
  76   (setq new (expand-file-name new)
  77         old (expand-file-name old))
  78   (let ((buffer-read-only nil)
  79         (sw diff-switches))
  80     (with-output-to-temp-buffer "*Diff Output*"
  81       (buffer-disable-undo standard-output)
  82       (save-excursion
  83         (set-buffer standard-output)
  84         (erase-buffer)
  85         (apply 'call-process "diff" nil t nil
  86                (append diff-switches (list old new)))))
  87     (set-buffer "*Diff Output*")
  88     (goto-char (point-min))
  89     (while sw
  90       (if (string= (car sw) "-c")
  91           ;; strip leading filenames from context diffs
  92           (progn (forward-line 2) (delete-region (point-min) (point))))
  93       (setq sw (cdr sw))))
  94   (diff-mode)
  95   (if (string= "0" diff-total-differences)
  96       (let ((buffer-read-only nil))
  97         (insert (message "There are no differences.")))
  98     (narrow-to-region (point) (progn
  99                                 (forward-line 1)
 100                                 (if (re-search-forward diff-search-pattern
 101                                                        nil t)
 102                                     (goto-char (match-beginning 0))
 103                                   (goto-char (point-max)))))
 104     (setq diff-current-difference "1")))
 105
 106 ;; Take a buffer full of Unix diff output and go into a mode to easily
 107 ;; see the next and previous difference
 108 (defun diff-mode ()
 109   "Diff Mode is used by \\[diff] for perusing the output from the diff program.
 110 All normal editing commands are turned off.  Instead, these are available:
 111 \\<diff-mode-map>
 112 \\[diff-beginning-of-diff]      Move point to start of this difference.
 113 \\[scroll-up]   Scroll to next screen of this difference.
 114 \\[scroll-down] Scroll to previous screen of this difference.
 115 \\[diff-next-difference]        Move to Next Difference.
 116 \\[diff-previous-difference]    Move to Previous Difference.
 117 \\[diff-show-difference]        Jump to difference specified by numeric position.
 118 "
 119   (interactive)
 120   (use-local-map diff-mode-map)
 121   (setq buffer-read-only t
 122         major-mode 'diff-mode
 123         mode-name "Diff"
 124         mode-line-modified "--- "
 125         mode-line-process
 126         '(" " diff-current-difference "/" diff-total-differences))
 127   (make-local-variable 'diff-current-difference)
 128   (set (make-local-variable 'diff-total-differences)
 129        (int-to-string (diff-count-differences))))
 130
 131 (defun diff-next-difference (n)
 132   "In diff mode, go to the beginning of the next difference as delimited
 133 by `diff-search-pattern'."
 134   (interactive "p")
 135   (if (< n 0) (diff-previous-difference (- n))
 136     (if (zerop n) ()
 137       (goto-char (point-min))
 138       (forward-line 1) ; to get past the match for the start of this diff
 139       (widen)
 140       (if (re-search-forward diff-search-pattern nil 'move n)
 141           (let ((start (goto-char (match-beginning 0))))
 142             (forward-line 1)
 143             (if (re-search-forward diff-search-pattern nil 'move)
 144                 (goto-char (match-beginning 0)))
 145             (narrow-to-region start (point))
 146             (setq diff-current-difference
 147                   (int-to-string (+ n (string-to-int
 148                                        diff-current-difference)))))
 149         (re-search-backward diff-search-pattern nil)
 150         (narrow-to-region (point) (point-max))
 151         (message "No following differences.")
 152         (setq diff-current-difference diff-total-differences))
 153       (goto-char (point-min)))))
 154
 155 (defun diff-previous-difference (n)
 156   "In diff mode, go the the beginning of the previous difference as delimited
 157 by `diff-search-pattern'."
 158   (interactive "p")
 159   (if (< n 0) (diff-next-difference (- n))
 160     (if (zerop n) ()
 161       (goto-char (point-min))
 162       (widen)
 163       (if (re-search-backward diff-search-pattern nil 'move n)
 164           (setq diff-current-difference
 165                 (int-to-string (- (string-to-int diff-current-difference) n)))
 166         (message "No previous differences.")
 167         (setq diff-current-difference "1"))
 168       (narrow-to-region (point) (progn
 169                                   (forward-line 1)
 170                                   (re-search-forward diff-search-pattern nil)
 171                                   (goto-char (match-beginning 0))))
 172       (goto-char (point-min)))))
 173
 174 (defun diff-show-difference (n)
 175   "Show difference number N (prefix arg)."
 176   (interactive "p")
 177   (let ((cur (string-to-int diff-current-difference)))
 178     (cond ((or (= n cur)
 179                (zerop n)
 180                (not (natnump n))) ; should signal an error perhaps.
 181            ;; just redisplay.
 182            (goto-char (point-min)))
 183           ((< n cur)
 184            (diff-previous-difference (- cur n)))
 185           ((> n cur)
 186            (diff-next-difference (- n cur))))))
 187
 188 (defun diff-beginning-of-diff ()
 189   "Go to beginning of current difference."
 190   (interactive)
 191   (goto-char (point-min)))
 192
 193 ;; This function counts up the number of differences in the buffer.
 194 (defun diff-count-differences ()
 195   "Count number of differences in the current buffer."
 196   (message "Counting differences...")
 197   (save-excursion
 198     (save-restriction
 199       (widen)
 200       (goto-char (point-min))
 201       (let ((cnt 0))
 202         (while (re-search-forward diff-search-pattern nil t)
 203           (setq cnt (1+ cnt)))
 204         (message "Counting differences...done (%d)" cnt)
 205         cnt))))