.emacs.d.git - Gitblit

;ELC
;;; Compiled
;;; in Emacs version 26.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%\210\311\312\313\314\315DD\316\317\320\307\304&\207" [require cl-lib helm-lib custom-declare-group helm-multi-match nil "Helm multi match." :group helm custom-declare-variable helm-mm-matching-method funcall function #[0 "\300\207" [multi3] 1] "Matching method for helm match plugin.\nYou can set here different methods to match candidates in helm.\nHere are the possible value of this symbol and their meaning:\n- multi1: Respect order, prefix of pattern must match.\n- multi2: Same but with partial match.\n- multi3: The best, multiple regexp match, allow negation.\n- multi3p: Same but prefix must match.\n\nDefault is multi3, you should keep this for a better experience.\n\nNote that multi1 and multi3p are incompatible with fuzzy matching\nin file completion and by the way fuzzy matching will be disabled there\nwhen these options are used." :type (radio :tag "Matching methods for helm" (const :tag "Multiple regexp 1 ordered with prefix match" multi1) (const :tag "Multiple regexp 2 ordered with partial match" multi2) (const :tag "Multiple regexp 3 matching no order, partial, best." multi3) (const :tag "Multiple regexp 3p matching with prefix match" multi3p))] 8)
(defvar helm-mm-default-match-functions '(helm-mm-exact-match helm-mm-match))
(defvar helm-mm-default-search-functions '(helm-mm-exact-search helm-mm-search))
#@60 Regexp to represent space itself in multiple regexp match.
(defconst helm-mm-space-regexp "\\s\\\\s-" (#$ . 1807))
#@313 Split PATTERN if it contain spaces and return resulting list.
If spaces in PATTERN are escaped, don't split at this place.
i.e "foo bar baz"=> ("foo" "bar" "baz")
but "foo\ bar baz"=> ("foo\s-bar" "baz").
If GREP-SPACE is used translate escaped space to "\s" instead of "\s-".
 
(fn PATTERN &optional GREP-SPACE)
(defalias 'helm-mm-split-pattern #[513 "\301\302\203\303\202\f\304\305\306%!\207" [helm-mm-space-regexp split-string replace-regexp-in-string "\\s" "\\s-" nil t] 9 (#$ . 1929)])
#@52 Replace spaces in PATTERN with ".*".
 
(fn PATTERN)
(defalias 'helm-mm-1-make-regexp #[257 "\300\301\302!\303#\207" [mapconcat identity helm-mm-split-pattern ".*"] 5 (#$ . 2431)])
(defvar helm-mm-exact-pattern-str nil)
(defvar helm-mm-exact-pattern-real nil)
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-exact-get-pattern #[257 "\211\232\204 \211\302\302Q    \207" [helm-mm-exact-pattern-str helm-mm-exact-pattern-real "\n"] 4 (#$ . 2696)])
#@45 
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-exact-match #[385 "\211\203 \211A\262\242\202\203\302\303\304\305G\\D\"\210    \203.\227\262\211\227\262\230\2021\230\207" [helm-pattern case-fold-search signal wrong-number-of-arguments helm-mm-exact-match 2] 8 (#$ . 2875)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-exact-search #[385 "\300\301!\302\303#\205\f\304y\207" [search-forward helm-mm-exact-get-pattern nil t -1] 6 (#$ . 3186)])
(defvar helm-mm-prefix-pattern-str nil)
(defvar helm-mm-prefix-pattern-real nil)
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-prefix-get-pattern #[257 "\211\232\204\f\211\302P    \207" [helm-mm-prefix-pattern-str helm-mm-prefix-pattern-real "\n"] 3 (#$ . 3445)])
#@30 
 
(fn STR &optional PATTERN)
(defalias 'helm-mm-prefix-match #[513 "\301\302\303\206#\262\211G\211GX\205\304O\230\207" [helm-pattern replace-regexp-in-string "\\\\" "" 0] 6 (#$ . 3624)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-prefix-search #[385 "\300\301!\302\303#\207" [search-forward helm-mm-prefix-get-pattern nil t] 6 (#$ . 3828)])
(defvar helm-mm-1-pattern-str nil)
(defvar helm-mm-1-pattern-real nil)
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-1-get-pattern #[257 "\211\232\204\211\302\303!P    \207" [helm-mm-1-pattern-str helm-mm-1-pattern-real "^" helm-mm-1-make-regexp] 4 (#$ . 4064)])
#@45 
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-1-match #[385 "\211\203 \211A\262\242\202\203\301\302\303\304G\\D\"\210\305\306!\"\207" [helm-pattern signal wrong-number-of-arguments helm-mm-1-match 2 string-match helm-mm-1-get-pattern] 8 (#$ . 4253)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-1-search #[385 "\300\301!\302\303#\207" [re-search-forward helm-mm-1-get-pattern nil t] 6 (#$ . 4539)])
(defvar helm-mm-2-pattern-str nil)
(defvar helm-mm-2-pattern-real nil)
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-2-get-pattern #[257 "\211\232\204\211\302\303!P    \207" [helm-mm-2-pattern-str helm-mm-2-pattern-real "^.*" helm-mm-1-make-regexp] 4 (#$ . 4768)])
#@45 
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-2-match #[385 "\211\203 \211A\262\242\202\203\301\302\303\304G\\D\"\210\305\306!\"\207" [helm-pattern signal wrong-number-of-arguments helm-mm-2-match 2 string-match helm-mm-2-get-pattern] 8 (#$ . 4959)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-2-search #[385 "\300\301!\302\303#\207" [re-search-forward helm-mm-2-get-pattern nil t] 6 (#$ . 5245)])
(defvar helm-mm-3-pattern-str nil)
(defvar helm-mm-3-pattern-list nil)
#@197 Return `helm-mm-3-pattern-list', a list of predicate/regexp cons cells.
e.g ((identity . "foo") (identity . "bar")).
This is done only if `helm-mm-3-pattern-str' is same as PATTERN.
 
(fn PATTERN)
(defalias 'helm-mm-3-get-patterns #[257 "\211\232\204\f\211\302!    \207" [helm-mm-3-pattern-str helm-mm-3-pattern-list helm-mm-3-get-patterns-internal] 3 (#$ . 5475)])
#@106 Return a list of predicate/regexp cons cells.
e.g ((identity . "foo") (identity . "bar")).
 
(fn PATTERN)
(defalias 'helm-mm-3-get-patterns-internal #[257 "\211\300\230?\2059\301!\302\211:\2035@\262\303\304O\305\230\203'\306\304\302OB\202*\307BB\262A\262\202\f\211\237\266\203\207" ["" helm-mm-split-pattern nil 0 1 "!" not identity] 8 (#$ . 5849)])
#@564 Check if PATTERN match STR.
When PATTERN contain a space, it is splitted and matching is done
with the several resulting regexps against STR.
e.g "bar foo" will match "foobar" and "barfoo".
Argument PATTERN, a string, is transformed in a list of
cons cell with `helm-mm-3-get-patterns' if it contain a space.
e.g "foo bar"=>((identity . "foo") (identity . "bar")).
Then each predicate of cons cell(s) is called with regexp of same
cons cell against STR (a candidate).
i.e (identity (string-match "foo" "foo bar")) => t.
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-3-match #[385 "\211\203 \211A\262\242\202\203\301\302\303\304G\\D\"\210\305!\211\306\211\307:\203S@\262\211A\262\242\262\3101B\311\n\"0\202E\306\262!\211\262\203SA\262\202#\211\205X\307\266\204\262\207" [helm-pattern signal wrong-number-of-arguments helm-mm-3-match 2 helm-mm-3-get-patterns nil t (invalid-regexp) string-match] 12 (#$ . 6221)])
#@339 Try to find PATTERN in `helm-buffer' with SEARCHFN1 and SEARCHFN2.
This is the search function for `candidates-in-buffer' enabled sources.
Use the same method as `helm-mm-3-match' except it search in buffer
instead of matching on a string.
i.e (identity (re-search-forward "foo" (point-at-eol) t)) => t.
 
(fn PATTERN SEARCHFN1 SEARCHFN2)
(defalias 'helm-mm-3-search-base #[771 ";\203\300!\202\f\301\211\302\301@@\303=\203)\304 \305 D\306y\210\262\301\211\262\202*\302\203\250\3071A@A\206:\310\301\302#0\202D\301\262\203\250\304 \262\305 \262A\301\211\302:\203\212@\262\211A\262\242\262b\210\3111y\n    \302#0\202|\301\262!\211\262\203\212A\262\202T\211\205\217\302\266\204\203\241b\210\302\262\301\211\262\202\245b\210\302\204?\205\256\211\207" [helm-mm-3-get-patterns nil t not point-at-bol point-at-eol 1 (invalid-regexp) "" (invalid-regexp)] 17 (#$ . 7186)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-3-search #[385 ";\203\n\300!\262\301\302\211#\207" [helm-mm-3-get-patterns helm-mm-3-search-base re-search-forward] 6 (#$ . 8106)])
#@41 [Internal] Cache previous migemo query.
(defvar helm-mm--previous-migemo-info nil (#$ . 8296))
(byte-code "\300\301!\210\302\303\304\305\306DD\307\310\311\312\313\314\315\316\317&\207" [make-local-variable helm-mm--previous-migemo-info custom-declare-variable helm-migemo-mode funcall function #[0 "\300\207" [nil] 1] "Non-nil if Helm-Migemo mode is enabled.\nSee the `helm-migemo-mode' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `helm-migemo-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :group helm :type boolean] 12)
#@158 Enable migemo in helm.
It will be available in the sources handling it,
i.e the sources which have the slot :migemo with non--nil value.
 
(fn &optional ARG)
(defalias 'helm-migemo-mode #[256 "\300 \301\302\303=\203\304\302!?\202\305!\306V\"\210\307\310!\204%\311\312\313\314\211$\210\315\316\304\302!\2031\317\2022\320\"\210\321\322!\203\\\323\302!\210\300 \203J\211\300 \232\203\\\324\325\326\304\302!\203W\327\202X\330#\266\210\331 \210\304\302!\207" [current-message set-default helm-migemo-mode toggle default-value prefix-numeric-value 0 featurep migemo cl--assertion-failed (featurep 'migemo) "No feature called migemo found, install migemo.el." nil run-hooks helm-migemo-mode-hook helm-migemo-mode-on-hook helm-migemo-mode-off-hook called-interactively-p any customize-mark-as-set "" message "Helm-Migemo mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 8993) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar helm-migemo-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\311\211%\207" [helm-migemo-mode-map helm-migemo-mode-hook variable-documentation put "Hook run after entering or leaving `helm-migemo-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 helm-migemo-mode " Hmio" boundp nil] 6)
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-migemo-get-pattern #[257 "\300!\3011\302\303\"\210\3040\202\210\202\203\211\305Q\202 \207" [migemo-get-pattern (error) string-match "" t "\\|"] 5 (#$ . 10392)])
#@16 
 
(fn PATTERN)
(defalias 'helm-mm-migemo-search-pattern-get #[257 "\300!\3011\302\303\"\210\3040\202\210\202\203\211\305Q\202 \207" [migemo-search-pattern-get (error) string-match "" t "\\|"] 5 (#$ . 10606)])
#@53 Migemo version of `string-match'.
 
(fn PATTERN STR)
(defalias 'helm-mm-migemo-string-match #[514 "\301\"\204r\302 q\210\303!BB\211)\304\305\"\"\207" [helm-mm--previous-migemo-info assoc helm-buffer-get helm-mm-migemo-get-pattern string-match assoc-default] 6 (#$ . 10834)])
#@45 
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-3-migemo-match #[385 "\211\203 \211A\262\242\202\203\302\303\304\305G\\D\"\210    \205R\306!\307\211\310:\203K@\262\211A\262\242\262\311    \"!\211\262\203KA\262\202&\211\205P\310\266\204\207" [helm-pattern helm-migemo-mode signal wrong-number-of-arguments helm-mm-3-migemo-match 2 helm-mm-3-get-patterns nil t helm-mm-migemo-string-match] 11 (#$ . 11126)])
#@43 
 
(fn WORD &optional BOUND NOERROR COUNT)
(defalias 'helm-mm-migemo-forward #[1025 "r\301 q\210\302\"\204$\303\304\305!\"\203\202\306!BB\211)\307\310\"$\207" [helm-mm--previous-migemo-info helm-buffer-get assoc delq ascii find-charset-string helm-mm-migemo-search-pattern-get re-search-forward assoc-default] 9 (#$ . 11575)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-3-migemo-search #[385 "\205    \301\302\211#\207" [helm-migemo-mode helm-mm-3-search-base helm-mm-migemo-forward] 6 (#$ . 11927)])
#@214 Check if PATTERN match STR.
Same as `helm-mm-3-match' but more strict, matching against prefix also.
e.g "bar foo" will match "barfoo" but not "foobar" contrarily to
`helm-mm-3-match'.
 
(fn STR &optional PATTERN)
(defalias 'helm-mm-3p-match #[513 "\301\206!\211@\211@\302A\"!\205EA\303\211\304:\203>@\262\211A\262\242\262\305\n\"!\211\262\203>A\262\202\211\205C\304\266\204\207" [helm-pattern helm-mm-3-get-patterns helm-mm-prefix-match nil t string-match] 12 (#$ . 12112)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-3p-search #[385 ";\203\n\300!\262\301\302\303#\207" [helm-mm-3-get-patterns helm-mm-3-search-base helm-mm-prefix-search re-search-forward] 6 (#$ . 12618)])
#@45 
 
(fn STR &optional (PATTERN helm-pattern))
(defalias 'helm-mm-match #[385 "\211\203 \211A\262\242\202\203\302\303\304\305G\\D\"\210\306    \307\"\203'\310\202Q\306    \311\"\2032\312\202Q\306    \313\"\203=\314\202Q\306    \315\"\203H\316\202Q\317\320    \321#\205Q\322\211\"\262\207" [helm-pattern helm-mm-matching-method signal wrong-number-of-arguments helm-mm-match 2 eql multi1 helm-mm-1-match multi2 helm-mm-2-match multi3 helm-mm-3-match multi3p helm-mm-3p-match error "cl-ecase failed: %s, %s" (multi1 multi2 multi3 multi3p) nil] 8 (#$ . 12832)])
#@29 
 
(fn PATTERN &rest IGNORE)
(defalias 'helm-mm-search #[385 "\301\302\"\203\303\2025\301\304\"\203\305\2025\301\306\"\203!\307\2025\301\310\"\203,\311\2025\312\313\314#\2055\315\211!\207" [helm-mm-matching-method eql multi1 helm-mm-1-search multi2 helm-mm-2-search multi3 helm-mm-3-search multi3p helm-mm-3p-search error "cl-ecase failed: %s, %s" (multi1 multi2 multi3 multi3p) nil] 6 (#$ . 13401)])
(provide 'helm-multi-match)