ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/vc/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/vc/smerge-mode.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.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\321\322%\210\313\323\315\316\324DD\325\321\326%\210\313\327\315\316\330DD\331\321\332%\210\333\334\335\336#\210\337\340\341\334#\210\337\340\342\343\344!\206M \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" [#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-mine' 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-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#\210\304\305\306\301#\210\304\305\307\310\311!\206 \312#\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." put smerge-other-face face-alias obsolete-face purecopy "22.1" t] 5)
(defvar smerge-other-face 'smerge-other)
(byte-code "\300\301\302\303#\210\304\305\306\301#\210\304\305\307\310\311!\206 \312#\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." put smerge-base-face face-alias obsolete-face purecopy "22.1" t] 5)
(defvar smerge-base-face 'smerge-base)
(byte-code "\300\301\302\303#\210\304\305\306\301#\210\304\305\307\310\311!\206 \312#\207" [custom-declare-face smerge-markers ((((background light)) (:background "grey85")) (((background dark)) (:background "grey30"))) "Face for the conflict markers." put smerge-markers-face face-alias obsolete-face purecopy "22.1" t] 5)
(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!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) (#$ . 3981))
(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) (#$ . 4958))
(defvar smerge-check-cache nil)
(make-variable-buffer-local 'smerge-check-cache)
(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 "\n\n(fn N)"])
#@25 Menu for `smerge-mode'.
(defvar smerge-mode-menu nil (#$ . 5472))
(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 (#$ . 6905))
(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))) (#$ . 7401))
(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 (#$ . 7852))
#@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!\2031 db\210\202c \311\312\313\"\210\202c \303\224b\210p\314 =\203c \315\316!\203c \212\306\307\310\317$)\206V d\320\307\310#\204b \321\322!\210\210 \205q \3231o \324 0\207\210\307\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 called-interactively-p interactive 2 pos-visible-in-window-p recenter (0) (error) smerge-refine] 6 (#$ . 8025) "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 \205. \3131, \314 0\207\210\306\207" [smerge-begin-re diff-auto-refine-mode 1 0 smerge-next re-search-backward nil t user-error "No previous %s" "conflict" (error) smerge-refine] 6 (#$ . 8699) "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\302H\"\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])
#@27 Concatenate all versions.
(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 (#$ . 9541) 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)"])
#@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\217 Hb\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 (#$ . 9993) nil])
#@64 Max number of lines between conflicts that should be combined.
(defvar smerge-auto-combine-max-separation 2 (#$ . 10921))
#@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 (#$ . 11049) 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] (#$ . 11374))
(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 "\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 "\n\n(fn BEG END)"])
#@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\206a e\206f d\"\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 (#$ . 12279) "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 {\205 b\210\303y\210`\301\\\302 {b\210\303y\210`\301\\\302 {\304\n\n\"\210 |\210 |\210 \262 ZZ\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\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 (#$ . 13083)])
(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 (#$ . 14386)])
(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 "\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\216 \327 \317\211\317C\320\310\330\322\323 \"\331\"\313$\216\332!\210\203\201 \f!\210\202\204 \f \210\211\333\240,\266\2050\202\222 \210\202\225 \204=\203\261 \n=\203\261 \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\f \203\f =?\206 rq\210eb\210\345\346\347!\350Q!)?\262\2034\351
\n&\210\202\203r\336\352!\240\210\340 \242\317\341%\210rq\210\353 \210)\343
\317\317\354\242\n\242&\310U\203r\334!\210\325\314!\210\202\204\277\203\277\242\203\277\n=\204\277rq\210\355ed\356\333\317\211\357>\360\361\f\242& \310U)\203\277\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\216\363\f \"\203\216\363 \"\203\216\363\n\"\203\216\364\f \"\364\f \"\364\f \"\232\203l\232\204l\314\211\262\202}\232?\205}\232\205}\312\211\262\266\203\203\216\334!\210\325!\210\202\212\205\362\365\366!8\205\362\367?\317\333#?\205\362\370\366!8b\210\371\312!\210` V\205\362\372\f \"\372\f \"\372\f \"\232\203\337\232\204\337\314\211\262\202\360\232?\205\360\232\205\360\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 (#$ . 15321) 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 (#$ . 18440) nil])
(defalias 'smerge-batch-resolve #[0 "\204 \302\303!\210 \205? \211A\242\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])
#@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 (#$ . 19179) nil])
#@22 Use "other" version.
(defalias 'smerge-keep-other #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 3 smerge-auto-leave] 2 (#$ . 19391) nil])
#@20 Keep your version.
(defalias 'smerge-keep-mine #[0 "\300 \210\301\302!\210\303 \207" [smerge-match-conflict smerge-keep-n 1 smerge-auto-leave] 2 (#$ . 19564) nil])
(defalias 'smerge-get-current #[0 "\300\211\225\203 `\224W\204 `\225Y\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 (#$ . 19847) 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 (#$ . 20125) nil])
#@60 Diff `base' and `mine' version in current conflict region.
(defalias 'smerge-diff-base-mine #[0 "\300\301\302\"\207" [smerge-diff 2 1] 3 (#$ . 20562) nil])
#@61 Diff `base' and `other' version in current conflict region.
(defalias 'smerge-diff-base-other #[0 "\300\301\302\"\207" [smerge-diff 2 3] 3 (#$ . 20724) nil])
#@61 Diff `mine' and `other' version in current conflict region.
(defalias 'smerge-diff-mine-other #[0 "\300\301\302\"\207" [smerge-diff 1 3] 3 (#$ . 20888) nil])
#@213 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.
(defalias 'smerge-match-conflict #[0 "\212\3061\320 `\307y\310!\311\224\311\225\312\307!\206 \313\314 !\311\225W\204% \315\316!\210\317\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-other-re smerge-base-re smerge-conflict-style buffer-file-name (search-failed) 1 re-search-backward 0 match-string "" re-search-forward 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 user-error "Point not in conflict region"] 28 (#$ . 21053)])
#@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 (#$ . 22277)])
#@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 (#$ . 22551)])
#@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 (#$ . 23616))
#@86 If non-nil, indicate that `smerge-refine' should try to ignore change in whitespace.
(defvar smerge-refine-ignore-whitespace t (#$ . 24176))
#@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 (#$ . 24324))
(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 "\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$\216\315#\210\203& eb\210 \210\2031 \316ed\317\320$\210eb\210m\204x \321!\210\322u\210n\321u\210?\205K \323 `{`Sf\317=\204V \317c\210\n\203t \211GS\307\211W\203r \211\324\261\266\211T\262\202^ \266\210\2024 n\204\200 \325\326!\210\327\330ed\331\332%+\262\207" [smerge-refine-ignore-whitespace smerge-refine-forward-function smerge-refine-weight-hack 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 subst-char-in-region 10 32 1 -1 line-beginning-position "\n" error "Smerge refine internal error" emacs-mule write-region nil nomessage] 12 (#$ . 25622)])
(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$\216\321\322!r\211q\210\312\313\323\315\316!\324\"\320$\216\325\326\n\305\327\305 \203U \f\204U \330\202V \331&\210)eb\210\305\211m\204\340 \332\333!\204u \334\335`\336 {\"\210\337\224f\340\341!\340\320!\340\342!\340\343!\344>\203\251 \345\f \346=\203\237 \206\246 \206\246 %\262\347>\203\314 \345\f \346=\203\302 \206\311 \206\311 %\262\266\341y\210\350\351\305\352#\203c \313\224b\210\202c \f?\205\203\373 \353!V\203\373 \354\355!#\210\211\205\353!\fV\205\354\355!#\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 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] 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 (#$ . 27291)])
#@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-subst ((smerge . refine) (face . smerge-refined-change)) nil ((smerge . refine) (face . smerge-refined-removed)) ((smerge . refine) (face . smerge-refined-added))] 14 (#$ . 29558) (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)])
#@228 Swap the "Mine" and the "Other" 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 "Other" 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 (#$ . 31309) nil])
(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\335 Q\334\335
Q\257\"&\211\320=\203\205 \336c\210\210)eb\210\337 \210\340p\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 "-L" "/" "No differences found.\n" diff-mode display-buffer inhibit-read-only diff-command smerge-diff-switches] 26 "\n\n(fn N1 N2)"])
(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 "\n\n(fn REGEXP DEFAULT)"])
#@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\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 "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 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 (#$ . 32843) 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\n CBBB\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 (#$ . 34636) (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 (#$ . 35511))
(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\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 (#$ . 35688) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
#@176 Hook run after entering or leaving `smerge-mode'.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar smerge-mode-hook nil (#$ . 37015))
(byte-code "\301\302\303\304\300!\205\n \305\211%\207" [smerge-mode-map 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 (#$ . 37365) nil])
(provide 'smerge-mode)
Kontol Shell Bypass