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

Chizi123
2018-11-17 5cb5f70b1872a757e93ea333b0e2dca50c6c8957
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
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
;;; company-autoloads.el --- automatically extracted autoloads
;;
;;; Code:
 
(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))
 
 
;;;### (autoloads nil "company" "company.el" (0 0 0 0))
;;; Generated autoloads from company.el
 
(autoload 'company-mode "company" "\
\"complete anything\"; is an in-buffer completion framework.
Completion starts automatically, depending on the values
`company-idle-delay' and `company-minimum-prefix-length'.
 
Completion can be controlled with the commands:
`company-complete-common', `company-complete-selection', `company-complete',
`company-select-next', `company-select-previous'.  If these commands are
called before `company-idle-delay', completion will also start.
 
Completions can be searched with `company-search-candidates' or
`company-filter-candidates'.  These can be used while completion is
inactive, as well.
 
The completion data is retrieved using `company-backends' and displayed
using `company-frontends'.  If you want to start a specific backend, call
it interactively or use `company-begin-backend'.
 
By default, the completions list is sorted alphabetically, unless the
backend chooses otherwise, or `company-transformers' changes it later.
 
regular keymap (`company-mode-map'):
 
\\{company-mode-map}
keymap during active completions (`company-active-map'):
 
\\{company-active-map}
 
\(fn &optional ARG)" t nil)
 
(defvar global-company-mode nil "\
Non-nil if Global Company mode is enabled.
See the `global-company-mode' command
for a description of this minor mode.
Setting this variable directly does not take effect;
either customize it (see the info node `Easy Customization')
or call the function `global-company-mode'.")
 
(custom-autoload 'global-company-mode "company" nil)
 
(autoload 'global-company-mode "company" "\
Toggle Company mode in all buffers.
With prefix ARG, enable Global Company mode if ARG is positive;
otherwise, disable it.  If called from Lisp, enable the mode if
ARG is omitted or nil.
 
Company mode is enabled in all buffers where
`company-mode-on' would do it.
See `company-mode' for more information on Company mode.
 
\(fn &optional ARG)" t nil)
 
(autoload 'company-manual-begin "company" "\
 
 
\(fn)" t nil)
 
(autoload 'company-complete "company" "\
Insert the common part of all candidates or the current selection.
The first time this is called, the common part is inserted, the second
time, or when the selection has been changed, the selected candidate is
inserted.
 
\(fn)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company" '("company-")))
 
;;;***
 
;;;### (autoloads nil "company-abbrev" "company-abbrev.el" (0 0 0
;;;;;;  0))
;;; Generated autoloads from company-abbrev.el
 
(autoload 'company-abbrev "company-abbrev" "\
`company-mode' completion backend for abbrev.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-abbrev" '("company-abbrev-insert")))
 
;;;***
 
;;;### (autoloads nil "company-bbdb" "company-bbdb.el" (0 0 0 0))
;;; Generated autoloads from company-bbdb.el
 
(autoload 'company-bbdb "company-bbdb" "\
`company-mode' completion backend for BBDB.
 
\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-bbdb" '("company-bbdb-")))
 
;;;***
 
;;;### (autoloads nil "company-capf" "company-capf.el" (0 0 0 0))
;;; Generated autoloads from company-capf.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-capf" '("company-")))
 
;;;***
 
;;;### (autoloads nil "company-clang" "company-clang.el" (0 0 0 0))
;;; Generated autoloads from company-clang.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-clang" '("company-clang")))
 
;;;***
 
;;;### (autoloads nil "company-cmake" "company-cmake.el" (0 0 0 0))
;;; Generated autoloads from company-cmake.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-cmake" '("company-cmake")))
 
;;;***
 
;;;### (autoloads nil "company-css" "company-css.el" (0 0 0 0))
;;; Generated autoloads from company-css.el
 
(autoload 'company-css "company-css" "\
`company-mode' completion backend for `css-mode'.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-css" '("company-css-")))
 
;;;***
 
;;;### (autoloads nil "company-dabbrev" "company-dabbrev.el" (0 0
;;;;;;  0 0))
;;; Generated autoloads from company-dabbrev.el
 
(autoload 'company-dabbrev "company-dabbrev" "\
dabbrev-like `company-mode' completion backend.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-dabbrev" '("company-dabbrev-")))
 
;;;***
 
;;;### (autoloads nil "company-dabbrev-code" "company-dabbrev-code.el"
;;;;;;  (0 0 0 0))
;;; Generated autoloads from company-dabbrev-code.el
 
(autoload 'company-dabbrev-code "company-dabbrev-code" "\
dabbrev-like `company-mode' backend for code.
The backend looks for all symbols in the current buffer that aren't in
comments or strings.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-dabbrev-code" '("company-dabbrev-code-")))
 
;;;***
 
;;;### (autoloads nil "company-eclim" "company-eclim.el" (0 0 0 0))
;;; Generated autoloads from company-eclim.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-eclim" '("company-eclim")))
 
;;;***
 
;;;### (autoloads nil "company-elisp" "company-elisp.el" (0 0 0 0))
;;; Generated autoloads from company-elisp.el
 
(autoload 'company-elisp "company-elisp" "\
`company-mode' completion backend for Emacs Lisp.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-elisp" '("company-elisp-")))
 
;;;***
 
;;;### (autoloads nil "company-etags" "company-etags.el" (0 0 0 0))
;;; Generated autoloads from company-etags.el
 
(autoload 'company-etags "company-etags" "\
`company-mode' completion backend for etags.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-etags" '("company-etags-")))
 
;;;***
 
;;;### (autoloads nil "company-files" "company-files.el" (0 0 0 0))
;;; Generated autoloads from company-files.el
 
(autoload 'company-files "company-files" "\
`company-mode' completion backend existing file names.
Completions works for proper absolute and relative files paths.
File paths with spaces are only supported inside strings.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-files" '("company-file")))
 
;;;***
 
;;;### (autoloads nil "company-gtags" "company-gtags.el" (0 0 0 0))
;;; Generated autoloads from company-gtags.el
 
(autoload 'company-gtags "company-gtags" "\
`company-mode' completion backend for GNU Global.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-gtags" '("company-gtags-")))
 
;;;***
 
;;;### (autoloads nil "company-ispell" "company-ispell.el" (0 0 0
;;;;;;  0))
;;; Generated autoloads from company-ispell.el
 
(autoload 'company-ispell "company-ispell" "\
`company-mode' completion backend using Ispell.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-ispell" '("company-ispell-")))
 
;;;***
 
;;;### (autoloads nil "company-keywords" "company-keywords.el" (0
;;;;;;  0 0 0))
;;; Generated autoloads from company-keywords.el
 
(autoload 'company-keywords "company-keywords" "\
`company-mode' backend for programming language keywords.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-keywords" '("company-keywords-")))
 
;;;***
 
;;;### (autoloads nil "company-nxml" "company-nxml.el" (0 0 0 0))
;;; Generated autoloads from company-nxml.el
 
(autoload 'company-nxml "company-nxml" "\
`company-mode' completion backend for `nxml-mode'.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-nxml" '("company-nxml-")))
 
;;;***
 
;;;### (autoloads nil "company-oddmuse" "company-oddmuse.el" (0 0
;;;;;;  0 0))
;;; Generated autoloads from company-oddmuse.el
 
(autoload 'company-oddmuse "company-oddmuse" "\
`company-mode' completion backend for `oddmuse-mode'.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-oddmuse" '("company-oddmuse-")))
 
;;;***
 
;;;### (autoloads nil "company-semantic" "company-semantic.el" (0
;;;;;;  0 0 0))
;;; Generated autoloads from company-semantic.el
 
(autoload 'company-semantic "company-semantic" "\
`company-mode' completion backend using CEDET Semantic.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-semantic" '("company-semantic-")))
 
;;;***
 
;;;### (autoloads nil "company-template" "company-template.el" (0
;;;;;;  0 0 0))
;;; Generated autoloads from company-template.el
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-template" '("company-template-")))
 
;;;***
 
;;;### (autoloads nil "company-tempo" "company-tempo.el" (0 0 0 0))
;;; Generated autoloads from company-tempo.el
 
(autoload 'company-tempo "company-tempo" "\
`company-mode' completion backend for tempo.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-tempo" '("company-tempo-")))
 
;;;***
 
;;;### (autoloads nil "company-tng" "company-tng.el" (0 0 0 0))
;;; Generated autoloads from company-tng.el
 
(autoload 'company-tng-frontend "company-tng" "\
When the user changes the selection at least once, this
frontend will display the candidate in the buffer as if it's
already there and any key outside of `company-active-map' will
confirm the selection and finish the completion.
 
\(fn COMMAND)" nil nil)
 
(autoload 'company-tng-configure-default "company-tng" "\
Applies the default configuration to enable company-tng.
 
\(fn)" nil nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-tng" '("company-tng--")))
 
;;;***
 
;;;### (autoloads nil "company-xcode" "company-xcode.el" (0 0 0 0))
;;; Generated autoloads from company-xcode.el
 
(autoload 'company-xcode "company-xcode" "\
`company-mode' completion backend for Xcode projects.
 
\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-xcode" '("company-xcode-")))
 
;;;***
 
;;;### (autoloads nil "company-yasnippet" "company-yasnippet.el"
;;;;;;  (0 0 0 0))
;;; Generated autoloads from company-yasnippet.el
 
(autoload 'company-yasnippet "company-yasnippet" "\
`company-mode' backend for `yasnippet'.
 
This backend should be used with care, because as long as there are
snippets defined for the current major mode, this backend will always
shadow backends that come after it.  Recommended usages:
 
* In a buffer-local value of `company-backends', grouped with a backend or
  several that provide actual text completions.
 
  (add-hook 'js-mode-hook
            (lambda ()
              (set (make-local-variable 'company-backends)
                   '((company-dabbrev-code company-yasnippet)))))
 
* After keyword `:with', grouped with other backends.
 
  (push '(company-semantic :with company-yasnippet) company-backends)
 
* Not in `company-backends', just bound to a key.
 
  (global-set-key (kbd \"C-c y\") 'company-yasnippet)
 
\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
 
(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "company-yasnippet" '("company-yasnippet--")))
 
;;;***
 
;;;### (autoloads nil nil ("company-pkg.el") (0 0 0 0))
 
;;;***
 
;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; company-autoloads.el ends here