%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/vc/
Current File : //usr/local/share/emacs/27.2/lisp/vc/smerge-mode.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\300\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\322\323%\210\314\324\316\317\325DD\326\322\327%\210\314\330\316\317\331DD\332\322\333%\210\334\335\336\337#\210\340\341\342\335#\210\340\341\343\344\345!\206Q\346#\207" [require diff 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" [#1="*vc-diff*"] 1 #1#] "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] "A list of strings specifying switches to be passed to diff.\nUsed in `smerge-diff-base-upper' and related functions." (repeat string) smerge-auto-leave #[0 "\300\207" [t] 1] "Non-nil means to leave `smerge-mode' when the last conflict is resolved." boolean custom-declare-face smerge-upper ((((class color) (min-colors 88) (background light)) :background "#ffdddd" :extend t) (((class color) (min-colors 88) (background dark)) :background "#553333" :extend t) (((class color)) :foreground "red" :extend)) "Face for the `upper' version of a conflict." put smerge-mine face-alias obsolete-face purecopy "26.1" t] 8)
(defvar smerge-upper-face 'smerge-upper)
(byte-code "\300\301\302\303#\210\304\305\306\301#\210\304\305\307\310\311!\206\312#\207" [custom-declare-face smerge-lower ((((class color) (min-colors 88) (background light)) :background "#ddffdd" :extend t) (((class color) (min-colors 88) (background dark)) :background "#335533" :extend t) (((class color)) :foreground "green" :extend)) "Face for the `lower' version of a conflict." put smerge-other face-alias obsolete-face purecopy "26.1" t] 5)
(defvar smerge-lower-face 'smerge-lower)
(custom-declare-face 'smerge-base '((((class color) (min-colors 88) (background light)) :background "#ffffaa" :extend t) (((class color) (min-colors 88) (background dark)) :background "#888833" :extend t) (((class color)) :foreground "yellow" :extend t)) "Face for the base code.")
(defvar smerge-base-face 'smerge-base)
(custom-declare-face 'smerge-markers '((((background light)) (:background "grey85" :extend t)) (((background dark)) (:background "grey30" :extend t))) "Face for the conflict markers.")
(defvar smerge-markers-face 'smerge-markers)
(byte-code "\300\301\302\303#\210\304\305\306\301#\210\304\305\307\310\311!\206\312#\210\300\313\314\315\316\317%\210\300\320\321\322\316\317%\207" [custom-declare-face smerge-refined-changed ((t nil)) "Face used for char-based changes shown by `smerge-refine'." put smerge-refined-change face-alias obsolete-face purecopy "24.5" t 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'."] 6)
#@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\320\321!B\322BBBBBBBBBBBBBB\323\324\300!\205*\323$\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-lower) ("l" . smerge-keep-lower) ("m" . smerge-keep-upper) ("u" . smerge-keep-upper) ("E" . smerge-ediff) ("C" . smerge-combine-with-next) ("R" . smerge-refine) ("
" . smerge-keep-current) "=" make-sparse-keymap "Diff" (("=<" "base-upper" . smerge-diff-base-upper) ("=>" "base-lower" . smerge-diff-base-lower) ("==" "upper-lower" . smerge-diff-upper-lower)) nil boundp] 17) (#$ . 3823))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable smerge-command-prefix funcall function #[0 "\300\207" [#1="^"] 1 #1#] "Prefix for `smerge-mode' commands." :type (choice (const :tag "ESC" "") (const :tag "C-c ^" "^") (const :tag "none" "") string)] 6)
#@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) (#$ . 4867))
(defvar smerge-check-cache nil)
(make-variable-buffer-local 'smerge-check-cache)
#@10 

(fn N)
(defalias 'smerge-check #[257 "\3011!`\302 BA\232\204\303 \210\304 B\305_@8\2620\207\210\306\207" [smerge-check-cache (error) buffer-modified-tick smerge-match-conflict match-data 2 nil] 4 (#$ . 5167)])
#@25 Menu for `smerge-mode'.
(defvar smerge-mode-menu nil (#$ . 5395))
(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 Upper" smerge-keep-upper :help "Keep `upper' version" :active (smerge-check 1)] ["Keep Lower" smerge-keep-lower :help "Keep `lower' version" :active (smerge-check 3)] "--" ["Diff Base/Upper" smerge-diff-base-upper :help "Diff `base' and `upper' for current conflict" :active (smerge-check 2)] ["Diff Base/Lower" smerge-diff-base-lower :help "Diff `base' and `lower' for current conflict" :active (smerge-check 2)] ["Diff Upper/Lower" smerge-diff-upper-lower :help "Diff `upper' and `lower' 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)]))
#@47 Context menu for upper area in `smerge-mode'.
(defvar smerge-context-menu nil (#$ . 6838))
(easy-menu-do-define 'smerge-context-menu nil "Context menu for upper 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-upper-face prepend t) (2 smerge-base-face prepend t) (3 smerge-lower-face prepend t) (0 smerge-markers-face keep) (4 nil t t) (5 nil t t))) (#$ . 7336))
(defconst smerge-begin-re "^<<<<<<< \\(.*\\)\n")
(defconst smerge-end-re "^>>>>>>> \\(.*\\)\n")
(defconst smerge-base-re "^||||||| \\(.*\\)\n")
(defconst smerge-lower-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 (#$ . 7788))
#@129 Go to the next COUNT'th conflict.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(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\202r\311\312\313\"\210\202r\303\224b\210p\314 =\203r\315\316!\203r\212\306\307\310\317$)\206Vd\320\307\310#\204q\321 \322\323!\210\321 W\203p\324\307\"\210\210\210	\205\200\3251~\326 0\207\210\307\207" [smerge-begin-re diff-refine 1 0 smerge-prev looking-at re-search-forward nil t user-error "No next %s" "conflict" window-buffer called-interactively-p interactive 2 pos-visible-in-window-p window-start recenter (0) set-window-start (error) smerge-refine] 6 (#$ . 7962) "p"])
(put 'smerge-next 'definition-name 'smerge)
#@133 Go to the previous COUNT'th conflict.
Interactively, COUNT is the prefix numeric argument, and defaults to 1.

(fn &optional COUNT)
(defalias 'smerge-prev #[256 "\211\204\302\262\211\303W\203\304[!\207\305\306\307$\204 \310\311\312\"\210	\205.\3131,\314 0\207\210\306\207" [smerge-begin-re diff-refine 1 0 smerge-next re-search-backward nil t user-error "No previous %s" "conflict" (error) smerge-refine] 6 (#$ . 8769) "p"])
(put 'smerge-prev 'definition-name 'smerge)
(defconst smerge-match-names ["conflict" "upper" "base" "lower"])
#@10 

(fn N)
(defalias 'smerge-ensure-match #[257 "\211\225?\205\f\301\302H\"\207" [smerge-match-names error "No `%s'"] 5 (#$ . 9321)])
(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])
#@27 Concatenate all versions.
(defalias 'smerge-keep-all #[0 "\300 \210\301\224\206	d\301\225\206e\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 (#$ . 9689) nil])
#@10 

(fn N)
(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 (#$ . 10001)])
#@49 Combine the current conflict with the next one.
(defalias 'smerge-combine-with-next #[0 "\301 \210\302\303\211\203 \211@\211\225\205\304\225\305\"B\262A\266\202\202\210\306\307\"\262\211\310Hb\210\311\302\305#\204:\312\313!\202\274\301 \210\314\315\316 \"\317\211\203d\211@H\203]Hb\210\320p\310H@#\210A\266\202\202C\210\310H@|\210\321\211\203\226\211@\322!\210H\203\217\211\225\203\217Hb\210\320p\224\225#\210A\266\202\202m\210\211@A@|\210\211\211\203\265\211@\211\203\256\211\302\211\223\210A\266\202\202\237\210\323\324\"\262\207" [smerge-begin-re 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)"]] 8 (#$ . 10156) nil])
#@64 Max number of lines between conflicts that should be combined.
(defvar smerge-auto-combine-max-separation 2 (#$ . 11085))
#@59 Automatically combine conflicts that are near each other.
(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 (#$ . 11213) 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] (#$ . 11538))
(defvar smerge-text-properties '(help-echo "merge conflict: mouse-3 shows a menu" keymap (keymap (down-mouse-3 . smerge-popup-context-menu))))
#@16 

(fn BEG END)
(defalias 'smerge-remove-props #[514 "\303\304\305$\210\303\304\306$\210\307 \310\211\310\311\312\313\314\315!\316\"\317$\216\320\321#,\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks remove-overlays smerge refine conflict buffer-modified-p t make-byte-code 0 "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] 2 remove-text-properties (fontified nil)] 10 (#$ . 12013)])
#@62 Pop up the Smerge mode context menu under mouse.

(fn EVENT)
(defalias 'smerge-popup-context-menu #[257 "\203P\212\306\307!!\210\310\311!)\203P\306\307!!\210\312 \210\313 \314C\315X\203+\316	!\202O\211\317\224\225\"\240\210\320\315\321\322\323!\324\"\325$\216\326\242\327\330#\210\331\315!\210\316\n!)\207\212\332\314\333#\334\f\314\333#\335\206ae\206fd\"\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 make-byte-code "\301\300\242!\207" vconcat vector [delete-overlay] 2 overlay-put face highlight sit-for re-search-backward t re-search-forward smerge-remove-props] 9 (#$ . 12458) "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 "\300pb\210`\301\\\302 {\205b\210\303y\210`\301\\\302 {b\210\303y\210`\301\\\302 {\304\n\n\"\210	|\210	|\210	\262ZZ\262b\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\210Zy\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 (#$ . 13262)])
(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$\216\322\323\237\"\210eb\210\324\301\303#\203d\325\307!\210\202U\326 *\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*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 apply insert re-search-forward replace-match buffer-string] 11 (#$ . 14565)])
#@16 

(fn BEG END)
(defalias 'smerge-resolve--normalize #[514 "\301\302\211\303\"\302Q#\207" [smerge-resolve--normalize-re replace-regexp-in-string " " buffer-substring-no-properties] 9 (#$ . 15306)])
#@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 "\306 \210\307\310\224\310\225\"\210\311 \310\224\312\224\313\224\314\224\310\225\312\225\313\225\314\225\315\316!\317C\317C\317C\317\320\310\321\322\323				$\324\"\313$\216\312\225\314\225=\203P\312\224\314\224=\203P\325\314!\210\202\3261\220\327 \317\211\317C\320\310\330\322\323	\"\331\"\313$\216\332!\210\203\201\f!\210\202\204\f \210\333\333\240\210,\266\2050\202\224\210\202\227\204=\203\263\n=\203\263\334!\210\325\314!\210\202\335\n\"\336\337!\240\210\340
\n\242\317\341%\210\336\342!\240\210\340\242\317\341%\210\f	=\206\n=\206\343
\317\317\344\242\242&\310U\204\203=?\206rq\210eb\210\345\346\347!\350Q!)?\262\2036\351
\n&\210\202\203t\336\352!\240\210\340\242\317\341%\210rq\210\353 \210)\343
\317\317\354\242\n\242&\310U\203t\334!\210\325\314!\210\202\204\301\203\301\242\203\301\n=\204\301rq\210\355ed\356\333\317\211\357>\360\361\f\242&\310U)\203\301\214\f	}\210\307
\n\"\210\362\242\317\211\211\333%\210)\202\204)\203)\242\203)\n=\204)\340\n\242\317\341%\210\343
\317\317\354\242\242&\210rq\210\355ed\356\333\317\211\357>\360\361\242&\310U)\203)\214\f	}\210\307
\n\"\210\362\242\317\211\211\333%\210)\202\203\220\363\f	\"\203\220\363\"\203\220\363\n\"\203\220\364\f	\"\364\f	\"\364\f	\"\232\203n\232\204n\314\211\262\202\232?\205\232\205\312\211\262\266\203\203\220\334!\210\325!\210\202\212\205\364\365\366!8\205\364\367?\317\333#?\205\364\370\366!8b\210\371\312!\210`	V\205\364\372\f	\"\372\f	\"\372\f	\"\232\203\341\232\204\341\314\211\262\202\362\232?\205\362\232\205\362\312\211\262\266\203)\203\334!\210\325!\210\202\373\374!\210)\266\375 \207" [most-positive-fixnum undo-strong-limit undo-limit undo-outer-limit smerge-resolve-function diff-command smerge-match-conflict smerge-remove-props 0 match-data 1 2 3 generate-new-buffer " *smerge*" nil make-byte-code "\304\300!\203\n\305\300!\210\301\242\203\306\301\242!\210\302\242\203\306\302\242!\210\303\242\205'\306\303\242!\207" vconcat vector [buffer-name kill-buffer delete-file] smerge-keep-n (error) prepare-change-group "\301\242\203	\302\300!\207\303\300!\207" [accept-change-group cancel-change-group] activate-change-group t set-match-data count-lines make-temp-file "smm" write-region silent "smo" call-process "-b" looking-at "1," number-to-string "c" smerge-apply-resolution-patch "smb" erase-buffer "-bc" call-process-region "patch" "-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 null-device smerge-begin-re] 27 (#$ . 15515) nil])
#@48 Perform automatic resolution on all conflicts.
(defalias 'smerge-resolve-all #[0 "\212eb\210\301\302\303#\205\"\3041\305 \210\306\307!0\202\210\202\210\202)\207" [smerge-begin-re re-search-forward nil t (error) smerge-match-conflict smerge-resolve safe] 4 (#$ . 18637) nil])
(defalias 'smerge-batch-resolve #[0 "\204\302\303!\210	\205@	\211A\242\304\305\"\203 \306\307\211\224#\262\310\311\"\210\312!\203<r\313!q\210\314 \210\315 \210\316p!\210)\210\202\207" [noninteractive command-line-args-left error "`smerge-batch-resolve' is to be used only with -batch" string-match "\\.rej\\'" substring 0 message "Resolving conflicts in %s..." file-readable-p find-file-noselect smerge-resolve-all save-buffer kill-buffer] 5])
#@29 Revert to the base version.
(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 (#$ . 19387) nil])
#@138 Keep the "lower" version of a merge conflict.
In a conflict that looks like:
  <<<<<<<
  UUU
  =======
  LLL
  >>>>>>>
this keeps "LLL".
(defalias 'smerge-keep-lower #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 3 smerge-auto-leave] 2 (#$ . 19600) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-keep-other smerge-keep-lower nil make-obsolete "26.1"] 4)
#@138 Keep the "upper" version of a merge conflict.
In a conflict that looks like:
  <<<<<<<
  UUU
  =======
  LLL
  >>>>>>>
this keeps "UUU".
(defalias 'smerge-keep-upper #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 1 smerge-auto-leave] 2 (#$ . 20021) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-keep-mine smerge-keep-upper nil make-obsolete "26.1"] 4)
(defalias 'smerge-get-current #[0 "\300\211\225\203`\224W\204`\225V\203\211S\262\202\211\207" [3] 3])
#@45 Use the current (under the cursor) version.
(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 (#$ . 20553) nil])
#@48 Remove the current (under the cursor) version.
(defalias 'smerge-kill-current #[0 "\300 \210\301 \211\302X\203\303\304!\202Q\305\306\211\2032\211@\211\225\203+\211\225\225U\204+\211B\262A\266\202\202\210\211A\203H\211@\225A@\225U\204H\307 \202O\310@!\210\311 \262\207" [smerge-match-conflict smerge-get-current 0 error "Not inside a version" nil (3 2 1) ding smerge-keep-n smerge-auto-leave] 6 (#$ . 20831) nil])
#@61 Diff `base' and `upper' version in current conflict region.
(defalias 'smerge-diff-base-upper #[0 "\300\301\302\"\207" [smerge-diff 2 1] 3 (#$ . 21268) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-diff-base-mine smerge-diff-base-upper nil make-obsolete "26.1"] 4)
#@61 Diff `base' and `lower' version in current conflict region.
(defalias 'smerge-diff-base-lower #[0 "\300\301\302\"\207" [smerge-diff 2 3] 3 (#$ . 21572) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-diff-base-other smerge-diff-base-lower nil make-obsolete "26.1"] 4)
#@62 Diff `upper' and `lower' version in current conflict region.
(defalias 'smerge-diff-upper-lower #[0 "\300\301\302\"\207" [smerge-diff 1 3] 3 (#$ . 21877) nil])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-diff-mine-other smerge-diff-upper-lower nil make-obsolete "26.1"] 4)
#@255 Get info about the conflict.  Puts the info in the `match-data'.
The submatches contain:
 0:  the whole conflict.
 1:  upper version of the code.
 2:  base version of the code.
 3:  lower version of the code.
An error is raised if not inside a conflict.
(defalias 'smerge-match-conflict #[0 "\212\3061\320`\307y\310!\311\224\311\225\312\307!\206\313\314	!\311\225W\205&\315\316C\"\311\224\311\225\310\n\"\311\224\311\225\317\211\212\nb\210\314\320#)\203K\321\322!\210\202\245\310
\320#\203h\323\304!\210\324\262\311\224\262\311\225\262\202\245	\325
\206p\313!\230\203~\323\304!\210\326\202\245\204\245\f\324=\204\227	\327\232\204\227\330\331\"\203\245\n\262\262\262\262\332\f
	\n\205\276\nS
S\257\f!\210\320\266\2170\202\324\210\333\334!)\207" [smerge-begin-re smerge-end-re smerge-lower-re smerge-base-re smerge-conflict-style buffer-file-name (search-failed) 1 re-search-backward 0 match-string "" re-search-forward signal search-failed 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 user-error "Point not in conflict region"] 28 (#$ . 22186)])
#@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 (#$ . 23418)])
#@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 "\302`\302\204D\303!\211\262\203D\30414\305!b\210\306 \210\307\225b\210`X\203,\310\311!\2020\312\211\2620\202@\210\313\305!\314!\"\210b\210\202\204\257\315\312#\203\257\3161\247\306 \210\307\225b\210\303`S!\211\203n\317\307\224\307\225#\210\202\236\320\307\224\307\225\302\321\302%\262\322\323\312#\210\322\324\325#\210	\211\203\235\322\211A\262\242\211A\262\242#\210\202\206\210\210\312\211\2620\202\253\210\202D\210\202D\207" [smerge-begin-re smerge-text-properties nil smerge-conflict-overlay (error) overlay-start smerge-match-conflict 0 error "Matching backward!" t smerge-remove-props overlay-end re-search-forward (error) move-overlay make-overlay front-advance overlay-put evaporate smerge conflict] 11 (#$ . 23692)])
#@481 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-regions'.
  This only matters if `smerge-refine-weight-hack' is nil.
(defvar smerge-refine-forward-function 'smerge--refine-forward (#$ . 24757))
#@86 If non-nil, indicate that `smerge-refine' should try to ignore change in whitespace.
(defvar smerge-refine-ignore-whitespace t (#$ . 25320))
#@853 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.
- Is a bit more costly (may in degenerate cases use temp files that are 10x
  larger than the refined regions).
(defvar smerge-refine-weight-hack t (#$ . 25468))
#@10 

(fn N)
(defalias 'smerge--refine-forward #[257 "\303\304	\203\n\204\305\306Q\262\307\211W\2051\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 (#$ . 26376)])
#@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 "\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317!#\210\203(eb\210 \210\2033\320ed\321\322$\210eb\210m\204\263n\204B\323\324!\210`	\325!\210`Z\211\325Y\204T\323\326!\210n\204[\321c\210\n\203\256\211\325V\203\256\327`\"\330V\203\227\331\"\211\204\216\332\310\333#\334\335\336\337!\\!\340R\262\341#\210`|\210\211c\210\262S\310\211W\203\254\211c\266\211T\262\202\232\266\266\2026n\204\273\342\343!\210\344\345ed\346\347%+\207" [smerge-refine-ignore-whitespace smerge-refine-forward-function smerge-refine-weight-hack smerge--refine-long-words coding-system-for-write generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-buffer-substring marker-buffer subst-char-in-region 10 32 cl--assertion-failed (bolp) 1 (>= len 1) buffer-substring-no-properties 8 gethash substring 7 " " string 48 hash-table-count "\n" puthash error "Smerge refine internal error" utf-8-emacs-unix write-region nil nomessage] 15 (#$ . 26797)])
#@40 

(fn BEG MATCH-NUM1 MATCH-NUM2 PROPS)
(defalias 'smerge--refine-highlight-change #[1028 "r\303!q\210b\210\304!S\203\305\202	!\210`\203\"\305\202#	\203/\304!Z\2020\306!\210`\n\203H\307x\210`\262b\210\307w\210`\262\211V\205u\310\311\312\311%\313\314\315#\210\211\203q\211@\313@A#\210A\266\202\202\\\210\211\262\266\203)\207" [smerge-refine-weight-hack smerge-refine-forward-function smerge-refine-ignore-whitespace marker-buffer string-to-number forward-char 1 " 	\n" make-overlay nil front-advance overlay-put evaporate t] 14 (#$ . 28218)])
#@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-regions #[2053 "`\306\307\310!\307\311!	\205\312\313\314\"\315!\204\316!\262\315	!\204,\316	!\262	\317\320	$\210\320			$\210)\321\322\323\324\325#\326\"\327$\216\330\331!r\211q\210\321\322\332\324\325!\333\"\327$\216\334\335
\306\317\3064\203{	\204{\336\202|\337&\210)eb\210\306\211m\204\340\341!\204\233\342\343`\344 {\"\210\345\224f\346\347!\346\327!\346\350!\346\351!\352>\203\313\353\354=\203\301\206\310\206\310$\262\355>\203\354\353\354=\203\342\206\351\206\351$\262\266\347y\210\356\357\306\360#\203\211\322\224b\210\202\211	?\2050\203\361!
V\203\362\363!#\210\211\2050\361!V\2050\362\363!
#\266\202*\262+\207" [deactivate-mark smerge-refine-weight-hack smerge--refine-long-words write-region-inhibit-fsync coding-system-for-read diff-command nil make-temp-file "diff1" "diff2" make-hash-table :test equal markerp copy-marker t smerge--refine-chopup-region make-byte-code 0 "\300b\210\303\301!\210\303\302!\207" vconcat vector [delete-file] 2 generate-new-buffer " *temp*" "\301\300!\205	\302\300!\207" [buffer-name kill-buffer] utf-8-emacs call-process "-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 smerge-refine-ignore-whitespace] 25 (#$ . 28802)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias smerge-refine-subst smerge-refine-regions nil make-obsolete "26.1"] 4)
#@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\303W\204\211\304V\203\305\306\"\210\307 \210\310\311\224\311\225\312\313$\210\314\225\204+\314\202Y\303\225\304\225=\2037\303\202Y\211\250\203@\211\202Y\303\225\303\224=\203L\303\202Y\304\225\304\224=\203X\304\202Y\314\262\211\303=\203e\314\202f\303\304=\203p\314\202q\304\315\316!\205\204\317\316\320\"?\205\204\317\316\321\"?\322!\210\322!\210\323 \324\211\324\325\311\326\327\330!\331\"\314$\216\332\311\224\311\224T\333\334 	B$\210,\210\335\224\225\224\225\205\276\336\337?\205\306\340?\205\315\341&\207" [buffer-undo-list inhibit-read-only inhibit-modification-hooks 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 make-byte-code "\300?\205\301\302!\207" vconcat vector [restore-buffer-modified-p nil] put-text-property smerge-refine-part buffer-chars-modified-tick smerge-refine-regions ((smerge . refine) (font-lock-face . smerge-refined-change)) nil ((smerge . refine) (font-lock-face . smerge-refined-removed)) ((smerge . refine) (font-lock-face . smerge-refined-added))] 14 (#$ . 31372) (byte-code "\250\203C\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)])
#@229 Swap the "Upper" and the "Lower" chunks.
Can be used before things like `smerge-keep-all' or `smerge-resolve' where the
ordering can have some subtle influence on the result, such as preferring the
spacing of the "Lower" chunk.
(defalias 'smerge-swap #[0 "\300 \210\301\224b\210\302`\301\225\"\302\303\224\303\225\"c\210\303\224b\210\211c\207" [smerge-match-conflict 3 delete-and-extract-region 1] 4 (#$ . 33155) nil])
#@14 

(fn N1 N2)
(defalias 'smerge-diff #[514 "\306 \210\307!\210\307!\210HH\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$\216r\326
!q\210\327\"\330 \210\331\332#\315\327\315\333$\334 \205y\335\336Q\335\336
QF\f\fD#&\211\320=\203\212\337c\210\210)eb\210\340 \210\341p\327\"+\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 make-byte-code 0 "\302\300!\210\302\301!\207" vconcat vector [delete-file] 2 get-buffer-create t erase-buffer apply call-process append diff-check-labels "--label" "/" "No differences found.\n" diff-mode display-buffer inhibit-read-only diff-command smerge-diff-switches] 26 (#$ . 33580)])
#@23 

(fn REGEXP DEFAULT)
(defalias 'smerge--get-marker #[514 "\212eb\210\300\301\302#\203\303\225\303\224V\203\211\304\305\303!Q\202\211)\207" [search-forward-regexp nil t 1 "=" match-string-no-properties] 6 (#$ . 34518)])
#@170 Invoke ediff to resolve the conflicts.
NAME-UPPER, NAME-LOWER, and NAME-BASE, if non-nil, are used for the
buffer names.

(fn &optional NAME-UPPER NAME-LOWER NAME-BASE)
(defalias 'smerge-ediff #[768 "p\306 \307	\206\n\310!\311\206\312\313\314\n\315\"\312\260!\311\206,\312\313\314\316\"\312\260!\317rq\210\320 \210\321!\210eb\210\322 \203Q\323\224\203J\324\262\325\326!\210\202=\327 \210\330\317!\210 \210)rq\210\320 \210\321!\210eb\210\322 \203w\325\331!\210\202k\327 \210\330\317!\210 \210)\211\203\315\311\206\226\312\313\314\f\332\"\312\260!\262r\211q\210\320 \210\321!\210eb\210\322 \203\302\323\225\203\271\325\323!\210\202\250\333\224\333\225|\210\202\250\327 \210\330\317!\210 \210)\211\203\331\334#\202\335\335\"q\210\336\305!\210\336\337!\210\336\340!\210\341 \342\343!\207" [major-mode buffer-file-name smerge-begin-re smerge-end-re smerge-base-re smerge-ediff-windows current-window-configuration file-name-nondirectory "-" generate-new-buffer "*" " " smerge--get-marker "UPPER" "LOWER" 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 smerge-ediff-buf ediff-quit-hook #[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] message "Please resolve conflicts now; exit ediff when done"] 17 (#$ . 34752) 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 ">>>>>>> LOWER\n" "=======\n" "||||||| BASE\n" "<<<<<<< UPPER\n" 1 smerge-refine] 18 (#$ . 36548) (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-lower-re #1#))
#@91 Non-nil if Smerge mode is enabled.
Use the command `smerge-mode' to change this variable.
(defvar smerge-mode nil (#$ . 37424))
(make-variable-buffer-local 'smerge-mode)
#@342 Minor mode to simplify editing output from the diff3 program.

If called interactively, enable Smerge mode if ARG is positive, and
disable it if ARG is zero or negative.  If called from Lisp, also
enable the mode if ARG is omitted or nil, and toggle it if ARG is
`toggle'; disable the mode otherwise.

\{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\245\305 \203\225\211\305 \232\203\245\335\336\337\203\240\340\202\241\341#\266\210\342 \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 " in current buffer" message "Smerge mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 37601) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar smerge-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\311\211%\207" [smerge-mode-map smerge-mode-hook variable-documentation put "Hook run after entering or leaving `smerge-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode smerge-mode " SMerge" boundp nil] 6)
#@119 Turn on `smerge-mode' and move point to first conflict marker.
If no conflict maker is found, turn off `smerge-mode'.
(defalias 'smerge-start-session #[0 "\301\302!\210\3031\304!?\205\305 0\207\210\306 \207" [smerge-begin-re smerge-mode 1 (error) looking-at smerge-next smerge-auto-leave] 2 (#$ . 39428) nil])
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable smerge-change-buffer-confirm funcall function #[0 "\300\207" [t] 1] "If non-nil, request confirmation before moving to another buffer." :type boolean] 6)
#@181 Go to next conflict, possibly in another file.
First tries to go to the next conflict in the current buffer, and if not
found, uses VC to try and find the next file with conflict.
(defalias 'smerge-vc-next-conflict #[0 "p\3051\306 0\202O\210\204\307 \2034	\2034\n=\2044\f\310=\2044\311\307 \203/\312\2020\313!\202O\307 \203@	\203@\314 \210\315 \210\211p=?\205Oeb\210\306 \207" [smerge-change-buffer-confirm buffer-file-name last-command this-command last-command-event (error) smerge-next buffer-modified-p 13 message "No more conflicts here.  Repeat to save and go to next buffer" "No more conflicts here.  Repeat to go to next buffer" save-buffer vc-find-conflicted-file] 3 (#$ . 39982) nil])
(provide 'smerge-mode)
Zerion Mini Shell 1.0