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

[Stefan Monnier]

Index: emacs/lisp/smerge-mode.el
diff -c emacs/lisp/smerge-mode.el:1.40 emacs/lisp/smerge-mode.el:1.41
*** emacs/lisp/smerge-mode.el:1.40      Sat Aug  6 22:13:43 2005
--- emacs/lisp/smerge-mode.el   Mon Aug 22 14:38:51 2005
***************
*** 53,59 ****
  (defvar smerge-mode)
  
  (defgroup smerge ()
!   "Minor mode to resolve diff3 conflicts."
    :group 'tools
    :prefix "smerge-")
  
--- 53,59 ----
  (defvar smerge-mode)
  
  (defgroup smerge ()
!   "Minor mode to highlight and resolve diff3 conflicts."
    :group 'tools
    :prefix "smerge-")
  
***************
*** 69,81 ****
  (defcustom smerge-diff-switches
    (append '("-d" "-b")
          (if (listp diff-switches) diff-switches (list diff-switches)))
!   "*A list of strings specifying switches to be passed to diff.
  Used in `smerge-diff-base-mine' and related functions."
    :group 'smerge
    :type '(repeat string))
  
  (defcustom smerge-auto-leave t
!   "*Non-nil means to leave `smerge-mode' when the last conflict is resolved."
    :group 'smerge
    :type 'boolean)
  
--- 69,81 ----
  (defcustom smerge-diff-switches
    (append '("-d" "-b")
          (if (listp diff-switches) diff-switches (list diff-switches)))
!   "A list of strings specifying switches to be passed to diff.
  Used in `smerge-diff-base-mine' and related functions."
    :group 'smerge
    :type '(repeat string))
  
  (defcustom smerge-auto-leave t
!   "Non-nil means to leave `smerge-mode' when the last conflict is resolved."
    :group 'smerge
    :type 'boolean)
  
***************
*** 138,143 ****
--- 138,144 ----
      ("o" . smerge-keep-other)
      ("m" . smerge-keep-mine)
      ("E" . smerge-ediff)
+     ("C" . smerge-combine-with-next)
      ("\C-m" . smerge-keep-current)
      ("=" . ,(make-sparse-keymap "Diff"))
      ("=<" "base-mine" . smerge-diff-base-mine)
***************
*** 257,262 ****
--- 258,265 ----
    (when (and smerge-auto-leave
             (save-excursion (goto-char (point-min))
                             (not (re-search-forward smerge-begin-re nil t))))
+     (when (and (listp buffer-undo-list) smerge-mode)
+       (push (list 'apply 'smerge-mode 1) buffer-undo-list))
      (smerge-mode -1)))
  
  
***************
*** 316,321 ****
--- 319,325 ----
    "Mode-specific merge function.
  The function is called with no argument and with the match data set
  according to `smerge-match-conflict'.")
+ (add-to-list 'debug-ignored-errors "Don't know how to resolve")
  
  (defvar smerge-text-properties
    `(help-echo "merge conflict: mouse-3 shows a menu"
***************
*** 323,332 ****
      keymap (keymap (down-mouse-3 . smerge-popup-context-menu))))
  
  (defun smerge-remove-props (&optional beg end)
!   (remove-text-properties
!    (or beg (match-beginning 0))
!    (or end (match-end 0))
!    smerge-text-properties))
  
  (defun smerge-popup-context-menu (event)
    "Pop up the Smerge mode context menu under mouse."
--- 327,333 ----
      keymap (keymap (down-mouse-3 . smerge-popup-context-menu))))
  
  (defun smerge-remove-props (&optional beg end)
!   (remove-overlays beg end 'smerge 'conflict))
  
  (defun smerge-popup-context-menu (event)
    "Pop up the Smerge mode context menu under mouse."
***************
*** 368,375 ****
     ;; Trivial diff3 -A non-conflicts.
     ((and (eq (match-end 1) (match-end 3))
         (eq (match-beginning 1) (match-beginning 3)))
-     ;; FIXME: Add "if [ diff -b MINE OTHER ]; then select OTHER; fi"
      (smerge-keep-n 3))
     ((and (match-end 2)
         ;; FIXME: Add "diff -b BASE MINE | patch OTHER".
         ;; FIXME: Add "diff -b BASE OTHER | patch MINE".
--- 369,384 ----
     ;; Trivial diff3 -A non-conflicts.
     ((and (eq (match-end 1) (match-end 3))
         (eq (match-beginning 1) (match-beginning 3)))
      (smerge-keep-n 3))
+    ;; Mode-specific conflict resolution.
+    ((condition-case nil
+         (atomic-change-group
+          (funcall smerge-resolve-function)
+          t)
+       (error nil))
+     ;; Nothing to do: the resolution function has done it already.
+     nil)
+    ;; FIXME: Add "if [ diff -b MINE OTHER ]; then select OTHER; fi"
     ((and (match-end 2)
         ;; FIXME: Add "diff -b BASE MINE | patch OTHER".
         ;; FIXME: Add "diff -b BASE OTHER | patch MINE".
***************
*** 380,387 ****
         nil)
      )
     (t
!     ;; Mode-specific conflict resolution.
!     (funcall smerge-resolve-function)))
    (smerge-auto-leave))
  
  (defun smerge-keep-base ()
--- 389,395 ----
         nil)
      )
     (t
!     (error "Don't know how to resolve")))
    (smerge-auto-leave))
  
  (defun smerge-keep-base ()
***************
*** 500,505 ****
--- 508,517 ----
              (re-search-forward smerge-begin-re end t))
            ;; There's a nested conflict and we're after the the beginning
            ;; of the outer one but before the beginning of the inner one.
+           ;; Of course, maybe this is not a nested conflict but in that
+           ;; case it can only be something nastier that we don't know how
+           ;; to handle, so may as well arbitrarily decide to treat it as
+           ;; a nested conflict.  --Stef
            (error "There is a nested conflict"))
  
           ((re-search-backward smerge-base-re start t)
***************
*** 524,536 ****
            (setq mine-start other-start)
            (setq mine-end   other-end)))
  
-         (let ((inhibit-read-only t)
-               (inhibit-modification-hooks t)
-               (m (buffer-modified-p)))
-           (unwind-protect
-               (add-text-properties start end smerge-text-properties)
-             (restore-buffer-modified-p m)))
- 
          (store-match-data (list start end
                                  mine-start mine-end
                                  base-start base-end
--- 536,541 ----
***************
*** 540,556 ****
          t)
        (search-failed (error "Point not in conflict region")))))
  
  (defun smerge-find-conflict (&optional limit)
    "Find and match a conflict region.  Intended as a font-lock MATCHER.
  The submatches are the same as in `smerge-match-conflict'.
! Returns non-nil if a match is found between the point and LIMIT.
! The point is moved to the end of the conflict."
!   (when (re-search-forward smerge-begin-re limit t)
!     (condition-case err
!       (progn
!         (smerge-match-conflict)
!         (goto-char (match-end 0)))
!       (error (smerge-find-conflict limit)))))
  
  (defun smerge-diff (n1 n2)
    (smerge-match-conflict)
--- 545,604 ----
          t)
        (search-failed (error "Point not in conflict region")))))
  
+ (defun smerge-conflict-overlay (pos)
+   "Return the conflict overlay at POS if any."
+   (let ((ols (overlays-at pos))
+         conflict)
+     (dolist (ol ols)
+       (if (and (eq (overlay-get ol 'smerge) 'conflict)
+                (> (overlay-end ol) pos))
+           (setq conflict ol)))
+     conflict))
+ 
  (defun smerge-find-conflict (&optional limit)
    "Find and match a conflict region.  Intended as a font-lock MATCHER.
  The submatches are the same as in `smerge-match-conflict'.
! Returns non-nil if a match is found between point and LIMIT.
! Point is moved to the end of the conflict."
!   (let ((found nil)
!         (pos (point))
!         conflict)
!     ;; First check to see if point is already inside a conflict, using
!     ;; the conflict overlays.
!     (while (and (not found) (setq conflict (smerge-conflict-overlay pos)))
!       ;; Check the overlay's validity and kill it if it's out of date.
!       (condition-case nil
!           (progn
!             (goto-char (overlay-start conflict))
!             (smerge-match-conflict)
!             (goto-char (match-end 0))
!             (if (<= (point) pos)
!                 (error "Matching backward!")
!               (setq found t)))
!         (error (smerge-remove-props
!                 (overlay-start conflict) (overlay-end conflict))
!                (goto-char pos))))
!     ;; If we're not already inside a conflict, look for the next conflict
!     ;; and add/update its overlay.
!     (while (and (not found) (re-search-forward smerge-begin-re limit t))
!       (condition-case nil
!           (progn
!             (smerge-match-conflict)
!             (goto-char (match-end 0))
!             (let ((conflict (smerge-conflict-overlay (1- (point)))))
!               (if conflict
!                   ;; Update its location, just in case it got messed up.
!                   (move-overlay conflict (match-beginning 0) (match-end 0))
!                 (setq conflict (make-overlay (match-beginning 0) (match-end 0)
!                                              nil 'front-advance nil))
!                 (overlay-put conflict 'evaporate t)
!                 (overlay-put conflict 'smerge 'conflict)
!                 (let ((props smerge-text-properties))
!                   (while props
!                     (overlay-put conflict (pop props) (pop props))))))
!             (setq found t))
!         (error nil)))
!     found))
  
  (defun smerge-diff (n1 n2)
    (smerge-match-conflict)
***************
*** 566,572 ****
        (file1 (make-temp-file "smerge1"))
        (file2 (make-temp-file "smerge2"))
        (dir default-directory)
!       (file (file-relative-name buffer-file-name))
        (coding-system-for-read buffer-file-coding-system))
      (write-region beg1 end1 file1 nil 'nomessage)
      (write-region beg2 end2 file2 nil 'nomessage)
--- 614,625 ----
        (file1 (make-temp-file "smerge1"))
        (file2 (make-temp-file "smerge2"))
        (dir default-directory)
!       (file (if buffer-file-name (file-relative-name buffer-file-name)))
!         ;; We would want to use `emacs-mule-unix' for read&write, but we
!         ;; bump into problems with the coding-system used by diff to write
!         ;; the file names and the time stamps in the header.
!         ;; `buffer-file-coding-system' is not always correct either, but if
!         ;; the OS/user uses only one coding-system, then it works.
        (coding-system-for-read buffer-file-coding-system))
      (write-region beg1 end1 file1 nil 'nomessage)
      (write-region beg2 end2 file2 nil 'nomessage)
***************
*** 594,599 ****
--- 647,654 ----
  (defvar ediff-buffer-A)
  (defvar ediff-buffer-B)
  (defvar ediff-buffer-C)
+ (defvar ediff-ancestor-buffer)
+ (defvar ediff-quit-hook)
  
  ;;;###autoload
  (defun smerge-ediff (&optional name-mine name-other name-base)
***************
*** 687,693 ****
  \\{smerge-mode-map}"
    :group 'smerge :lighter " SMerge"
    (when (and (boundp 'font-lock-mode) font-lock-mode)
-     (set (make-local-variable 'font-lock-multiline) t)
      (save-excursion
        (if smerge-mode
          (font-lock-add-keywords nil smerge-font-lock-keywords 'append)
--- 742,747 ----
***************
*** 695,701 ****
        (goto-char (point-min))
        (while (smerge-find-conflict)
        (save-excursion
!         (font-lock-fontify-region (match-beginning 0) (match-end 0) nil))))))
  
  
  (provide 'smerge-mode)
--- 749,757 ----
        (goto-char (point-min))
        (while (smerge-find-conflict)
        (save-excursion
!         (font-lock-fontify-region (match-beginning 0) (match-end 0) nil)))))
!   (unless smerge-mode
!     (smerge-remove-props (point-min) (point-max))))
  
  
  (provide 'smerge-mode)