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

Chizi123
2018-11-18 21067e7cbe6d7a0f65ff5c317a96b5c337b0b3d8
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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
;;; helm-core-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
 
(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))
 
 
;;;### (autoloads nil "helm" "helm.el" (0 0 0 0))
;;; Generated autoloads from helm.el
 
(autoload 'helm-define-multi-key "helm" "\
In KEYMAP, define key sequence KEY for function list FUNCTIONS.
Each function runs sequentially for each KEY press.
If DELAY is specified, switch back to initial function of FUNCTIONS list
after DELAY seconds.
The functions in FUNCTIONS list take no args.
e.g
    (defun foo ()
      (interactive)
      (message \"Run foo\"))
    (defun bar ()
      (interactive)
      (message \"Run bar\"))
    (defun baz ()
      (interactive)
      (message \"Run baz\"))
 
\(helm-define-multi-key global-map (kbd \"<f5> q\") '(foo bar baz) 2)
 
Each time \"<f5> q\" is pressed, the next function is executed. Waiting
more than 2 seconds between key presses switches back to executing the first
function on the next hit.
 
\(fn KEYMAP KEY FUNCTIONS &optional DELAY)" nil nil)
 
(autoload 'helm-multi-key-defun "helm" "\
Define NAME as a multi-key command running FUNS.
After DELAY seconds, the FUNS list is reinitialized.
See `helm-define-multi-key'.
 
\(fn NAME DOCSTRING FUNS &optional DELAY)" nil t)
 
(function-put 'helm-multi-key-defun 'lisp-indent-function '2)
 
(autoload 'helm-define-key-with-subkeys "helm" "\
Defines in MAP a KEY and SUBKEY to COMMAND.
 
This allows typing KEY to call COMMAND the first time and
type only SUBKEY on subsequent calls.
 
Arg MAP is the keymap to use, SUBKEY is the initial short key-binding to
call COMMAND.
 
Arg OTHER-SUBKEYS is an alist specifying other short key-bindings
to use once started e.g:
 
    (helm-define-key-with-subkeys global-map
       (kbd \"C-x v n\") ?n 'git-gutter:next-hunk '((?p . git-gutter:previous-hunk)))
 
 
In this example, `C-x v n' will run `git-gutter:next-hunk'
subsequent \"n\"'s run this command again
and subsequent \"p\"'s run `git-gutter:previous-hunk'.
 
If specified PROMPT can be displayed in minibuffer to
describe SUBKEY and OTHER-SUBKEYS.
Arg EXIT-FN specifies a function to run on exit.
 
For any other keys pressed, run their assigned command as defined
in MAP and then exit the loop running EXIT-FN, if specified.
 
NOTE: SUBKEY and OTHER-SUBKEYS bindings support only char syntax and
vectors, so don't use strings to define them.
 
\(fn MAP KEY SUBKEY COMMAND &optional OTHER-SUBKEYS PROMPT EXIT-FN)" nil nil)
 
(function-put 'helm-define-key-with-subkeys 'lisp-indent-function '1)
 
(autoload 'helm-debug-open-last-log "helm" "\
Open helm log file or buffer of last helm session.
 
\(fn)" t nil)
 
(autoload 'helm "helm" "\
Main function to execute helm sources.
 
PLIST is a list like
 
\(:key1 val1 :key2 val2 ...)
 
 or
 
\(&optional sources input prompt resume preselect
            buffer keymap default history allow-nest).
 
** Keywords
 
Keywords supported:
 
- :sources
- :input
- :prompt
- :resume
- :preselect
- :buffer
- :keymap
- :default
- :history
- :allow-nest
 
Extra LOCAL-VARS keywords are supported, see the \"** Other
keywords\" section below.
 
Basic keywords are the following:
 
*** :sources
 
One of the following:
 
- List of sources
- Symbol whose value is a list of sources
- Alist representing a Helm source.
  - In this case the source has no name and is referenced in
    `helm-sources' as a whole alist.
 
*** :input
 
Initial input of minibuffer (temporary value of `helm-pattern')
 
*** :prompt
 
Minibuffer prompt. Default value is `helm--prompt'.
 
*** :resume
 
If t, allow resumption of the previous session of this Helm
command, skipping initialization.
 
If 'noresume, this instance of `helm' cannot be resumed.
 
*** :preselect
 
Initially selected candidate (string or regexp).
 
*** :buffer
 
Buffer name for this Helm session. `helm-buffer' will take this value.
 
*** :keymap
 
\[Obsolete]
 
Keymap used at the start of this Helm session.
 
It is overridden by keymaps specified in sources, and is kept
only for backward compatibility.
 
Keymaps should be specified in sources using the :keymap slot
instead. See `helm-source'.
 
This keymap is not restored by `helm-resume'.
 
*** :default
 
Default value inserted into the minibuffer with
\\<minibuffer-local-map>\\[next-history-element].
 
It can be a string or a list of strings, in this case
\\<minibuffer-local-map>\\[next-history-element] cycles through
the list items, starting with the first.
 
If nil, `thing-at-point' is used.
 
If `helm--maybe-use-default-as-input' is non-`nil', display is
updated using this value, unless :input is specified, in which
case that value is used instead.
 
*** :history
 
Minibuffer input, by default, is pushed to `minibuffer-history'.
 
When an argument HISTORY is provided, input is pushed to
HISTORY. HISTORY should be a valid symbol.
 
*** :allow-nest
 
Allow running this Helm command in a running Helm session.
 
** Other keywords
 
Other keywords are interpreted as local variables of this Helm
session. The `helm-' prefix can be omitted. For example,
 
\(helm :sources 'helm-source-buffers-list
       :buffer \"*helm buffers*\"
       :candidate-number-limit 10)
 
starts a Helm session with the variable
`helm-candidate-number-limit' set to 10.
 
** Backward compatibility
 
For backward compatibility, positional parameters are
supported:
 
\(helm sources input prompt resume preselect
       buffer keymap default history allow-nest)
 
However, the use of non-keyword args is deprecated.
 
\(fn &key SOURCES INPUT PROMPT RESUME PRESELECT BUFFER KEYMAP DEFAULT HISTORY ALLOW-NEST OTHER-LOCAL-VARS)" nil nil)
 
(autoload 'helm-cycle-resume "helm" "\
Cycle in `helm-buffers' list and resume when waiting more than 1.2s.
 
\(fn)" t nil)
 
(autoload 'helm-other-buffer "helm" "\
Simplified `helm' interface with other `helm-buffer'.
Call `helm' only with ANY-SOURCES and ANY-BUFFER as args.
 
\(fn ANY-SOURCES ANY-BUFFER)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "helm" '("helm-" "with-helm-")))
 
;;;***
 
;;;### (autoloads nil "helm-lib" "helm-lib.el" (0 0 0 0))
;;; Generated autoloads from helm-lib.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "helm-lib" '("helm-" "with-helm-")))
 
;;;***
 
;;;### (autoloads nil "helm-multi-match" "helm-multi-match.el" (0
;;;;;;  0 0 0))
;;; Generated autoloads from helm-multi-match.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "helm-multi-match" '("helm-m")))
 
;;;***
 
;;;### (autoloads nil "helm-source" "helm-source.el" (0 0 0 0))
;;; Generated autoloads from helm-source.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "helm-source" '("helm-")))
 
;;;***
 
;;;### (autoloads nil nil ("helm-core-pkg.el") (0 0 0 0))
 
;;;***
 
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; helm-core-autoloads.el ends here