[bpt/emacs.git] / admin / bzrmerge.el

;;; bzrmerge.el --- help merge one Emacs bzr branch to another

;; Copyright (C) 2010-2011  Free Software Foundation, Inc.

;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
;; Keywords: 

;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;; Some usage notes are in admin/notes/bzr.

;;; Code:

(eval-when-compile
  (require 'cl))                        ; assert

(defvar bzrmerge-skip-regexp
  "back[- ]?port\\|merge\\|sync\\|re-?generate\\|bump version"
  "Regexp matching logs of revisions that might be skipped.
`bzrmerge-missing' will ask you if it should skip any matches.")

(defconst bzrmerge-buffer "*bzrmerge*"
  "Working buffer for bzrmerge.")

(defconst bzrmerge-warning-buffer "*bzrmerge warnings*"
  "Buffer where bzrmerge will display any warnings.")

(defun bzrmerge-merges ()
  "Return the list of already merged (not yet committed) revisions.
The list returned is sorted by oldest-first."
  (with-current-buffer (get-buffer-create bzrmerge-buffer)
    (erase-buffer)
    ;; We generally want to make sure we start with a clean tree, but we also
    ;; want to allow restarts (i.e. with some part of FROM already merged but
    ;; not yet committed).
    (call-process "bzr" nil t nil "status" "-v")
    (goto-char (point-min))
    (when (re-search-forward "^conflicts:\n" nil t)
      (error "You still have unresolved conflicts"))
    (let ((merges ()))
      (if (not (re-search-forward "^pending merges:\n" nil t))
          (when (save-excursion
                  (goto-char (point-min))
                  (re-search-forward "^[a-z ]*:\n" nil t))
            (error "You still have uncommitted changes"))
        ;; This is really stupid, but it seems there's no easy way to figure
        ;; out which revisions have been merged already.  The only info I can
        ;; find is the "pending merges" from "bzr status -v", which is not
        ;; very machine-friendly.
        (while (not (eobp))
          (skip-chars-forward " ")
          (push (buffer-substring (point) (line-end-position)) merges)
          (forward-line 1)))
      merges)))

(defun bzrmerge-check-match (merge)
  ;; Make sure the MERGES match the revisions on the FROM branch.
  ;; Stupidly the best form of MERGES I can find is the one from
  ;; "bzr status -v" which is very machine non-friendly, so I have
  ;; to do some fuzzy matching.
  (let ((author
         (or
          (save-excursion
            (if (re-search-forward "^author: *\\([^<]*[^ ]\\) +<.*"
                                   nil t)
                (match-string 1)))
          (save-excursion
            (if (re-search-forward
                 "^committer: *\\([^<]*[^< ]\\) +<" nil t)
                (match-string 1)))))
        (timestamp
         (save-excursion
           (if (re-search-forward
                "^timestamp:[^0-9]*\\([-0-9]+\\)" nil t)
               (match-string 1))))
        (line1
         (save-excursion
           (if (re-search-forward "^message:[ \n]*" nil t)
               (buffer-substring (point) (line-end-position))))))
    ;; The `merge' may have a truncated line1 with "...", so get
    ;; rid of any "..." and then look for a prefix match.
    (when (string-match "\\.+\\'" merge)
      (setq merge (substring merge 0 (match-beginning 0))))
    (or (string-prefix-p
         merge (concat author " " timestamp " " line1))
        (string-prefix-p
         merge (concat author " " timestamp " [merge] " line1)))))

(defun bzrmerge-missing (from merges)
  "Return the list of revisions that need to be merged.
MERGES is the revisions already merged but not yet committed.
Asks about skipping revisions with logs matching `bzrmerge-skip-regexp'.
The result is of the form (TOMERGE . TOSKIP) where TOMERGE and TOSKIP
are both lists of revnos, in oldest-first order."
  (with-current-buffer (get-buffer-create bzrmerge-buffer)
    (erase-buffer)
    (call-process "bzr" nil t nil "missing" "--theirs-only"
                  (expand-file-name from))
    (let ((revnos ()) (skipped ()))
      (pop-to-buffer (current-buffer))
      (goto-char (point-max))
      (while (re-search-backward "^------------------------------------------------------------\nrevno: \\([0-9.]+\\).*" nil t)
        (save-excursion
          (if merges
              (while (not (bzrmerge-check-match (pop merges)))
                (unless merges
                  (error "Unmatched tip of merged revisions")))
            (let ((case-fold-search t)
                  (revno (match-string 1))
                  (skip nil))
              (if (string-match "\\." revno)
                  (error "Unexpected dotted revno!")
                (setq revno (string-to-number revno)))
              (re-search-forward "^message:\n")
              (while (and (not skip)
                          (re-search-forward bzrmerge-skip-regexp nil t))
                (let ((str (buffer-substring (line-beginning-position)
                                             (line-end-position))))
                  (when (string-match "\\` *" str)
                    (setq str (substring str (match-end 0))))
                  (when (string-match "[.!;, ]+\\'" str)
                    (setq str (substring str 0 (match-beginning 0))))
                  (if (save-excursion (y-or-n-p (concat str ": Skip? ")))
                      (setq skip t))))
              (if skip
                  (push revno skipped)
                (push revno revnos)))))
        (delete-region (point) (point-max)))
      (and (or revnos skipped)
           (cons (nreverse revnos) (nreverse skipped))))))

(defun bzrmerge-resolve (file)
  (unless (file-exists-p file) (error "Bzrmerge-resolve: Can't find %s" file))
  (with-demoted-errors
    (let ((exists (find-buffer-visiting file)))
      (with-current-buffer (let ((enable-local-variables :safe))
                             (find-file-noselect file))
        (if (buffer-modified-p)
            (error "Unsaved changes in %s" (current-buffer)))
        (save-excursion
          (cond
           ((derived-mode-p 'change-log-mode)
            ;; Fix up dates before resolving the conflicts.
            (goto-char (point-min))
            (let ((diff-auto-refine-mode nil))
              (while (re-search-forward smerge-begin-re nil t)
                (smerge-match-conflict)
                (smerge-ensure-match 3)
                (let ((start1 (match-beginning 1))
                      (end1 (match-end 1))
                      (start3 (match-beginning 3))
                      (end3 (copy-marker (match-end 3) t)))
                  (goto-char start3)
                  (while (re-search-forward change-log-start-entry-re end3 t)
                    (let* ((str (match-string 0))
                           (newstr (save-match-data
                                     (concat (add-log-iso8601-time-string)
                                             (when (string-match " *\\'" str)
                                               (match-string 0 str))))))
                      (replace-match newstr t t)))
                  ;; change-log-resolve-conflict prefers to put match-1's
                  ;; elements first (for equal dates), whereas we want to put
                  ;; match-3's first.
                  (let ((match3 (buffer-substring start3 end3))
                        (match1 (buffer-substring start1 end1)))
                    (delete-region start3 end3)
                    (goto-char start3)
                    (insert match1)
                    (delete-region start1 end1)
                    (goto-char start1)
                    (insert match3)))))
            ;; (pop-to-buffer (current-buffer)) (debug 'before-resolve)
            ))
          ;; Try to resolve the conflicts.
          (cond
           ((member file '("configure" "lisp/ldefs-boot.el"
                           "lisp/emacs-lisp/cl-loaddefs.el"))
            ;; We are in the file's buffer, so names are relative.
            (call-process "bzr" nil t nil "revert"
                          (file-name-nondirectory file))
            (revert-buffer nil 'noconfirm))
           (t
            (goto-char (point-max))
            (while (re-search-backward smerge-begin-re nil t)
              (save-excursion
                (ignore-errors
                  (smerge-match-conflict)
                  (smerge-resolve))))
            ;; (when (derived-mode-p 'change-log-mode)
            ;;   (pop-to-buffer (current-buffer)) (debug 'after-resolve))
            (save-buffer)))
          (goto-char (point-min))
          (prog1 (re-search-forward smerge-begin-re nil t)
            (unless exists (kill-buffer))))))))

(defun bzrmerge-add-metadata (from endrevno)
  "Add the metadata for a merge of FROM upto ENDREVNO.
Does not make other difference."
  (if (with-temp-buffer
        (call-process "bzr" nil t nil "status")
        (goto-char (point-min))
        (re-search-forward "^conflicts:\n" nil t))
      (error "Don't know how to add metadata in the presence of conflicts")
    (call-process "bzr" nil t nil "shelve" "--all"
                  "-m" "Bzrmerge shelved merge during skipping")
    (call-process "bzr" nil t nil "revert")
    (call-process "bzr" nil t nil
                  "merge" "-r" (format "%s" endrevno) from)
    (call-process "bzr" nil t nil "revert" ".")
    (call-process "bzr" nil t nil "unshelve")))

(defvar bzrmerge-already-done nil)

(defun bzrmerge-apply (missing from)
  (setq from (expand-file-name from))
  (with-current-buffer (get-buffer-create bzrmerge-buffer)
    (erase-buffer)
    (when (equal (cdr bzrmerge-already-done) (list from missing))
      (setq missing (car bzrmerge-already-done)))
    (setq bzrmerge-already-done nil)
    (let ((merge (car missing))
          (skip (cdr missing))
          (unsafe nil)
          beg end)
      (when (or merge skip)
        (cond
         ((and skip (or (null merge) (< (car skip) (car merge))))
          ;; Do a "skip" (i.e. merge the meta-data only).
          (setq beg (1- (car skip)))
          (while (and skip (or (null merge) (< (car skip) (car merge))))
            (assert (> (car skip) (or end beg)))
            (setq end (pop skip)))
          (message "Skipping %s..%s" beg end)
          (bzrmerge-add-metadata from end))

         (t
          ;; Do a "normal" merge.
          (assert (or (null skip) (< (car merge) (car skip))))
          (setq beg (1- (car merge)))
          (while (and merge (or (null skip) (< (car merge) (car skip))))
            (assert (> (car merge) (or end beg)))
            (setq end (pop merge)))
          (message "Merging %s..%s" beg end)
          (if (with-temp-buffer
                (call-process "bzr" nil t nil "status")
                (zerop (buffer-size)))
              (call-process "bzr" nil t nil
                            "merge" "-r" (format "%s" end) from)
            ;; Stupidly, "bzr merge --force -r A..B" dos not maintain the
            ;; metadata properly except when the checkout is clean.
            (call-process "bzr" nil t nil "merge"
                          "--force" "-r" (format "%s..%s" beg end) from)
            ;; The merge did not update the metadata, so force the next time
            ;; around to update it (as a "skip").
            (setq unsafe t)
            (push end skip))
          (pop-to-buffer (current-buffer))
          (sit-for 1)
          ;; (debug 'after-merge)
          ;; Check the conflicts.
          ;; FIXME if using the helpful bzr changelog_merge plugin,
          ;; there are normally no conflicts in ChangeLogs.
          ;; But we still want the dates fixing, like bzrmerge-resolve does.
          (let ((conflicted nil)
                (files ()))
            (goto-char (point-min))
            (when (re-search-forward "bzr: ERROR:" nil t)
              (error "Internal Bazaar error!!"))
            (while (re-search-forward "^Text conflict in " nil t)
              (push (buffer-substring (point) (line-end-position)) files))
            (if (re-search-forward "^\\([0-9]+\\) conflicts encountered" nil t)
                (if (/= (length files) (string-to-number (match-string 1)))
                    (setq conflicted t))
              (if files (setq conflicted t)))
            (dolist (file files)
              (if (bzrmerge-resolve file)
                  (setq conflicted t)))
            (when conflicted
              (setq bzrmerge-already-done
                    (list (cons merge skip) from missing))
              (if unsafe
                  ;; FIXME: Obviously, we'd rather make it right rather
                  ;; than output such a warning.  But I don't know how to add
                  ;; the metadata to bzr's since the technique used in
                  ;; bzrmerge-add-metadata does not work when there
                  ;; are conflicts.
                  (display-warning 'bzrmerge "Resolve conflicts manually.
Commit	Line	Data
f6041baa	1	;;; bzrmerge.el --- help merge one Emacs bzr branch to another
9ebea0e7	2
73b0cd50	3	;; Copyright (C) 2010-2011 Free Software Foundation, Inc.
9ebea0e7 SM	4
	5	;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
	6	;; Keywords:
	7
529ee9ed	8	;; GNU Emacs is free software: you can redistribute it and/or modify
9ebea0e7 SM	9	;; it under the terms of the GNU General Public License as published by
	10	;; the Free Software Foundation, either version 3 of the License, or
	11	;; (at your option) any later version.
	12
529ee9ed	13	;; GNU Emacs is distributed in the hope that it will be useful,
9ebea0e7 SM	14	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	;; GNU General Public License for more details.
	17
	18	;; You should have received a copy of the GNU General Public License
529ee9ed	19	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
9ebea0e7 SM	20
	21	;;; Commentary:
	22
f6041baa	23	;; Some usage notes are in admin/notes/bzr.
9ebea0e7 SM	24
	25	;;; Code:
	26
1851cac3 GM	27	(eval-when-compile
	28	(require 'cl)) ; assert
	29
d0cb8662 GM	30	(defvar bzrmerge-skip-regexp
	31	"back[- ]?port\\\|merge\\\|sync\\\|re-?generate\\\|bump version"
	32	"Regexp matching logs of revisions that might be skipped.
	33	`bzrmerge-missing' will ask you if it should skip any matches.")
	34
f6041baa GM	35	(defconst bzrmerge-buffer "bzrmerge"
	36	"Working buffer for bzrmerge.")
	37
4d881c83 GM	38	(defconst bzrmerge-warning-buffer "bzrmerge warnings"
	39	"Buffer where bzrmerge will display any warnings.")
	40
9ebea0e7	41	(defun bzrmerge-merges ()
1851cac3	42	"Return the list of already merged (not yet committed) revisions.
9ebea0e7	43	The list returned is sorted by oldest-first."
f6041baa	44	(with-current-buffer (get-buffer-create bzrmerge-buffer)
9ebea0e7 SM	45	(erase-buffer)
	46	;; We generally want to make sure we start with a clean tree, but we also
	47	;; want to allow restarts (i.e. with some part of FROM already merged but
	48	;; not yet committed).
	49	(call-process "bzr" nil t nil "status" "-v")
	50	(goto-char (point-min))
	51	(when (re-search-forward "^conflicts:\n" nil t)
	52	(error "You still have unresolved conflicts"))
	53	(let ((merges ()))
	54	(if (not (re-search-forward "^pending merges:\n" nil t))
	55	(when (save-excursion
	56	(goto-char (point-min))
	57	(re-search-forward "^[a-z ]*:\n" nil t))
	58	(error "You still have uncommitted changes"))
	59	;; This is really stupid, but it seems there's no easy way to figure
	60	;; out which revisions have been merged already. The only info I can
	61	;; find is the "pending merges" from "bzr status -v", which is not
	62	;; very machine-friendly.
	63	(while (not (eobp))
	64	(skip-chars-forward " ")
	65	(push (buffer-substring (point) (line-end-position)) merges)
	66	(forward-line 1)))
	67	merges)))
	68
	69	(defun bzrmerge-check-match (merge)
	70	;; Make sure the MERGES match the revisions on the FROM branch.
	71	;; Stupidly the best form of MERGES I can find is the one from
	72	;; "bzr status -v" which is very machine non-friendly, so I have
	73	;; to do some fuzzy matching.
	74	(let ((author
	75	(or
	76	(save-excursion
	77	(if (re-search-forward "^author: \\([^<][^ ]\\) +<.*"
	78	nil t)
	79	(match-string 1)))
	80	(save-excursion
	81	(if (re-search-forward
	82	"^committer: \\([^<][^< ]\\) +<" nil t)
	83	(match-string 1)))))
	84	(timestamp
	85	(save-excursion
	86	(if (re-search-forward
	87	"^timestamp:[^0-9]*\\([-0-9]+\\)" nil t)
	88	(match-string 1))))
	89	(line1
	90	(save-excursion
	91	(if (re-search-forward "^message:[ \n]*" nil t)
	92	(buffer-substring (point) (line-end-position))))))
	93	;; The `merge' may have a truncated line1 with "...", so get
	94	;; rid of any "..." and then look for a prefix match.
	95	(when (string-match "\\.+\\'" merge)
	96	(setq merge (substring merge 0 (match-beginning 0))))
	97	(or (string-prefix-p
	98	merge (concat author " " timestamp " " line1))
	99	(string-prefix-p
	100	merge (concat author " " timestamp " [merge] " line1)))))
	101
	102	(defun bzrmerge-missing (from merges)
	103	"Return the list of revisions that need to be merged.
	104	MERGES is the revisions already merged but not yet committed.
d0cb8662	105	Asks about skipping revisions with logs matching `bzrmerge-skip-regexp'.
9ebea0e7 SM	106	The result is of the form (TOMERGE . TOSKIP) where TOMERGE and TOSKIP
9ebea0e7 SM	107	are both lists of revnos, in oldest-first order."
f6041baa	108	(with-current-buffer (get-buffer-create bzrmerge-buffer)
9ebea0e7 SM	109	(erase-buffer)
	110	(call-process "bzr" nil t nil "missing" "--theirs-only"
	111	(expand-file-name from))
	112	(let ((revnos ()) (skipped ()))
	113	(pop-to-buffer (current-buffer))
	114	(goto-char (point-max))
	115	(while (re-search-backward "^------------------------------------------------------------\nrevno: \\([0-9.]+\\).*" nil t)
	116	(save-excursion
	117	(if merges
	118	(while (not (bzrmerge-check-match (pop merges)))
	119	(unless merges
	120	(error "Unmatched tip of merged revisions")))
	121	(let ((case-fold-search t)
	122	(revno (match-string 1))
	123	(skip nil))
	124	(if (string-match "\\." revno)
	125	(error "Unexpected dotted revno!")
	126	(setq revno (string-to-number revno)))
	127	(re-search-forward "^message:\n")
	128	(while (and (not skip)
d0cb8662	129	(re-search-forward bzrmerge-skip-regexp nil t))
9ebea0e7 SM	130	(let ((str (buffer-substring (line-beginning-position)
	131	(line-end-position))))
	132	(when (string-match "\\` *" str)
	133	(setq str (substring str (match-end 0))))
	134	(when (string-match "[.!;, ]+\\'" str)
	135	(setq str (substring str 0 (match-beginning 0))))
	136	(if (save-excursion (y-or-n-p (concat str ": Skip? ")))
	137	(setq skip t))))
	138	(if skip
	139	(push revno skipped)
	140	(push revno revnos)))))
	141	(delete-region (point) (point-max)))
f6041baa GM	142	(and (or revnos skipped)
f6041baa GM	143	(cons (nreverse revnos) (nreverse skipped))))))
9ebea0e7 SM	144
	145	(defun bzrmerge-resolve (file)
	146	(unless (file-exists-p file) (error "Bzrmerge-resolve: Can't find %s" file))
	147	(with-demoted-errors
	148	(let ((exists (find-buffer-visiting file)))
2a35386d GM	149	(with-current-buffer (let ((enable-local-variables :safe))
2a35386d GM	150	(find-file-noselect file))
9ebea0e7 SM	151	(if (buffer-modified-p)
	152	(error "Unsaved changes in %s" (current-buffer)))
	153	(save-excursion
	154	(cond
	155	((derived-mode-p 'change-log-mode)
	156	;; Fix up dates before resolving the conflicts.
	157	(goto-char (point-min))
	158	(let ((diff-auto-refine-mode nil))
	159	(while (re-search-forward smerge-begin-re nil t)
	160	(smerge-match-conflict)
	161	(smerge-ensure-match 3)
	162	(let ((start1 (match-beginning 1))
	163	(end1 (match-end 1))
	164	(start3 (match-beginning 3))
	165	(end3 (copy-marker (match-end 3) t)))
	166	(goto-char start3)
	167	(while (re-search-forward change-log-start-entry-re end3 t)
	168	(let* ((str (match-string 0))
	169	(newstr (save-match-data
	170	(concat (add-log-iso8601-time-string)
	171	(when (string-match " *\\'" str)
	172	(match-string 0 str))))))
	173	(replace-match newstr t t)))
	174	;; change-log-resolve-conflict prefers to put match-1's
	175	;; elements first (for equal dates), whereas we want to put
	176	;; match-3's first.
	177	(let ((match3 (buffer-substring start3 end3))
	178	(match1 (buffer-substring start1 end1)))
	179	(delete-region start3 end3)
	180	(goto-char start3)
	181	(insert match1)
	182	(delete-region start1 end1)
	183	(goto-char start1)
	184	(insert match3)))))
	185	;; (pop-to-buffer (current-buffer)) (debug 'before-resolve)
	186	))
	187	;; Try to resolve the conflicts.
	188	(cond
6fffc900 GM	189	((member file '("configure" "lisp/ldefs-boot.el"
6fffc900 GM	190	"lisp/emacs-lisp/cl-loaddefs.el"))
7b24e97a GM	191	;; We are in the file's buffer, so names are relative.
	192	(call-process "bzr" nil t nil "revert"
	193	(file-name-nondirectory file))
9ebea0e7 SM	194	(revert-buffer nil 'noconfirm))
	195	(t
	196	(goto-char (point-max))
	197	(while (re-search-backward smerge-begin-re nil t)
	198	(save-excursion
	199	(ignore-errors
	200	(smerge-match-conflict)
	201	(smerge-resolve))))
	202	;; (when (derived-mode-p 'change-log-mode)
	203	;; (pop-to-buffer (current-buffer)) (debug 'after-resolve))
	204	(save-buffer)))
	205	(goto-char (point-min))
	206	(prog1 (re-search-forward smerge-begin-re nil t)
	207	(unless exists (kill-buffer))))))))
	208
	209	(defun bzrmerge-add-metadata (from endrevno)
	210	"Add the metadata for a merge of FROM upto ENDREVNO.
	211	Does not make other difference."
	212	(if (with-temp-buffer
	213	(call-process "bzr" nil t nil "status")
	214	(goto-char (point-min))
	215	(re-search-forward "^conflicts:\n" nil t))
	216	(error "Don't know how to add metadata in the presence of conflicts")
	217	(call-process "bzr" nil t nil "shelve" "--all"
	218	"-m" "Bzrmerge shelved merge during skipping")
	219	(call-process "bzr" nil t nil "revert")
	220	(call-process "bzr" nil t nil
	221	"merge" "-r" (format "%s" endrevno) from)
	222	(call-process "bzr" nil t nil "revert" ".")
	223	(call-process "bzr" nil t nil "unshelve")))
529ee9ed	224
9ebea0e7 SM	225	(defvar bzrmerge-already-done nil)
	226
	227	(defun bzrmerge-apply (missing from)
	228	(setq from (expand-file-name from))
f6041baa	229	(with-current-buffer (get-buffer-create bzrmerge-buffer)
9ebea0e7 SM	230	(erase-buffer)
	231	(when (equal (cdr bzrmerge-already-done) (list from missing))
	232	(setq missing (car bzrmerge-already-done)))
	233	(setq bzrmerge-already-done nil)
	234	(let ((merge (car missing))
	235	(skip (cdr missing))
41f44310	236	(unsafe nil)
9ebea0e7 SM	237	beg end)
	238	(when (or merge skip)
	239	(cond
	240	((and skip (or (null merge) (< (car skip) (car merge))))
	241	;; Do a "skip" (i.e. merge the meta-data only).
	242	(setq beg (1- (car skip)))
	243	(while (and skip (or (null merge) (< (car skip) (car merge))))
	244	(assert (> (car skip) (or end beg)))
	245	(setq end (pop skip)))
	246	(message "Skipping %s..%s" beg end)
	247	(bzrmerge-add-metadata from end))
	248
	249	(t
	250	;; Do a "normal" merge.
	251	(assert (or (null skip) (< (car merge) (car skip))))
	252	(setq beg (1- (car merge)))
	253	(while (and merge (or (null skip) (< (car merge) (car skip))))
	254	(assert (> (car merge) (or end beg)))
	255	(setq end (pop merge)))
	256	(message "Merging %s..%s" beg end)
	257	(if (with-temp-buffer
	258	(call-process "bzr" nil t nil "status")
	259	(zerop (buffer-size)))
	260	(call-process "bzr" nil t nil
	261	"merge" "-r" (format "%s" end) from)
	262	;; Stupidly, "bzr merge --force -r A..B" dos not maintain the
	263	;; metadata properly except when the checkout is clean.
	264	(call-process "bzr" nil t nil "merge"
	265	"--force" "-r" (format "%s..%s" beg end) from)
	266	;; The merge did not update the metadata, so force the next time
	267	;; around to update it (as a "skip").
41f44310	268	(setq unsafe t)
9ebea0e7 SM	269	(push end skip))
	270	(pop-to-buffer (current-buffer))
	271	(sit-for 1)
	272	;; (debug 'after-merge)
	273	;; Check the conflicts.
59af988b GM	274	;; FIXME if using the helpful bzr changelog_merge plugin,
	275	;; there are normally no conflicts in ChangeLogs.
	276	;; But we still want the dates fixing, like bzrmerge-resolve does.
9ebea0e7 SM	277	(let ((conflicted nil)
	278	(files ()))
	279	(goto-char (point-min))
	280	(when (re-search-forward "bzr: ERROR:" nil t)
	281	(error "Internal Bazaar error!!"))
	282	(while (re-search-forward "^Text conflict in " nil t)
	283	(push (buffer-substring (point) (line-end-position)) files))
	284	(if (re-search-forward "^\\([0-9]+\\) conflicts encountered" nil t)
	285	(if (/= (length files) (string-to-number (match-string 1)))
	286	(setq conflicted t))
	287	(if files (setq conflicted t)))
	288	(dolist (file files)
	289	(if (bzrmerge-resolve file)
	290	(setq conflicted t)))
	291	(when conflicted
	292	(setq bzrmerge-already-done
	293	(list (cons merge skip) from missing))
41f44310 SM	294	(if unsafe
	295	;; FIXME: Obviously, we'd rather make it right rather
	296	;; than output such a warning. But I don't know how to add
	297	;; the metadata to bzr's since the technique used in
	298	;; bzrmerge-add-metadata does not work when there
	299	;; are conflicts.
	300	(display-warning 'bzrmerge "Resolve conflicts manually.
f6041baa	301