[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.")

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