| 1 | ;;; diff.el --- run `diff' in compilation-mode |
| 2 | |
| 3 | ;; Copyright (C) 1992, 1994, 1996, 2001 Free Software Foundation, Inc. |
| 4 | |
| 5 | ;; Maintainer: FSF |
| 6 | ;; Keywords: unix, tools |
| 7 | |
| 8 | ;; This file is part of GNU Emacs. |
| 9 | |
| 10 | ;; GNU Emacs is free software; you can redistribute it and/or modify |
| 11 | ;; it under the terms of the GNU General Public License as published by |
| 12 | ;; the Free Software Foundation; either version 2, or (at your option) |
| 13 | ;; any later version. |
| 14 | |
| 15 | ;; GNU Emacs is distributed in the hope that it will be useful, |
| 16 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | ;; GNU General Public License for more details. |
| 19 | |
| 20 | ;; You should have received a copy of the GNU General Public License |
| 21 | ;; along with GNU Emacs; see the file COPYING. If not, write to the |
| 22 | ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 23 | ;; Boston, MA 02111-1307, USA. |
| 24 | |
| 25 | ;;; Commentary: |
| 26 | |
| 27 | ;; This package helps you explore differences between files, using the |
| 28 | ;; UNIX command diff(1). The commands are `diff' and `diff-backup'. |
| 29 | ;; You can specify options with `diff-switches'. |
| 30 | |
| 31 | ;;; Code: |
| 32 | |
| 33 | (require 'compile) |
| 34 | |
| 35 | (defgroup diff nil |
| 36 | "Comparing files with `diff'." |
| 37 | :group 'tools) |
| 38 | |
| 39 | ;;;###autoload |
| 40 | (defcustom diff-switches "-c" |
| 41 | "*A string or list of strings specifying switches to be be passed to diff." |
| 42 | :type '(choice string (repeat string)) |
| 43 | :group 'diff) |
| 44 | |
| 45 | ;;;###autoload |
| 46 | (defcustom diff-command "diff" |
| 47 | "*The command to use to run diff." |
| 48 | :type 'string |
| 49 | :group 'diff) |
| 50 | |
| 51 | (defvar diff-regexp-alist |
| 52 | '( |
| 53 | ;; -u format: @@ -OLDSTART,OLDEND +NEWSTART,NEWEND @@ |
| 54 | ("^@@ -\\([0-9]+\\),[0-9]+ \\+\\([0-9]+\\),[0-9]+ @@$" 1 2) |
| 55 | |
| 56 | ;; -c format: *** OLDSTART,OLDEND **** |
| 57 | ("^\\*\\*\\* \\([0-9]+\\),[0-9]+ \\*\\*\\*\\*$" 1 nil) |
| 58 | ;; --- NEWSTART,NEWEND ---- |
| 59 | ("^--- \\([0-9]+\\),[0-9]+ ----$" nil 1) |
| 60 | |
| 61 | ;; plain diff format: OLDSTART[,OLDEND]{a,d,c}NEWSTART[,NEWEND] |
| 62 | ("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]\\([0-9]+\\)\\(,[0-9]+\\)?$" 1 3) |
| 63 | |
| 64 | ;; -e (ed) format: OLDSTART[,OLDEND]{a,d,c} |
| 65 | ("^\\([0-9]+\\)\\(,[0-9]+\\)?[adc]$" 1) |
| 66 | |
| 67 | ;; -f format: {a,d,c}OLDSTART[ OLDEND] |
| 68 | ;; -n format: {a,d,c}OLDSTART LINES-CHANGED |
| 69 | ("^[adc]\\([0-9]+\\)\\( [0-9]+\\)?$" 1) |
| 70 | ) |
| 71 | "Alist of regular expressions to match difference sections in \\[diff] output. |
| 72 | Each element has the form (REGEXP OLD-IDX NEW-IDX). |
| 73 | Any text that REGEXP matches identifies one difference hunk |
| 74 | or the header of a hunk. |
| 75 | |
| 76 | The OLD-IDX'th subexpression of REGEXP gives the line number |
| 77 | in the old file, and NEW-IDX'th subexpression gives the line number |
| 78 | in the new file. If OLD-IDX or NEW-IDX |
| 79 | is nil, REGEXP matches only half a hunk.") |
| 80 | |
| 81 | (defvar diff-old-file nil |
| 82 | "This is the old file name in the comparison in this buffer.") |
| 83 | (defvar diff-new-file nil |
| 84 | "This is the new file name in the comparison in this buffer.") |
| 85 | (defvar diff-old-temp-file nil |
| 86 | "This is the name of a temp file to be deleted after diff finishes.") |
| 87 | (defvar diff-new-temp-file nil |
| 88 | "This is the name of a temp file to be deleted after diff finishes.") |
| 89 | |
| 90 | ;; See compilation-parse-errors-function (compile.el). |
| 91 | (defun diff-parse-differences (limit-search find-at-least) |
| 92 | (setq compilation-error-list nil) |
| 93 | (message "Parsing differences...") |
| 94 | |
| 95 | ;; Don't reparse diffs already seen at last parse. |
| 96 | (if compilation-parsing-end (goto-char compilation-parsing-end)) |
| 97 | |
| 98 | ;; Construct in REGEXP a regexp composed of all those in dired-regexp-alist. |
| 99 | (let ((regexp (mapconcat (lambda (elt) |
| 100 | (concat "\\(" (car elt) "\\)")) |
| 101 | diff-regexp-alist |
| 102 | "\\|")) |
| 103 | ;; (GROUP-IDX OLD-IDX NEW-IDX) |
| 104 | (groups (let ((subexpr 1)) |
| 105 | (mapcar (lambda (elt) |
| 106 | (prog1 |
| 107 | (cons subexpr |
| 108 | (mapcar (lambda (n) |
| 109 | (and n |
| 110 | (+ subexpr n))) |
| 111 | (cdr elt))) |
| 112 | (setq subexpr (+ subexpr 1 |
| 113 | (count-regexp-groupings |
| 114 | (car elt)))))) |
| 115 | diff-regexp-alist))) |
| 116 | |
| 117 | (new-error |
| 118 | (function (lambda (file subexpr) |
| 119 | (setq compilation-error-list |
| 120 | (cons |
| 121 | (cons (save-excursion |
| 122 | ;; Report location of message |
| 123 | ;; at beginning of line. |
| 124 | (goto-char |
| 125 | (match-beginning subexpr)) |
| 126 | (beginning-of-line) |
| 127 | (point-marker)) |
| 128 | ;; Report location of corresponding text. |
| 129 | (let ((line (string-to-int |
| 130 | (buffer-substring |
| 131 | (match-beginning subexpr) |
| 132 | (match-end subexpr))))) |
| 133 | (save-excursion |
| 134 | (save-match-data |
| 135 | (set-buffer (find-file-noselect file))) |
| 136 | (save-excursion |
| 137 | (goto-line line) |
| 138 | (point-marker))))) |
| 139 | compilation-error-list))))) |
| 140 | |
| 141 | (found-desired nil) |
| 142 | (num-loci-found 0) |
| 143 | g) |
| 144 | |
| 145 | (while (and (not found-desired) |
| 146 | ;; We don't just pass LIMIT-SEARCH to re-search-forward |
| 147 | ;; because we want to find matches containing LIMIT-SEARCH |
| 148 | ;; but which extend past it. |
| 149 | (re-search-forward regexp nil t)) |
| 150 | |
| 151 | ;; Find which individual regexp matched. |
| 152 | (setq g groups) |
| 153 | (while (and g (null (match-beginning (car (car g))))) |
| 154 | (setq g (cdr g))) |
| 155 | (setq g (car g)) |
| 156 | |
| 157 | (if (nth 1 g) ;OLD-IDX |
| 158 | (funcall new-error diff-old-file (nth 1 g))) |
| 159 | (if (nth 2 g) ;NEW-IDX |
| 160 | (funcall new-error diff-new-file (nth 2 g))) |
| 161 | |
| 162 | (setq num-loci-found (1+ num-loci-found)) |
| 163 | (if (or (and find-at-least |
| 164 | (>= num-loci-found find-at-least)) |
| 165 | (and limit-search (>= (point) limit-search))) |
| 166 | ;; We have found as many new loci as the user wants, |
| 167 | ;; or the user wanted a specific diff, and we're past it. |
| 168 | (setq found-desired t))) |
| 169 | (set-marker compilation-parsing-end |
| 170 | (if found-desired (point) |
| 171 | ;; Set to point-max, not point, so we don't perpetually |
| 172 | ;; parse the last bit of text when it isn't a diff header. |
| 173 | (point-max))) |
| 174 | (message "Parsing differences...done")) |
| 175 | (setq compilation-error-list (nreverse compilation-error-list))) |
| 176 | |
| 177 | (defun diff-process-setup () |
| 178 | "Set up \`compilation-exit-message-function' for \`diff'." |
| 179 | ;; Avoid frightening people with "abnormally terminated" |
| 180 | ;; if diff finds differences. |
| 181 | (set (make-local-variable 'compilation-exit-message-function) |
| 182 | (lambda (status code msg) |
| 183 | (cond ((not (eq status 'exit)) |
| 184 | (cons msg code)) |
| 185 | ((zerop code) |
| 186 | '("finished (no differences)\n" . "no differences")) |
| 187 | ((= code 1) |
| 188 | '("finished\n" . "differences found")) |
| 189 | (t |
| 190 | (cons msg code)))))) |
| 191 | |
| 192 | ;;;###autoload |
| 193 | (defun diff (old new &optional switches no-async) |
| 194 | "Find and display the differences between OLD and NEW files. |
| 195 | Interactively the current buffer's file name is the default for NEW |
| 196 | and a backup file for NEW is the default for OLD. |
| 197 | With prefix arg, prompt for diff switches. |
| 198 | If NO-ASYNC is non-nil, call diff synchronously." |
| 199 | (interactive |
| 200 | (nconc |
| 201 | (let (oldf newf) |
| 202 | (nreverse |
| 203 | (list |
| 204 | (setq newf (buffer-file-name) |
| 205 | newf (if (and newf (file-exists-p newf)) |
| 206 | (read-file-name |
| 207 | (concat "Diff new file: (default " |
| 208 | (file-name-nondirectory newf) ") ") |
| 209 | nil newf t) |
| 210 | (read-file-name "Diff new file: " nil nil t))) |
| 211 | (setq oldf (file-newest-backup newf) |
| 212 | oldf (if (and oldf (file-exists-p oldf)) |
| 213 | (read-file-name |
| 214 | (concat "Diff original file: (default " |
| 215 | (file-name-nondirectory oldf) ") ") |
| 216 | (file-name-directory oldf) oldf t) |
| 217 | (read-file-name "Diff original file: " |
| 218 | (file-name-directory newf) nil t)))))) |
| 219 | (if current-prefix-arg |
| 220 | (list (read-string "Diff switches: " |
| 221 | (if (stringp diff-switches) |
| 222 | diff-switches |
| 223 | (mapconcat 'identity diff-switches " ")))) |
| 224 | nil))) |
| 225 | (setq new (expand-file-name new) |
| 226 | old (expand-file-name old)) |
| 227 | (let ((old-alt (file-local-copy old)) |
| 228 | (new-alt (file-local-copy new)) |
| 229 | buf) |
| 230 | (save-excursion |
| 231 | (let ((compilation-process-setup-function 'diff-process-setup) |
| 232 | (command |
| 233 | (mapconcat 'identity |
| 234 | (append (list diff-command) |
| 235 | ;; Use explicitly specified switches |
| 236 | (if switches |
| 237 | (if (consp switches) |
| 238 | switches (list switches)) |
| 239 | ;; If not specified, use default. |
| 240 | (if (consp diff-switches) |
| 241 | diff-switches |
| 242 | (list diff-switches))) |
| 243 | (if (or old-alt new-alt) |
| 244 | (list "-L" old "-L" new)) |
| 245 | (list |
| 246 | (shell-quote-argument (or old-alt old))) |
| 247 | (list |
| 248 | (shell-quote-argument (or new-alt new)))) |
| 249 | " "))) |
| 250 | (setq buf |
| 251 | (compile-internal command |
| 252 | "No more differences" "Diff" |
| 253 | 'diff-parse-differences |
| 254 | nil nil nil nil nil nil no-async)) |
| 255 | (set-buffer buf) |
| 256 | (set (make-local-variable 'diff-old-file) old) |
| 257 | (set (make-local-variable 'diff-new-file) new) |
| 258 | (set (make-local-variable 'diff-old-temp-file) old-alt) |
| 259 | (set (make-local-variable 'diff-new-temp-file) new-alt) |
| 260 | (set (make-local-variable 'compilation-finish-function) |
| 261 | (function (lambda (buff msg) |
| 262 | (if diff-old-temp-file |
| 263 | (delete-file diff-old-temp-file)) |
| 264 | (if diff-new-temp-file |
| 265 | (delete-file diff-new-temp-file))))) |
| 266 | ;; When async processes aren't available, the compilation finish |
| 267 | ;; function doesn't get chance to run. Invoke it by hand. |
| 268 | (or (fboundp 'start-process) |
| 269 | (funcall compilation-finish-function nil nil)) |
| 270 | buf)))) |
| 271 | |
| 272 | ;;;###autoload |
| 273 | (defun diff-backup (file &optional switches) |
| 274 | "Diff this file with its backup file or vice versa. |
| 275 | Uses the latest backup, if there are several numerical backups. |
| 276 | If this file is a backup, diff it with its original. |
| 277 | The backup file is the first file given to `diff'." |
| 278 | (interactive (list (read-file-name "Diff (file with backup): ") |
| 279 | (if current-prefix-arg |
| 280 | (read-string "Diff switches: " |
| 281 | (if (stringp diff-switches) |
| 282 | diff-switches |
| 283 | (mapconcat 'identity |
| 284 | diff-switches " "))) |
| 285 | nil))) |
| 286 | (let (bak ori) |
| 287 | (if (backup-file-name-p file) |
| 288 | (setq bak file |
| 289 | ori (file-name-sans-versions file)) |
| 290 | (setq bak (or (diff-latest-backup-file file) |
| 291 | (error "No backup found for %s" file)) |
| 292 | ori file)) |
| 293 | (diff bak ori switches))) |
| 294 | |
| 295 | (defun diff-latest-backup-file (fn) ; actually belongs into files.el |
| 296 | "Return the latest existing backup of FILE, or nil." |
| 297 | (let ((handler (find-file-name-handler fn 'diff-latest-backup-file))) |
| 298 | (if handler |
| 299 | (funcall handler 'diff-latest-backup-file fn) |
| 300 | (file-newest-backup fn)))) |
| 301 | |
| 302 | (provide 'diff) |
| 303 | |
| 304 | ;;; diff.el ends here |