-;;; diff-mode.el --- A mode for viewing/editing context diffs
+;;; diff-mode.el --- a mode for viewing/editing context diffs
-;; Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
;; Author: Stefan Monnier <monnier@cs.yale.edu>
-;; Keywords: patch diff
-;; Revision: $Id: diff-mode.el,v 1.35 2000/11/14 18:09:21 fx Exp $
+;; Keywords: convenience patch diff
;; This file is part of GNU Emacs.
;; commands, editing and various conversions as well as jumping
;; to the corresponding source file.
-;;
inspired by Pavel Machek's patch-mode.el (<pavel@atrey.karlin.mff.cuni.cz>)
-;; some efforts were spent to have it somewhat compatible with XEmacs'
+;;
Inspired by Pavel Machek's patch-mode.el (<pavel@atrey.karlin.mff.cuni.cz>)
+;; Some efforts were spent to have it somewhat compatible with XEmacs'
;; diff-mode as well as with compilation-minor-mode
-;; to use it, simply add to your .emacs the following lines:
-;;
-;; (autoload 'diff-mode "diff-mode" "Diff major mode" t)
-;; (add-to-list 'auto-mode-alist '("\\.\\(diffs?\\|patch\\|rej\\)\\'" . diff-mode))
-
;; Bugs:
;; - Reverse doesn't work with normal diffs.
;; - re-enable (conditionally) the `compile' support after improving it to use
;; the same code as diff-goto-source.
;; - Support for # comments in context->unified.
-;; - Do a fuzzy search in diff-goto-source.
;; - Allow diff.el to use diff-mode.
;; This mostly means ability to jump from half-hunk to half-hunk
;; in context (and normal) diffs and to jump to the corresponding
:group 'tools
:group 'diff)
-(defcustom diff-jump-to-old-file-flag nil
+(defcustom diff-default-read-only t
+ "If non-nil, `diff-mode' buffers default to being read-only."
+ :type 'boolean
+ :group 'diff-mode)
+
+(defcustom diff-jump-to-old-file nil
"*Non-nil means `diff-goto-source' jumps to the old file.
Else, it jumps to the new file."
- :group 'diff-mode
:type '(boolean))
-(defcustom diff-update-on-the-fly-flag t
+(defcustom diff-update-on-the-fly t
"*Non-nil means hunk headers are kept up-to-date on-the-fly.
When editing a diff file, the line numbers in the hunk headers
need to be kept consistent with the actual diff. This can
either be done on the fly (but this sometimes interacts poorly with the
undo mechanism) or whenever the file is written (can be slow
when editing big diffs)."
- :group 'diff-mode
:type '(boolean))
(defcustom diff-advance-after-apply-hunk t
"*Non-nil means `diff-apply-hunk' will move to the next hunk after applying."
- :group 'diff-mode
:type 'boolean)
(defcustom diff-minor-mode-prefix "\C-c="
"Prefix key for `diff-minor-mode' commands."
- :group 'diff-mode
:type '(choice (string "\e") (string "C-c=") string))
(easy-mmode-defmap diff-minor-mode-map
(defface diff-header-face
'((((type tty pc) (class color) (background light))
- (:foreground "blue1" :bold t))
+ (:foreground "blue1" :weight bold))
(((type tty pc) (class color) (background dark))
- (:foreground "green" :bold t))
+ (:foreground "green" :weight bold))
(((class color) (background light))
(:background "grey85"))
(((class color) (background dark))
(:background "grey45"))
- (t (:bold t)))
- "`diff-mode' face inherited by hunk and index header faces."
- :group 'diff-mode)
+ (t (:weight bold)))
+ "`diff-mode' face inherited by hunk and index header faces.")
(defvar diff-header-face 'diff-header-face)
(defface diff-file-header-face
'((((type tty pc) (class color) (background light))
- (:foreground "yellow" :bold t))
+ (:foreground "yellow" :weight bold))
(((type tty pc) (class color) (background dark))
- (:foreground "cyan" :bold t))
+ (:foreground "cyan" :weight bold))
(((class color) (background light))
- (:background "grey70" :bold t))
+ (:background "grey70" :weight bold))
(((class color) (background dark))
- (:background "grey60" :bold t))
- (t (:bold t))) ; :height 1.3
- "`diff-mode' face used to highlight file header lines."
- :group 'diff-mode)
+ (:background "grey60" :weight bold))
+ (t (:weight bold))) ; :height 1.3
+ "`diff-mode' face used to highlight file header lines.")
(defvar diff-file-header-face 'diff-file-header-face)
(defface diff-index-face
'((t (:inherit diff-file-header-face)))
- "`diff-mode' face used to highlight index header lines."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight index header lines.")
(defvar diff-index-face 'diff-index-face)
(defface diff-hunk-header-face
'((t (:inherit diff-header-face)))
- "`diff-mode' face used to highlight hunk header lines."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight hunk header lines.")
(defvar diff-hunk-header-face 'diff-hunk-header-face)
(defface diff-removed-face
'((t (:inherit diff-changed-face)))
- "`diff-mode' face used to highlight removed lines."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight removed lines.")
(defvar diff-removed-face 'diff-removed-face)
(defface diff-added-face
'((t (:inherit diff-changed-face)))
- "`diff-mode' face used to highlight added lines."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight added lines.")
(defvar diff-added-face 'diff-added-face)
(defface diff-changed-face
'((((type tty pc) (class color) (background light))
- (:foreground "magenta" :bold t :italic t))
+ (:foreground "magenta" :weight bold :slant italic))
(((type tty pc) (class color) (background dark))
- (:foreground "yellow" :bold t :italic t))
+ (:foreground "yellow" :weight bold :slant italic))
(t ()))
- "`diff-mode' face used to highlight changed lines."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight changed lines.")
(defvar diff-changed-face 'diff-changed-face)
(defface diff-function-face
'((t (:inherit diff-context-face)))
- "`diff-mode' face used to highlight function names produced by \"diff -p\"."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight function names produced by \"diff -p\".")
(defvar diff-function-face 'diff-function-face)
(defface diff-context-face
(((class color) (background dark))
(:foreground "grey70"))
(t ))
- "`diff-mode' face used to highlight context and other side-information."
- :group 'diff-mode)
+ "`diff-mode' face used to highlight context and other side-information.")
(defvar diff-context-face 'diff-context-face)
+(defface diff-nonexistent-face
+ '((t (:inherit diff-file-header-face)))
+ "`diff-mode' face used to highlight nonexistent files in recursive diffs.")
+(defvar diff-nonexistent-face 'diff-nonexistent-face)
+
(defvar diff-font-lock-keywords
'(("^\\(@@ -[0-9,]+ \\+[0-9,]+ @@\\)\\(.*\\)$" ;unified
(1 diff-hunk-header-face)
(2 diff-function-face))
- ("^--- .+ ----$" ;context
- . diff-hunk-header-face)
- ("\\(\\*\\{15\\}\\)\\(.*\\)$" ;context
+ ("^--- .+ ----$" . diff-hunk-header-face) ;context
+ ("^\\(\\*\\{15\\}\\)\\(.*\\)$" ;context
(1 diff-hunk-header-face)
(2 diff-function-face))
("^\\*\\*\\* .+ \\*\\*\\*\\*". diff-hunk-header-face) ;context
("^[+>].*\n" . diff-added-face)
("^[-<].*\n" . diff-removed-face)
("^Index: \\(.+\\).*\n" (0 diff-header-face) (1 diff-index-face prepend))
+ ("^Only in .*\n" . diff-nonexistent-face)
("^#.*" . font-lock-string-face)
("^[^-=+*!<>].*\n" . diff-context-face)))
(defun diff-end-of-hunk (&optional style)
(if (looking-at diff-hunk-header-re) (goto-char (match-end 0)))
(let ((end (and (re-search-forward (case style
- (unified "^[^-+# \\]")
+ ;; A `unified' header is ambiguous.
+ (unified (concat "^[^-+# \\]\\|"
+ diff-file-header-re))
(context "^[^-+#! \\]")
(normal "^[^<>#\\]")
(t "^[^-+#!<> \\]"))
"Kill current hunk."
(interactive)
(diff-beginning-of-hunk)
- (let ((start (point))
- (firsthunk (save-excursion
- (ignore-errors
- (diff-beginning-of-file) (diff-hunk-next) (point))))
- (nexthunk (save-excursion
- (ignore-errors
- (diff-hunk-next) (point))))
- (nextfile (save-excursion
- (ignore-errors
- (diff-file-next) (point)))))
+ (let* ((start (point))
+ (nexthunk (ignore-errors (diff-hunk-next) (point)))
+ (firsthunk (ignore-errors
+ (goto-char start)
+ (diff-beginning-of-file) (diff-hunk-next) (point)))
+ (nextfile (ignore-errors (diff-file-next) (point))))
+ (goto-char start)
(if (and firsthunk (= firsthunk start)
(or (null nexthunk)
(and nextfile (> nexthunk nextfile))))
- ;; we're the only hunk for this file, so kill the file
+ ;; It's the only hunk for this file, so kill the file.
(diff-file-kill)
(diff-end-of-hunk)
(kill-region start (point)))))
(ignore-errors
(save-excursion
(goto-char (car diff-unhandled-changes))
- (unless (ignore-errors
- (diff-beginning-of-hunk)
- (save-excursion
- (diff-end-of-hunk)
- (> (point) (car diff-unhandled-changes))))
- (goto-char (car diff-unhandled-changes))
- (re-search-forward diff-hunk-header-re (cdr diff-unhandled-changes))
- (diff-beginning-of-hunk))
- (diff-fixup-modifs (point) (cdr diff-unhandled-changes))))
+ ;; We used to fixup modifs on all the changes, but it turns out
+ ;; that it's safer not to do it on big changes, for example
+ ;; when yanking a big diff, since we might then screw up perfectly
+ ;; correct values. -stef
+ ;; (unless (ignore-errors
+ ;; (diff-beginning-of-hunk)
+ ;; (save-excursion
+ ;; (diff-end-of-hunk)
+ ;; (> (point) (car diff-unhandled-changes))))
+ ;; (goto-char (car diff-unhandled-changes))
+ ;; (re-search-forward diff-hunk-header-re (cdr diff-unhandled-changes))
+ ;; (diff-beginning-of-hunk))
+ ;; (diff-fixup-modifs (point) (cdr diff-unhandled-changes))
+ (diff-beginning-of-hunk)
+ (when (save-excursion
+ (diff-end-of-hunk)
+ (> (point) (cdr diff-unhandled-changes)))
+ (diff-fixup-modifs (point) (cdr diff-unhandled-changes)))))
(setq diff-unhandled-changes nil)))
;;;;
;;;###autoload
(define-derived-mode diff-mode fundamental-mode "Diff"
"Major mode for viewing/editing context diffs.
-Supports unified and context diffs as well as (to a lesser extent) normal diffs.
-When the buffer is read-only, the ESC prefix is not necessary.
-This mode runs `diff-mode-hook'.
-\\{diff-mode-map}"
+Supports unified and context diffs as well as (to a lesser extent)
+normal diffs.
+When the buffer is read-only, the ESC prefix is not necessary."
(set (make-local-variable 'font-lock-defaults) diff-font-lock-defaults)
(set (make-local-variable 'outline-regexp) diff-outline-regexp)
(set (make-local-variable 'imenu-generic-expression)
;; (substring buffer-file-name 0 (match-beginning 0))))
;; (compilation-shell-minor-mode 1)
+ (when (and (> (point-max) (point-min)) diff-default-read-only)
+ (toggle-read-only t))
;; setup change hooks
- (toggle-read-only t)
- (if (not diff-update-on-the-fly-flag)
+ (if (not diff-update-on-the-fly)
(add-hook 'write-contents-hooks 'diff-write-contents-hooks)
(make-local-variable 'diff-unhandled-changes)
(add-hook 'after-change-functions 'diff-after-change-function nil t)
nil " Diff" nil
;; FIXME: setup font-lock
;; setup change hooks
- (if (not diff-update-on-the-fly-flag)
+ (if (not diff-update-on-the-fly)
(add-hook 'write-contents-hooks 'diff-write-contents-hooks)
(make-local-variable 'diff-unhandled-changes)
(add-hook 'after-change-functions 'diff-after-change-function nil t)
nil t)
(equal (match-string 1) (match-string 2)))))
-(defun diff-hunk-text (hunk destp &optional char-offset)
- "Return the literal source text from HUNK.
-if DESTP is nil return the source, otherwise the destination text.
-If CHAR-OFFSET is non-nil, it should be a char-offset in
-HUNK, and instead of a string, a cons cell is returned whose car is the
-appropriate text, and whose cdr is the corresponding char-offset in that text."
+(defun diff-hunk-text (hunk destp char-offset)
+ "Return the literal source text from HUNK as (TEXT . OFFSET).
+if DESTP is nil TEXT is the source, otherwise the destination text.
+CHAR-OFFSET is a char-offset in HUNK, and OFFSET is the corresponding
+char-offset in TEXT."
(with-temp-buffer
(insert hunk)
(goto-char (point-min))
(defun diff-find-text (text)
- "Return the buffer position of the nearest occurrence of TEXT.
+ "Return the buffer position (BEG . END) of the nearest occurrence of TEXT.
If TEXT isn't found, nil is returned."
(let* ((orig (point))
(forw (and (search-forward text nil t)
- (match-beginning 0)))
+ (cons (match-beginning 0) (match-end 0))))
(back (and (goto-char (+ orig (length text)))
(search-backward text nil t)
- (match-beginning 0))))
- ;; Choose the closest match.
+ (cons (match-beginning 0) (match-end 0)))))
+ ;; Choose the closest match.
+ (if (and forw back)
+ (if (> (- (car forw) orig) (- orig (car back))) back forw)
+ (or back forw))))
+
+(defun diff-find-approx-text (text)
+ "Return the buffer position (BEG . END) of the nearest occurrence of TEXT.
+Whitespace differences are ignored."
+ (let* ((orig (point))
+ (re (concat "^[ \t\n\f]*"
+ (mapconcat 'regexp-quote (split-string text) "[ \t\n\f]+")
+ "[ \t\n\f]*\n"))
+ (forw (and (re-search-forward re nil t)
+ (cons (match-beginning 0) (match-end 0))))
+ (back (and (goto-char (+ orig (length text)))
+ (re-search-backward re nil t)
+ (cons (match-beginning 0) (match-end 0)))))
+ ;; Choose the closest match.
(if (and forw back)
- (if (> (- forw orig) (- orig back)) back forw)
+ (if (> (- (car forw) orig) (- orig (car back))) back forw)
(or back forw))))
(defsubst diff-xor (a b) (if a (not b) b))
(defun diff-find-source-location (&optional other-file reverse)
- "Find out (BUF LINE-OFFSET POS SRC DST SWITCHED)."
+ "Find out (BUF LINE-OFFSET POS SRC DST SWITCHED).
+BUF is the buffer corresponding to the source file.
+LINE-OFFSET is the offset between the expected and actual positions
+ of the text of the hunk or nil if the text was not found.
+POS is a pair (BEG . END) indicating the position of the text in the buffer.
+SRC and DST are the two variants of text as returned by `diff-hunk-text'.
+ SRC is the variant that was found in the buffer.
+SWITCHED is non-nil if the patch is already applied."
(save-excursion
- (let* ((other (diff-xor other-file diff-jump-to-old-file-flag))
+ (let* ((other (diff-xor other-file diff-jump-to-old-file))
(char-offset (- (point) (progn (diff-beginning-of-hunk) (point))))
(hunk (buffer-substring (point)
(save-excursion (diff-end-of-hunk) (point))))
(buf (find-file-noselect file)))
;; Update the user preference if he so wished.
(when (> (prefix-numeric-value other-file) 8)
- (setq diff-jump-to-old-file-flag other))
+ (setq diff-jump-to-old-file other))
(with-current-buffer buf
(goto-line (string-to-number line))
(let* ((orig-pos (point))
- (pos (diff-find-text (car old)))
- (switched nil))
- (when (null pos)
- (setq pos (diff-find-text (car new)) switched t))
+ (switched nil)
+ (pos (or (diff-find-text (car old))
+ (progn (setq switched t) (diff-find-text (car new)))
+ (progn (setq switched nil)
+ (diff-find-approx-text (car old)))
+ (progn (setq switched t)
+ (diff-find-approx-text (car new)))
+ (progn (setq switched nil) nil))))
(nconc
(list buf)
- (if pos (list (count-lines orig-pos pos) pos) (list nil orig-pos))
+ (if pos
+ (list (count-lines orig-pos (car pos)) pos)
+ (list nil (cons orig-pos (+ orig-pos (length (car old))))))
(if switched (list new old t) (list old new))))))))
(defun diff-apply-hunk (&optional reverse)
"Apply the current hunk to the source file and go to the next.
By default, the new source file is patched, but if the variable
-`diff-jump-to-old-file-flag' is non-nil, then the old source file is
+`diff-jump-to-old-file' is non-nil, then the old source file is
patched instead (some commands, such as `diff-goto-source' can change
the value of this variable when given an appropriate prefix argument).
;; A reversed patch was detected, perhaps apply it in reverse.
(not (save-window-excursion
(pop-to-buffer buf)
- (goto-char (+ pos (cdr old)))
+ (goto-char (+ (car pos) (cdr old)))
(y-or-n-p
(if reverse
"Hunk hasn't been applied yet; apply it now? "
(t
;; Apply the hunk
(with-current-buffer buf
- (goto-char pos)
- (delete-char (length (car old)))
+ (goto-char (car pos))
+ (delete-region (car pos) (cdr pos))
(insert (car new)))
;; Display BUF in a window
- (set-window-point (display-buffer buf) (+ pos (cdr new)))
+ (set-window-point (display-buffer buf) (+ (car pos) (cdr new)))
(diff-hunk-status-msg line-offset (diff-xor switched reverse) nil)
(when diff-advance-after-apply-hunk
(diff-hunk-next))))))
(interactive "P")
(destructuring-bind (buf line-offset pos src dst &optional switched)
(diff-find-source-location nil reverse)
- (set-window-point (display-buffer buf) (+ pos (cdr src)))
+ (set-window-point (display-buffer buf) (+ (car pos) (cdr src)))
(diff-hunk-status-msg line-offset (diff-xor reverse switched) t)))
(defun diff-goto-source (&optional other-file)
"Jump to the corresponding source line.
-`diff-jump-to-old-file-flag' (or its opposite if the OTHER-FILE prefix arg
+`diff-jump-to-old-file' (or its opposite if the OTHER-FILE prefix arg
is given) determines whether to jump to the old or the new file.
If the prefix arg is bigger than 8 (for example with \\[universal-argument] \\[universal-argument])
- then `diff-jump-to-old-file-flag' is also set, for the next invocations."
+ then `diff-jump-to-old-file' is also set, for the next invocations."
(interactive "P")
;; When pointing at a removal line, we probably want to jump to
;; the old location, and else to the new (i.e. as if reverting).
(destructuring-bind (buf line-offset pos src dst &optional switched)
(diff-find-source-location other-file rev)
(pop-to-buffer buf)
- (goto-char (+ pos (cdr src)))
+ (goto-char (+ (car pos) (cdr src)))
(diff-hunk-status-msg line-offset (diff-xor rev switched) t))))
(funcall (with-current-buffer buf major-mode))
(add-log-current-defun))))
(with-current-buffer buf
- (goto-char (+ pos (cdr src)))
+ (goto-char (+ (car pos) (cdr src)))
(add-log-current-defun))))))
;; provide the package
HCoop / bpt / emacs.git / blobdiff