WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/vc
Viewing File: /usr/share/emacs/24.3/lisp/vc/smerge-mode.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:52:16 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/vc/smerge-mode.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310\311\312&\210\313\314\315\316\317DD\320\307\304\321\322&\210\313\323\315\316\324DD\325\307\304\321\326&\210\313\327\315\316\330DD\331\307\304\321\332&\210\333\334\335\336\307\304%\210\337\340\341\334#\210\337\340\342\343\344!\206X\345#\207" [require diff-mode newcomment custom-declare-group smerge nil "Minor mode to highlight and resolve diff3 conflicts." :group tools :prefix "smerge-" custom-declare-variable smerge-diff-buffer-name funcall function #[0 "\300\207" ["*vc-diff*"] 1 "*vc-diff*\n\n(fn)"] "Buffer name to use for displaying diffs." :type (choice (const "*vc-diff*") (const "*cvs-diff*") (const "*smerge-diff*") string) smerge-diff-switches #[0 "\301\302<\203\202
C\"\207" [diff-switches append ("-d" "-b")] 3 "\n\n(fn)"] "A list of strings specifying switches to be passed to diff.\nUsed in `smerge-diff-base-mine' and related functions." (repeat string) smerge-auto-leave #[0 "\300\207" [t] 1 "\n\n(fn)"] "Non-nil means to leave `smerge-mode' when the last conflict is resolved." boolean custom-declare-face smerge-mine ((((class color) (min-colors 88) (background light)) :background "#ffdddd") (((class color) (min-colors 88) (background dark)) :background "#553333") (((class color)) :foreground "red")) "Face for your code." put smerge-mine-face face-alias obsolete-face purecopy "22.1" t] 8)
(defvar smerge-mine-face 'smerge-mine)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312\313!\206\314#\207" [custom-declare-face smerge-other ((((class color) (min-colors 88) (background light)) :background "#ddffdd") (((class color) (min-colors 88) (background dark)) :background "#335533") (((class color)) :foreground "green")) "Face for the other code." :group smerge put smerge-other-face face-alias obsolete-face purecopy "22.1" t] 6)
(defvar smerge-other-face 'smerge-other)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312\313!\206\314#\207" [custom-declare-face smerge-base ((((class color) (min-colors 88) (background light)) :background "#ffffaa") (((class color) (min-colors 88) (background dark)) :background "#888833") (((class color)) :foreground "yellow")) "Face for the base code." :group smerge put smerge-base-face face-alias obsolete-face purecopy "22.1" t] 6)
(defvar smerge-base-face 'smerge-base)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312\313!\206\314#\207" [custom-declare-face smerge-markers ((((background light)) (:background "grey85")) (((background dark)) (:background "grey30"))) "Face for the conflict markers." :group smerge put smerge-markers-face face-alias obsolete-face purecopy "22.1" t] 6)
(defvar smerge-markers-face 'smerge-markers)
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\304\305\311\312&\210\300\313\314\315\304\305\311\312&\207" [custom-declare-face smerge-refined-change ((t nil)) "Face used for char-based changes shown by `smerge-refine'." :group smerge smerge-refined-removed ((default :inherit smerge-refined-change) (((class color) (min-colors 88) (background light)) :background "#ffbbbb") (((class color) (min-colors 88) (background dark)) :background "#aa2222") (t :inverse-video t)) "Face used for removed characters shown by `smerge-refine'." :version "24.3" smerge-refined-added ((default :inherit smerge-refined-change) (((class color) (min-colors 88) (background light)) :background "#aaffaa") (((class color) (min-colors 88) (background dark)) :background "#22aa22") (t :inverse-video t)) "Face used for added characters shown by `smerge-refine'."] 8)
#@36 The base keymap for `smerge-mode'.
(defconst smerge-basic-map (byte-code "\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317!B\320BBBBBBBBBBBB\321\322\300!\205&\321$\207" [smerge-basic-map easy-mmode-define-keymap ("n" . smerge-next) ("p" . smerge-prev) ("r" . smerge-resolve) ("a" . smerge-keep-all) ("b" . smerge-keep-base) ("o" . smerge-keep-other) ("m" . smerge-keep-mine) ("E" . smerge-ediff) ("C" . smerge-combine-with-next) ("R" . smerge-refine) ("
" . smerge-keep-current) "=" make-sparse-keymap "Diff" (("=<" "base-mine" . smerge-diff-base-mine) ("=>" "base-other" . smerge-diff-base-other) ("==" "mine-other" . smerge-diff-mine-other)) nil boundp] 15) (#$ . 4177))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable smerge-command-prefix funcall function #[0 "\300\207" ["^"] 1 "^\n\n(fn)"] "Prefix for `smerge-mode' commands." :group smerge :type (choice (const :tag "ESC" "") (const :tag "C-c ^" "^") (const :tag "none" "") string)] 8)
#@27 Keymap for `smerge-mode'.
(defconst smerge-mode-map (byte-code "\303	BC\304\305\302!\205
\n\304$\207" [smerge-command-prefix smerge-basic-map smerge-mode-map easy-mmode-define-keymap nil boundp] 5) (#$ . 5183))
(defvar smerge-check-cache nil)
(make-variable-buffer-local 'smerge-check-cache)
(defalias 'smerge-check #[257 "\300\301\302\303\304\305\306!\307\"\310\311%D\312\301\313\300EDC\217\207" [#1=#:err funcall make-byte-code 0 "`\302 B	A\232\204\303 \210\304 B\300\305_	@8\207" vconcat vector [smerge-check-cache buffer-modified-tick smerge-match-conflict match-data 2] 3 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 9 "\n\n(fn N)"])
#@25 Menu for `smerge-mode'.
(defvar smerge-mode-menu nil (#$ . 5855))
(easy-menu-do-define 'smerge-mode-menu smerge-mode-map "Menu for `smerge-mode'." '("SMerge" ["Next" smerge-next :help "Go to next conflict"] ["Previous" smerge-prev :help "Go to previous conflict"] "--" ["Keep All" smerge-keep-all :help "Keep all three versions" :active (smerge-check 1)] ["Keep Current" smerge-keep-current :help "Use current (at point) version" :active (and (smerge-check 1) (> (smerge-get-current) 0))] "--" ["Revert to Base" smerge-keep-base :help "Revert to base version" :active (smerge-check 2)] ["Keep Other" smerge-keep-other :help "Keep `other' version" :active (smerge-check 3)] ["Keep Yours" smerge-keep-mine :help "Keep your version" :active (smerge-check 1)] "--" ["Diff Base/Mine" smerge-diff-base-mine :help "Diff `base' and `mine' for current conflict" :active (smerge-check 2)] ["Diff Base/Other" smerge-diff-base-other :help "Diff `base' and `other' for current conflict" :active (smerge-check 2)] ["Diff Mine/Other" smerge-diff-mine-other :help "Diff `mine' and `other' for current conflict" :active (smerge-check 1)] "--" ["Invoke Ediff" smerge-ediff :help "Use Ediff to resolve the conflicts" :active (smerge-check 1)] ["Auto Resolve" smerge-resolve :help "Try auto-resolution heuristics" :active (smerge-check 1)] ["Combine" smerge-combine-with-next :help "Combine current conflict with next" :active (smerge-check 1)]))
#@46 Context menu for mine area in `smerge-mode'.
(defvar smerge-context-menu nil (#$ . 7288))
(easy-menu-do-define 'smerge-context-menu nil "Context menu for mine area in `smerge-mode'." '(nil ["Keep Current" smerge-keep-current :help "Use current (at point) version"] ["Kill Current" smerge-kill-current :help "Remove current (at point) version"] ["Keep All" smerge-keep-all :help "Keep all three versions"] "---" ["More..." (popup-menu smerge-mode-menu) :help "Show full SMerge mode menu"]))
#@39 Font lock patterns for `smerge-mode'.
(defconst smerge-font-lock-keywords '((smerge-find-conflict (1 smerge-mine-face prepend t) (2 smerge-base-face prepend t) (3 smerge-other-face prepend t) (0 smerge-markers-face keep) (4 nil t t) (5 nil t t))) (#$ . 7784))
(defconst smerge-begin-re "^<<<<<<< \\(.*\\)\n")
(defconst smerge-end-re "^>>>>>>> .*\n")
(defconst smerge-base-re "^||||||| .*\n")
(defconst smerge-other-re "^=======\n")
#@121 Keep track of which style of conflict is in use.
Can be nil if the style is undecided, or else:
- `diff3-E'
- `diff3-A'
(defvar smerge-conflict-style nil (#$ . 8223))
#@57 Go to the next COUNT'th conflict.

(fn &optional COUNT)
(defalias 'smerge-next #[256 "\211\204\302\262\211\303W\203\304[!\207\305!\203\211T\262\306\307\310$\2049\305!\2031db\210\202e\311\312\313\"\210\202e\303\224b\210p\314\315 !=\203e\316\317!\203e\212\306\307\310\320$)\206Xd\321\307\310#\204d\322\323!\210\210	\205u\324\325\326D\327\325\330\324EDC\217\207" [smerge-begin-re diff-auto-refine-mode 1 0 smerge-prev looking-at re-search-forward nil t user-error "No next %s" "conflict" window-buffer selected-window called-interactively-p interactive 2 pos-visible-in-window-p recenter (0) #1=#:err funcall #[0 "\300 \207" [smerge-refine] 1 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 7 (#$ . 8396) "p"])
(put 'smerge-next 'definition-name 'smerge)
#@60 Go to the previous COUNT'th conflict

(fn &optional COUNT)
(defalias 'smerge-prev #[256 "\211\204\302\262\211\303W\203\304[!\207\305\306\307$\204 \310\311\312\"\210	\2050\313\314\315D\316\314\317\313EDC\217\207" [smerge-begin-re diff-auto-refine-mode 1 0 smerge-next re-search-backward nil t user-error "No previous %s" "conflict" #1=#:err funcall #[0 "\300 \207" [smerge-refine] 1 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 7 (#$ . 9194) "p"])
(put 'smerge-prev 'definition-name 'smerge)
(defconst smerge-match-names ["conflict" "mine" "base" "other"])
(defalias 'smerge-ensure-match #[257 "\211\225?\205\f\301\302H\"\207" [smerge-match-names error "No `%s'"] 5 "\n\n(fn N)"])
(defalias 'smerge-auto-leave #[0 "\205%\212eb\210\304	\305\306#)?\205%\n<\203\"\203\"\307\303\310E\nB\303\311!\207" [smerge-auto-leave smerge-begin-re buffer-undo-list smerge-mode re-search-forward nil t apply 1 -1] 4 "\n\n(fn)"])
#@33 Concatenate all versions.

(fn)
(defalias 'smerge-keep-all #[0 "\300 \210\301\224\206	d\301\225\206e\302\225\303\225|\210\211\304\225]\302\224|\210\301\225\2030\304\225\302\225U\2040\304\225\301\224|\210\303\224\304\224^|\210\305 \207" [smerge-match-conflict 2 3 0 1 smerge-auto-leave] 5 (#$ . 10150) nil])
(defalias 'smerge-keep-n #[257 "\300\301\224\301\225\"\210\211\225\301\225|\210\301\224\224|\207" [smerge-remove-props 0] 4 "\n\n(fn N)"])
#@55 Combine the current conflict with the next one.

(fn)
(defalias 'smerge-combine-with-next #[0 "\302 \210\303\304\211\203 \211@\211\225\205\305\225\306\"B\262A\266\202\202\210\307\310\"\262\211\311Hb\210\312\303\306#\204:\313\314!\202\277\302 \210\315\316\317 \"\320\211\203d\211@H\203]Hb\210\321p\311H@#\210A\266\202\202C\210\311H@|\210\322\211\203\226\211@\323!\210H\203\217\211\225\203\217Hb\210\321p\224\225#\210A\266\202\202m\210\211@\211A@)|\210\211\211\203\270\211@\211\203\261\211\303\211\223\210A\266\202\202\242\210\324\325\"\262\207" [smerge-begin-re x smerge-match-conflict nil (3 2 1 0) copy-marker t apply vector 0 re-search-forward error "No next conflict" mapcar #[257 "\211\205\300!\207" [copy-marker] 3 "\n\n(fn M)"] match-data (1 2 3) insert-buffer-substring (1 2 3) set-match-data mapc #[257 "\211\205\211\300\211\223\207" [nil] 4 "\n\n(fn M)"]] 9 (#$ . 10609) nil])
#@64 Max number of lines between conflicts that should be combined.
(defvar smerge-auto-combine-max-separation 2 (#$ . 11552))
#@65 Automatically combine conflicts that are near each other.

(fn)
(defalias 'smerge-auto-combine #[0 "\212eb\210\301 \205!\212\301\302\303\\!!)\203\304y\210\305 \210\306y\210\202	)\207" [smerge-auto-combine-max-separation smerge-find-conflict line-beginning-position 2 -1 smerge-combine-with-next 1] 4 (#$ . 11680) nil])
#@217 Mode-specific merge function.
The function is called with zero or one argument (non-nil if the resolution
function should only apply safe heuristics) and with the match data set
according to `smerge-match-conflict'.
(defvar smerge-resolve-function #[0 "\300\301!\207" [user-error "Don't know how to resolve"] 2 "\n\n(fn)"] (#$ . 12011))
(defvar smerge-text-properties '(help-echo "merge conflict: mouse-3 shows a menu" keymap (keymap (down-mouse-3 . smerge-popup-context-menu))))
(defalias 'smerge-remove-props #[514 "\306\307\310$\210\306\307\311$\210\312 \313\211\313\314\211\314\315\316\317\320\321\322!\323\"\324\325%DC\216\326\327#.\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename remove-overlays smerge refine conflict buffer-modified-p t nil funcall make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 "\n\n(fn)" remove-text-properties (fontified nil)] 11 "\n\n(fn BEG END)"])
#@62 Pop up the Smerge mode context menu under mouse.

(fn EVENT)
(defalias 'smerge-popup-context-menu #[257 "\203U\212\306\307!!\210\310\311!)\203U\306\307!!\210\312 \210\313 \314C\315X\203+\316	!\202T\211\317\224\225\"\240\210\320\321\315\322\323\324!\325\"\326\327%DC\216\330@\331\332#\210\333\315!\210\316\n!)\207\212\334\314\335#\336\f\314\335#\337\206fe\206kd\"\210
B\211\266\202)\207" [smerge-mode smerge-mode-menu smerge-context-menu smerge-end-re smerge-begin-re unread-command-events posn-set-point event-end smerge-check 1 smerge-match-conflict smerge-get-current nil 0 popup-menu make-overlay funcall make-byte-code "\301\300@!\207" vconcat vector [delete-overlay] 2 "\n\n(fn)" overlay-put face highlight sit-for re-search-backward t re-search-forward smerge-remove-props] 10 (#$ . 13031) "e"])
#@147 Replace the conflict with a bunch of subconflicts.
BUF contains a plain diff between match-1 and match-3.

(fn BUF M0B M0E M3B M3E &optional M2B)
(defalias 'smerge-apply-resolution-patch #[1541 "\300pb\210`\301\\\302 {\205b\210\303y\210`\301\\\302 {b\210\303y\210`\301\\\302 {\304\n\n\"\210	|\210	|\210	\262ZZ\262b\210r\nq\210eb\210m?\205+\305\306!\204l\307\310`\302 {\"\210\202V\311\224f\312\313\300!!\314=\203~\300\202\315\\\314=\203\212\211\202\231\316\225\203\227\312\313\316!!\202\230\211T\211Z\317=\203\246\320\202\274\321\225\204\257\300\202\274\322\312\313\321!!\312\313\323!!\303#\320\300y\210y\210\324=\203\314\300y\210\204\324\325\202\364`\315\211W\203\355\211\326\316!\210\300y\266\211T\262\202\327\266\211`{\262\262r	q\210Zy\210\327	\330\203\331\f\330Q\202\325\332\261\210y\210\333\330\261\210\262)\266\202V)\207" [1 8 line-end-position -1 smerge-remove-props looking-at "\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)?\\([acd]\\)\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)?$" error "Unexpected patch hunk header: %s" 3 string-to-number match-string 97 0 2 100 nil 5 - 4 99 "" delete-char "<<<<<<< " "\n" "||||||| " "=======\n" ">>>>>>> "] 24 (#$ . 13860)])
(defconst smerge-resolve--normalize-re "[\n	][ 	\n]*\\| [ 	\n]+")
#@72 Extract the text within the comments that span BEG..END.

(fn BEG END)
(defalias 'smerge-resolve--extract-comment #[514 "\212\301\211b\210`W\2034\302\303\"\211\262\2034`b\210\304\305!\210\212\306 \210\307B\262\310`\"B\262)\210\202\307B\262\311\312!r\211q\210\313\314\315\316\317\320!\321\"\322\323%DC\216\324\325\237\"\210eb\210\326\301\303#\203i\327\307!\210\202Z\330 *\262\266\202)\207" [smerge-resolve--normalize-re nil comment-search-forward t comment-forward 1 comment-enter-backward " " buffer-substring-no-properties generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" apply insert re-search-forward replace-match buffer-string] 12 (#$ . 15163)])
(defalias 'smerge-resolve--normalize #[514 "\301\302\211\303\"\302Q#\207" [smerge-resolve--normalize-re replace-regexp-in-string " " buffer-substring-no-properties] 9 "\n\n(fn BEG END)"])
#@202 Resolve the conflict at point intelligently.
This relies on mode-specific knowledge and thus only works in some
major modes.  Uses `smerge-resolve-function' to do the actual work.

(fn &optional SAFE)
(defalias 'smerge-resolve #[256 "\303 \210\304\305\224\305\225\"\210\306 \305\224\307\224\310\224\311\224\305\225\307\225\310\225\311\225\312\313!\314C\314C\314C\314\315\316\305\317\320\321\n\n\n\n$\322\"\310\323%DC\216\307\225\311\225=\203T\307\224\311\224=\203T\324\311!\210\202\335\325\315\316\305\326\320\321!\327\"\330\323%D\331\315\332\325EDC\217\204\335=\203\213\n=\203\213\333!\210\324\311!\210\202\335\334\n\"\335\336!\240\210\337
\n@\314\340%\210\335\341!\240\210\337@\314\340%\210\f	=\206\366\n=\206\366\342\343\314	\314\344	@\f@&!\204\346\203\346=?\206\366rq\210eb\210\345\346\347!\350Q!)?\262\203\351
\n&\210\202\335\203L\335\352!\240\210\337@\314\340%\210rq\210\353 \210)\342\343\314\314\354	@@&!\203L\333!\210\324\311!\210\202\335\204\230\203\230@\203\230\n=\204\230rq\210\342\355ed\356\357\314\211\360	\361\362
@&!)\203\230\214\f	}\210\304
\n\"\210\363@\314\211\211\357%\210)\202\335\204\377\203\377@\203\377\n=\204\377\337\n@\314\340%\210\343\314\314\354@@&\210rq\210\342\355ed\356\357\314\211\360	\361\362@&!)\203\377\214\f	}\210\304
\n\"\210\363@\314\211\211\357%\210)\202\335\203f\364\f	\"\203f\364\"\203f\364\n\"\203f\365\f	\"\365\f	\"\365\f	\"\232\203D\232\204D\311\211\262\202U\232?\205U\232\205U\307\211\262\266\203\203f\333!\210\324!\210\202\335\212\205\311\366\367!8\205\311\370\n\314\357#?\205\311\371\367!8b\210\372\307!\210`	V\205\311\373\f	\"\373\f	\"\373\f	\"\232\203\266\232\204\266\311\211\262\202\307\232?\205\307\232\205\307\307\211\262\266\203)\203\331\333!\210\324!\210\202\335\374\375!\210)\266\376 \207" [diff-command null-device smerge-begin-re smerge-match-conflict smerge-remove-props 0 match-data 1 2 3 generate-new-buffer " *smerge*" nil funcall make-byte-code "\304\300!\203\n\305\300!\210\301@\203\306\301@!\210\302@\203\306\302@!\210\303@\205'\306\303@!\207" vconcat vector [buffer-name kill-buffer delete-file] "\n\n(fn)" smerge-keep-n #1=#:err "\306 \307	\211\307C\307\262\307\262\307\262\310\311\312\313\314\315\n\"\316\"\317\320%DC\216\321!\210\300\2038
\300!\210\202;
 \210\211\322\240,\207" [most-positive-fixnum undo-strong-limit undo-limit undo-outer-limit smerge-resolve-function prepare-change-group nil funcall make-byte-code 0 "\301@\203	\302\300!\207\303\300!\207" vconcat vector [accept-change-group cancel-change-group] 2 "\n\n(fn)" activate-change-group t] 13 error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] set-match-data count-lines make-temp-file "smm" write-region silent "smo" zerop call-process "-b" looking-at "1," number-to-string "c" smerge-apply-resolution-patch "smb" erase-buffer "-bc" call-process-region "patch" t "-r" "--no-backup-if-mismatch" "-fl" insert-file-contents comment-only-p smerge-resolve--extract-comment 4 syntax-ppss re-search-backward 8 forward-comment smerge-resolve--normalize user-error "Don't know how to resolve" smerge-auto-leave] 28 (#$ . 16128) nil])
#@54 Perform automatic resolution on all conflicts.

(fn)
(defalias 'smerge-resolve-all #[0 "\212eb\210\301\302\303#\205\304\305\306D\307\305\310\304EDC\217\210\202)\207" [smerge-begin-re re-search-forward nil t #1=#:err funcall #[0 "\300 \210\301\302!\207" [smerge-match-conflict smerge-resolve safe] 2 "\n\n(fn)"] error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 6 (#$ . 19443) nil])
(defalias 'smerge-batch-resolve #[0 "\204\302\303!\210	\205?	\211A@\304\305\"\203\211\306\211\224O\262\307\310\"\210\311!\203;r\312!q\210\313 \210\314 \210\315p!\210)\210\202\207" [noninteractive command-line-args-left error "`smerge-batch-resolve' is to be used only with -batch" string-match "\\.rej\\'" 0 message "Resolving conflicts in %s..." file-readable-p find-file-noselect smerge-resolve-all save-buffer kill-buffer] 4 "\n\n(fn)"])
#@35 Revert to the base version.

(fn)
(defalias 'smerge-keep-base #[0 "\300 \210\301\302!\210\303\302!\210\304 \207" [smerge-match-conflict smerge-ensure-match 2 smerge-keep-n smerge-auto-leave] 2 (#$ . 20294) nil])
#@28 Use "other" version.

(fn)
(defalias 'smerge-keep-other #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 3 smerge-auto-leave] 2 (#$ . 20512) nil])
#@26 Keep your version.

(fn)
(defalias 'smerge-keep-mine #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 1 smerge-auto-leave] 2 (#$ . 20691) nil])
(defalias 'smerge-get-current #[0 "\300\211\225\203`\224W\204`\225Y\203\211S\262\202\211\207" [3] 3 "\n\n(fn)"])
#@51 Use the current (under the cursor) version.

(fn)
(defalias 'smerge-keep-current #[0 "\300 \210\301 \211\302X\203\303\304!\202\305!\210\306 \207" [smerge-match-conflict smerge-get-current 0 error "Not inside a version" smerge-keep-n smerge-auto-leave] 3 (#$ . 20991) nil])
#@54 Remove the current (under the cursor) version.

(fn)
(defalias 'smerge-kill-current #[0 "\301 \210\302 \211\303X\203\304\305!\202T\306\307\211\2032\211@\211\225\203+\211\225\225U\204+\211B\262A\266\202\202\210\211A\203K\211@\225\211A@)\225U\204K\310 \202R\311@!\210\312 \262\207" [x smerge-match-conflict smerge-get-current 0 error "Not inside a version" nil (3 2 1) ding smerge-keep-n smerge-auto-leave] 7 (#$ . 21275) nil])
#@66 Diff 'base' and 'mine' version in current conflict region.

(fn)
(defalias 'smerge-diff-base-mine #[0 "\300\301\302\"\207" [smerge-diff 2 1] 3 (#$ . 21726) nil])
#@67 Diff 'base' and 'other' version in current conflict region.

(fn)
(defalias 'smerge-diff-base-other #[0 "\300\301\302\"\207" [smerge-diff 2 3] 3 (#$ . 21894) nil])
#@67 Diff 'mine' and 'other' version in current conflict region.

(fn)
(defalias 'smerge-diff-mine-other #[0 "\300\301\302\"\207" [smerge-diff 1 3] 3 (#$ . 22064) nil])
#@219 Get info about the conflict.  Puts the info in the `match-data'.
The submatches contain:
 0:  the whole conflict.
 1:  your code.
 2:  the base code.
 3:  other code.
An error is raised if not inside a conflict.

(fn)
(defalias 'smerge-match-conflict #[0 "\212\300\301\302D\303\301\304\300EDC\217)\207" [#1=#:err funcall #[0 "`\306y\307!\310\224\310\225\311\306!\206\312\313	!\310\225W\204\"\314\315\316C\"\210\317\310\224\310\225\307\n\"\310\224\310\225\317\211\212\nb\210\313\320#)\203H\321\322!\210\202\242\307
\320#\203e\323\304!\210\324\262\310\224\262\310\225\262\202\242	\325
\206m\312!\230\203{\323\304!\210\326\202\242\204\242\f\324=\204\224	\327\232\204\224\330\331\"\203\242\n\262\262\262\262\332\f
	\n\205\273\nS
S\257\f!\210\320\207" [smerge-begin-re smerge-end-re smerge-other-re smerge-base-re smerge-conflict-style buffer-file-name 1 re-search-backward 0 match-string "" re-search-forward signal cl-assertion-failed (< orig-point (match-end 0)) nil t error "There is a nested conflict" make-local-variable diff3-A file-name-nondirectory diff3-E "ANCESTOR" string-match "\\`[.0-9]+\\'" store-match-data] 28 "\n\n(fn)"] search-failed #[257 "\300\301!\207" [user-error "Point not in conflict region"] 3 "\n\n(fn IGNORED)"]] 6 (#$ . 22235)])
#@54 Return the conflict overlay at POS if any.

(fn POS)
(defalias 'smerge-conflict-overlay #[257 "\300!\301\211\203&\211@\302\303\"\304=\203\305!V\203\211\262A\266\202\202\210\207" [overlays-at nil overlay-get smerge conflict overlay-end] 8 (#$ . 23561)])
#@254 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.

(fn &optional LIMIT)
(defalias 'smerge-find-conflict #[256 "\301C`\301C@\204@\211\302!\240\203@\303\304\305\306\307\310\311			#\312\"\313\314%D\315\304\305\316\317\310\311\n\n\"\320\"\321\322%\303EDC\217\210\202@\204i\323\324#\203i\325\304\305\306\326\310\311	!\327\"\330\314%D\315\304\331\325EDC\217\210\202@@\207" [smerge-begin-re nil smerge-conflict-overlay #1=#:err funcall make-byte-code 0 "\303\302@!b\210\304 \210\305\225b\210`\301X\203\306\307!\207\300\310\240\207" vconcat vector [overlay-start smerge-match-conflict 0 error "Matching backward!" t] 2 "\n\n(fn)" error 257 "\302\303\301@!\304\301@!\"\210\300b\207" [smerge-remove-props overlay-start overlay-end] 5 "\n\n(fn IGNORED)" re-search-forward t #2=#:err "\302 \210\303\225b\210\304`S!\211\203\305\303\224\303\225#\210\202J\306\303\224\303\225\307\310\307%\262\311\312\313#\210\311\314\315#\210	\211\203I\311\211A\262@\211A\262@#\210\2022\210\210\300\313\240\207" [smerge-text-properties smerge-match-conflict 0 smerge-conflict-overlay move-overlay make-overlay nil front-advance overlay-put evaporate t smerge conflict] 7 #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 15 (#$ . 23835)])
#@479 Function used to determine an "atomic" element.
You can set it to `forward-char' to get char-level granularity.
Its behavior has mainly two restrictions:
- if this function encounters a newline, it's important that it stops right
  after the newline.
  This only matters if `smerge-refine-ignore-whitespace' is nil.
- it needs to be unaffected by changes performed by the `preproc' argument
  to `smerge-refine-subst'.
  This only matters if `smerge-refine-weight-hack' is nil.
(defvar smerge-refine-forward-function 'smerge-refine-forward (#$ . 25262))
#@86 If non-nil, indicate that `smerge-refine' should try to ignore change in whitespace.
(defvar smerge-refine-ignore-whitespace t (#$ . 25822))
#@838 If non-nil, pass to diff as many lines as there are chars in the region.
I.e. each atomic element (e.g. word) will be copied as many times (on different
lines) as it has chars.  This has two advantages:
- if `diff' tries to minimize the number *lines* (rather than chars)
  added/removed, this adjust the weights so that adding/removing long
  symbols is considered correspondingly more costly.
- `smerge-refine-forward-function' only needs to be called when chopping up
  the regions, and `forward-char' can be used afterwards.
It has the following disadvantages:
- cannot use `diff -w' because the weighting causes added spaces in a line
  to be represented as added copies of some line, so `diff -w' can't do the
  right thing any more.
- may in degenerate cases take a 1KB input region and turn it into a 1MB
  file to pass to diff.
(defvar smerge-refine-weight-hack t (#$ . 25970))
(defalias 'smerge-refine-forward #[257 "\303\304\303\262	\203\n\204\305\306Q\262\307\211W\2054\211\310!\204(\311\312!\210\307\225b\266\211T\262\202\266\202)\207" [case-fold-search smerge-refine-ignore-whitespace smerge-refine-weight-hack nil "[[:upper:]]?[[:lower:]]+\\|[[:upper:]]+\\|[[:digit:]]+\\|.\\|\n" "[ 	]*\\(?:" "\\)" 0 looking-at error "Smerge refine internal error"] 8 "\n\n(fn N)"])
#@320 Chopup the region into small elements, one per line.
Save the result into FILE.
If non-nil, PREPROC is called with no argument in a buffer that contains
a copy of the text, just before chopping it up.  It can be used to replace
chars to try and eliminate some spurious differences.

(fn BEG END FILE &optional PREPROC)
(defalias 'smerge-refine-chopup-region #[1027 "p\304\305!r\211q\210\306\307\310\311\312\313!\314\"\315\316%DC\216\317#\210\203+eb\210 \210\2036\320ed\321\322$\210eb\210m\204}	\323!\210\324u\210n\323u\210?\205P\325 `{`Sf\321=\204[\321c\210\n\203y\211GS\310\211W\203w\211\326\261\266\211T\262\202c\266\210\2029n\204\205\327\330!\210\331\332ed\333\334%+\262\207" [smerge-refine-ignore-whitespace smerge-refine-forward-function smerge-refine-weight-hack coding-system-for-write generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" insert-buffer-substring subst-char-in-region 10 32 1 -1 line-beginning-position "\n" error "Smerge refine internal error" emacs-mule write-region nil nomessage] 13 (#$ . 27277)])
(defalias 'smerge-refine-highlight-change #[1285 "rq\210b\210\303!S\203\304\202	!\210`\203 \304\202!	\203-\303!Z\202.\305!\210`\n\203F\306x\210`\262b\210\306w\210`\262\211V\205s\307\310\311\310%\312\313\314#\210\211\203o\211@\312@A#\210A\266\202\202Z\210\211\262\266\203)\207" [smerge-refine-weight-hack smerge-refine-forward-function smerge-refine-ignore-whitespace string-to-number forward-char 1 " 	\n" make-overlay nil front-advance overlay-put evaporate t] 15 "\n\n(fn BUF BEG MATCH-NUM1 MATCH-NUM2 PROPS)"])
#@874 Show fine differences in the two regions BEG1..END1 and BEG2..END2.
PROPS-C is an alist of properties to put (via overlays) on the changes.
PROPS-R is an alist of properties to put on removed characters.
PROPS-A is an alist of properties to put on added characters.
If PROPS-R and PROPS-A are nil, put PROPS-C on all changes.
If PROPS-C is nil, but PROPS-R and PROPS-A are non-nil,
put PROPS-A on added characters, PROPS-R on removed characters.
If PROPS-C, PROPS-R and PROPS-A are non-nil, put PROPS-C on changed characters,
PROPS-A on added characters, and PROPS-R on removed characters.

If non-nil, PREPROC is called with no argument in a buffer that contains
a copy of a region, just before preparing it to for `diff'.  It can be
used to replace chars to try and eliminate some spurious differences.

(fn BEG1 END1 BEG2 END2 PROPS-C &optional PREPROC PROPS-R PROPS-A)
(defalias 'smerge-refine-subst #[2053 "p`\305\306\307!\306\310!\311\f\f\n$\210\311\n\n\n$\210\312\313\314\315\316\317#\320\"\321\322%DC\216\323\324!r\211q\210\312\313\314\325\316\317!\326\"\321\322%DC\216\327\330\n\305\331\305\203^\f\204^\332\202_\333&\210)eb\210\305\211m\204\351\334\335!\204~\336\337`\340 {\"\210\341\224f\342\343!\342\321!\342\344!\342\345!\346>\203\262\347\f	\350=\203\250\206\257\206\257%\262\351>\203\325\347\f	\350=\203\313\206\322\206\322%\262\266\343y\210\352\353\305\354#\203l\314\224b\210\202l\f?\205\203\355!V\203\356\357!#\210\211\205\355!\fV\205\356\357!#\266\202*\262*\207" [deactivate-mark coding-system-for-read diff-command smerge-refine-ignore-whitespace smerge-refine-weight-hack nil make-temp-file "diff1" "diff2" smerge-refine-chopup-region funcall make-byte-code 0 "\300b\210\303\301!\210\303\302!\207" vconcat vector [delete-file] 2 "\n\n(fn)" generate-new-buffer " *temp*" "\301\300!\205	\302\300!\207" [buffer-name kill-buffer] emacs-mule call-process t "-awd" "-ad" looking-at "\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)?\\([acd]\\)\\([0-9]+\\)\\(?:,\\([0-9]+\\)\\)?$" error "Unexpected patch hunk header: %s" line-end-position 3 match-string 1 4 5 (100 99) smerge-refine-highlight-change 99 (97 99) re-search-forward "^[0-9]" move overlay-end move-overlay overlay-start] 27 (#$ . 28976)])
#@257 Highlight the words of the conflict that are different.
For 3-way conflicts, highlights only two of the three parts.
A numeric argument PART can be used to specify which two parts;
repeating the command will highlight other two parts.

(fn &optional PART)
(defalias 'smerge-refine #[256 "\211\250\203\211\306W\204\211\307V\203\310\311\"\210\312 \210\313\314\224\314\225\315\316$\210\317\225\204+\317\202Y\306\225\307\225=\2037\306\202Y\211\250\203@\211\202Y\306\225\306\224=\203L\306\202Y\307\225\307\224=\203X\307\202Y\317\262\211\306=\203e\317\202f\306\307=\203p\317\202q\307\320\321!\205\204\322\321\323\"?\205\204\322\321\324\"?\325!\210\325!\210\326 \327\211\327\330\211\330\331\332\314\333\334\335!\336\"\317\337%DC\216\340\314\224\314\224T\341\342 	B$\210.\210\343\224\225\224\225\205\312\344\330?\205\322\345?\205\331\346&\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename 1 3 error "No conflict part nb %s" smerge-match-conflict remove-overlays 0 smerge refine 2 face-differs-from-default-p smerge-refined-change face-equal smerge-refined-added smerge-refined-removed smerge-ensure-match buffer-modified-p t nil funcall make-byte-code "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] "\n\n(fn)" put-text-property smerge-refine-part buffer-chars-modified-tick smerge-refine-subst ((smerge . refine) (face . smerge-refined-change)) ((smerge . refine) (face . smerge-refined-removed)) ((smerge . refine) (face . smerge-refined-added))] 14 (#$ . 31277) (byte-code "\250\203C\207\301 \210\302\303\224\304\"\211:\205\305 @=\205\211A\211\250\205)\306\307\"TC\207" [current-prefix-arg smerge-match-conflict get-text-property 0 smerge-refine-part buffer-chars-modified-tick mod 3] 5)])
(defalias 'smerge-diff #[514 "\306 \210\307!\210\307!\210HH\224\225\224\225\310\311!\310\312!	\n\205'\313\n!\314\315\316%\210\314\315\316%\210\317\320\321\322\323\324		\"\325\"\326\327%DC\216r\330
!q\210\331#\332 \210\333\334$\315\331\315\335%\336\337Q\336\337
Q\257\"&\211\321=\203\211\340c\210\210)eb\210\341 \210\342p\331\"+\207" [smerge-match-names default-directory buffer-file-name buffer-file-coding-system coding-system-for-read smerge-diff-buffer-name smerge-match-conflict smerge-ensure-match make-temp-file "smerge1" "smerge2" file-relative-name write-region nil nomessage funcall make-byte-code 0 "\302\300!\210\302\301!\207" vconcat vector [delete-file] 2 "\n\n(fn)" get-buffer-create t erase-buffer apply call-process append "-L" "/" "No differences found.\n" diff-mode display-buffer inhibit-read-only diff-command smerge-diff-switches] 26 "\n\n(fn N1 N2)"])
#@168 Invoke ediff to resolve the conflicts.
NAME-MINE, NAME-OTHER, and NAME-BASE, if non-nil, are used for the
buffer names.

(fn &optional NAME-MINE NAME-OTHER NAME-BASE)
(defalias 'smerge-ediff #[768 "p\305 \306	!\307\206\310\311Q!\307\206\310\312Q!\313rq\210\314 \210\315!\210eb\210\316 \203A\317\224\203:\320\262\321\322!\210\202-\323 \210\324\313!\210 \210)rq\210\314 \210\315!\210eb\210\316 \203g\321\325!\210\202[\323 \210\324\313!\210 \210)\211\203\267\307\206\200\310\326Q!\262r\211q\210\314 \210\315!\210eb\210\316 \203\254\317\225\203\243\321\317!\210\202\222\327\224\327\225|\210\202\222\323 \210\324\313!\210 \210)\211\203\303\330#\202\307\331\"q\210\332\302!\210\332\303!\210\332\304!\210\333\334\335!\207" [major-mode buffer-file-name smerge-ediff-windows smerge-ediff-buf ediff-quit-hook current-window-configuration file-name-nondirectory generate-new-buffer "*" " MINE*" " OTHER*" nil buffer-disable-undo insert-buffer-substring smerge-find-conflict 2 t smerge-keep-n 1 buffer-enable-undo set-buffer-modified-p 3 " BASE*" 0 ediff-merge-buffers-with-ancestor ediff-merge-buffers make-local-variable #[0 "	\n\f
\306 \210rq\210\307 \210\310!\210\311!\210\311!\210\311!\210\312!\203+\311!\210\313!\210\314\315!)\207" [ediff-buffer-A ediff-buffer-B ediff-buffer-C ediff-ancestor-buffer smerge-ediff-buf smerge-ediff-windows ediff-cleanup-mess erase-buffer insert-buffer-substring kill-buffer bufferp set-window-configuration message "Conflict resolution finished; you may save the buffer"] 8 "\n\n(fn)"] message "Please resolve conflicts now; exit ediff when done"] 14 (#$ . 34047) nil])
#@274 Insert diff3 markers to make a new conflict.
Uses point and mark for two of the relevant positions and previous marks
for the other ones.
By default, makes up a 2-way conflict,
with a \[universal-argument] prefix, makes up a 3-way conflict.

(fn PT1 PT2 PT3 &optional PT4)
(defalias 'smerge-makeup-conflict #[1027 "\301\205\nCBBB\302\"\211@A\211@A\211@A\211@A\n\211b\210\303 \210\304c\210b\210\303 \210\305c\210b\210\303 \210\203J\306c\210b\210\303 \210\307c\266\204V\300\310!\210\311 \207" [smerge-mode sort >= beginning-of-line ">>>>>>> OTHER\n" "=======\n" "||||||| BASE\n" "<<<<<<< MINE\n" 1 smerge-refine] 18 (#$ . 35713) (byte-code "`\301 \302 \210\301 \205\302 \210\301 F\207" [current-prefix-arg mark pop-mark] 4)])
(defconst smerge-parsep-re (concat smerge-begin-re #1="\\|" smerge-end-re #1# smerge-base-re #1# smerge-other-re #1#))
#@91 Non-nil if Smerge mode is enabled.
Use the command `smerge-mode' to change this variable.
(defvar smerge-mode nil (#$ . 36588))
(make-variable-buffer-local 'smerge-mode)
#@256 Minor mode to simplify editing output from the diff3 program.
With a prefix argument ARG, enable the mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.
\{smerge-mode-map}

(fn &optional ARG)
(defalias 'smerge-mode #[256 "\305 \306=\203
?\202\307!\310V\311\301!\203F	\203F\212\203+\312\313\n\314#\210\2020\315\313\n\"\210eb\210\316 \203E\212\317\310\224\310\225\313#\210)\2023)\320\321!\f\"\203a\204m\322\304!\210\323\324\325\211\f$\202m\203m\322\304!\210\fP\204v\326ed\"\210\327\330\203\200\331\202\201\332\"\210\333\334!\203\242\305 \203\225\211\305 \232\203\242\335\336\203\237\337\202\240\340\"\210\210\341 \210\207" [smerge-mode font-lock-mode smerge-font-lock-keywords smerge-parsep-re paragraph-separate current-message toggle prefix-numeric-value 0 boundp font-lock-add-keywords nil append font-lock-remove-keywords smerge-find-conflict font-lock-fontify-region string-match regexp-quote make-local-variable replace-match "" t smerge-remove-props run-hooks smerge-mode-hook smerge-mode-on-hook smerge-mode-off-hook called-interactively-p any message "Smerge mode %sabled" "en" "dis" force-mode-line-update] 7 (#$ . 36765) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(byte-code "\301\302\303\304\300!\205\n\305\211%\207" [smerge-mode-map add-minor-mode smerge-mode " SMerge" boundp nil] 6)
#@125 Turn on `smerge-mode' and move point to first conflict marker.
If no conflict maker is found, turn off `smerge-mode'.

(fn)
(defalias 'smerge-start-session #[0 "\300\301!\210\302\303\304D\305\303\306\302EDC\217\207" [smerge-mode 1 #1=#:err funcall #[0 "\301!?\205	\302 \207" [smerge-begin-re looking-at smerge-next] 2 "\n\n(fn)"] error #[257 "\300 \207" [smerge-auto-leave] 2 "\n\n(fn IGNORED)"]] 6 (#$ . 38189) nil])
(provide 'smerge-mode)
F1l3 Manager
