mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-18 9d27fc972e84736015ab3b1c331888a8fe3d1276
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
;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)