HOME

;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\302\303\304\305\304\306&\210\307\310\311\312\313\314\304\301&\210\307\315\311\316\313\314\304\301&\210\307\317\320\321\313\322\304\301&\210\307\323\324\325\313\326\304\301&\210\307\327\302\330\313\314\304\301&\210\307\331\332\333\313\326\304\301&\210\307\334\335\336\313\326\304\301&\210\307\337\302\340\313\314\304\301&\210\307\341\342\343\313\326\304\301&\210\307\344\345\346\313\347\304\301&\207" [custom-declare-group completion nil "Dynamic word-completion code." :group matching convenience custom-declare-variable enable-completion t "Non-nil means enable recording and saving of completions.\nIf nil, no new words are added to the database or saved to the init file." :type boolean save-completions-flag "Non-nil means save most-used completions when exiting Emacs.\nSee also `save-completions-retention-time'." save-completions-file-name (locate-user-emacs-file "completions" ".completions") "The filename to save completions to." file save-completions-retention-time 336 "Discard a completion if unused for this many hours.\n(1 day = 24, 1 week = 168).  If this is 0, non-permanent completions\nwill not be saved unless these are used.  Default is two weeks." integer completion-on-separator-character "Non-nil means separator characters mark previous word as used.\nThis means the word will be saved as a completion." completions-file-versions-kept kept-new-versions "Number of versions to keep for the saved completions file." completion-prompt-speed-threshold 4800 "Minimum output speed at which to display next potential completion." completion-cdabbrev-prompt-flag "If non-nil, the next completion prompt does a cdabbrev search.\nThis can be time consuming." completion-search-distance 15000 "How far to search in the buffer when looking for completions.\nIn number of characters.  If nil, search the whole buffer." completions-merging-modes '(lisp c) "List of modes {`c' or `lisp'} for automatic completions merging.\nDefinitions from visited files which have these modes\nare automatically added to the completion database." (set (const lisp) (const c))] 8)
#@104 The minimum length of a stored completion.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-min-length 6 (#$ . 2516))
#@104 The maximum length of a stored completion.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-max-length 200 (#$ . 2671))
#@111 The minimum length of a completion search string.
DON'T CHANGE WITHOUT RECOMPILING !  This is used by macros.
(defvar completion-prefix-min-length 3 (#$ . 2828))
#@110 Set to t when the completion system is initialized.
Indicates that the old completion file has been read in.
(defvar cmpl-initialized-p nil (#$ . 2997))
#@105 Set to t as soon as the first completion has been accepted.
Used to decide whether to save completions.
(defvar cmpl-completions-accepted-p nil (#$ . 3157))
#@74 Return :capitalized, :up, :down, :mixed, or :neither for case of STRING.
(defalias 'cmpl-string-case-type #[(string) "\302\303\304	\"\203+\303\305	\"\203'	G\306V\203#\303\305	\306#\204#\307\2027\310\2027\311\2027\303\305	\"\2036\312\2027\313)\207" [case-fold-search string nil string-match "[[:lower:]]" "[[:upper:]]" 1 :capitalized :mixed :down :up :neither] 4 (#$ . 3320)])
(defalias 'cmpl-coerce-string-case #[(string case-type) "\302\267\202	\227\207	\226\207	\227\211\303\304	\303H\305\"I\210	\207	\207" [case-type string #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:down 6 :up 9 :capitalized 12)) 0 logand 223] 6])
(defalias 'cmpl-merge-string-cases #[(string-to-coerce given-string) "\303!\211\304>\203\305\303\n!\"\202)\207" [string-to-coerce string-case-type given-string cmpl-string-case-type (:down :up :capitalized) cmpl-coerce-string-case] 5])
(defalias 'cmpl-hours-since-origin #[nil "\300\301 \302\"\207" [floor float-time 3600] 3])
(defconst completion-standard-syntax-table (byte-code "\306 \307\310\211\311W\203\312\313	#\210T\211\202\310\211\314W\2039\312\315\\\316	#\210\312\317\\\316	#\210T\211\202\310\211\320W\203P\312\321\\\316	#\210T\211\202<\322\323\211\307\211\203l
@\312\f\316	#\210
A\211\204\\*\n\307\211\203\205
@\312\f\324	#\210
A\211\204u,	*\207" [i table symbol-chars-ignore symbol-chars char --dolist-tail-- make-syntax-table nil 0 256 modify-syntax-entry " " 26 97 "_" 65 10 48 (64 47 92 42 43 126 36 60 62 37) (95 45 58 46) "w"] 5))
#@58 This variable holds the current completion syntax table.
(defvar completion-syntax-table completion-standard-syntax-table (#$ . 4897))
(make-variable-buffer-local 'completion-syntax-table)
#@72 Holds first character of symbol, after any completion symbol function.
(defvar cmpl-symbol-start nil (#$ . 5092))
#@71 Holds last character of symbol, after any completion symbol function.
(defvar cmpl-symbol-end nil (#$ . 5212))
#@106 Return the symbol that the point is currently on.
But only if it is longer than `completion-min-length'.
(defalias 'symbol-under-point #[nil "\306 p\307\216\310\n!\210gz\311>\205_`\312T\313\"\312\314\"\ffz\315U\2033\fb\210\316\314!\210`b\210
Sfz\315U\203H
b\210\316\313!\210`b\210
\fZX\205^
\fZX\205^\317\f
\")+\207" [#1=#:buffer #2=#:table completion-syntax-table saved-point cmpl-symbol-start cmpl-symbol-end syntax-table #[nil "rq\210\302	!)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (119 95) scan-sexps -1 1 119 forward-word-strictly buffer-substring-no-properties completion-min-length completion-max-length] 3 (#$ . 5330)])
#@125 Return a string of the symbol immediately before point.
Returns nil if there isn't one longer than `completion-min-length'.
(defalias 'symbol-before-point #[nil "\306 p\307\216\310\n!\210hz\211\311U\203?`\312\f\313\"\211fz\314U\203/
b\210\315\316!\210`\fb\210\f
\\Y\205\200\317
\f\"\202\200\314U\205\200`\312\313\"\315\313!\210`
fz\314U\203e
b\210\315\316!\210`b\210\f
ZX\205\f
ZX\205\317
\f\")+\207" [#1=#:buffer #2=#:table completion-syntax-table cmpl-preceding-syntax cmpl-symbol-end cmpl-symbol-start syntax-table #[nil "rq\210\302	!)\207" [#1# #2# set-syntax-table] 2] set-syntax-table 95 scan-sexps -1 119 forward-word-strictly 1 buffer-substring-no-properties completion-min-length saved-point completion-max-length] 4 (#$ . 5998)])
(defalias 'symbol-under-or-before-point #[nil "\303 p\304\216\305\n!\210gz+\306>\203\307 \207\310 \207" [#1=#:buffer #2=#:table completion-syntax-table syntax-table #[nil "rq\210\302	!)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (119 95) symbol-under-point symbol-before-point] 2])
(defalias 'symbol-before-point-for-complete #[nil "\306 p\307\216\310\n!\210hz\211\311>\205E`\312\f\313\"\211fz\314U\203/
b\210\315\316!\210`\fb\210\f
ZX\205E\f
ZX\205E\317
\f\"+\207" [#1=#:buffer #2=#:table completion-syntax-table cmpl-preceding-syntax cmpl-symbol-end cmpl-symbol-start syntax-table #[nil "rq\210\302	!)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (95 119) scan-sexps -1 119 forward-word-strictly 1 buffer-substring-no-properties completion-prefix-min-length completion-max-length] 4])
(defconst cmpl-source-unknown 0)
(defconst cmpl-source-init-file 1)
(defconst cmpl-source-file-parsing 2)
(defconst cmpl-source-separator 3)
(defconst cmpl-source-cursor-moves 4)
(defconst cmpl-source-interactive 5)
(defconst cmpl-source-cdabbrev 6)
(defconst num-cmpl-sources 7)
(defvar current-completion-source cmpl-source-unknown)
(defvar cdabbrev-completions-tried nil)
(defvar cdabbrev-current-point 0)
(defvar cdabbrev-current-window nil)
(defvar cdabbrev-wrapped-p nil)
(defvar cdabbrev-abbrev-string "")
(defvar cdabbrev-start-point 0)
#@142 Reset the cdabbrev search to search for ABBREV-STRING.
INITIAL-COMPLETIONS-TRIED is a list of downcased strings to ignore
during the search.
(defalias 'reset-cdabbrev #[(abbrev-string &optional initial-completions-tried) "\227\nB\304\305!\207" [abbrev-string cdabbrev-abbrev-string initial-completions-tried cdabbrev-completions-tried reset-cdabbrev-window t] 2 (#$ . 8146)])
(defalias 'set-cdabbrev-buffer #[nil "\301=\203\302 \202\303!q\207" [cdabbrev-current-window t other-buffer window-buffer] 2])
#@56 Reset the cdabbrev search to search for abbrev-string.
(defalias 'reset-cdabbrev-window #[(&optional initializep) "\203\n\306 \202&	\307=\203\310\202&	\203&\311	!\211\306 =\203&\307	\205E\212\312 \210`\211\f\203>e\fZ]\202?e\310\211)\207" [initializep cdabbrev-current-window cdabbrev-current-point cdabbrev-start-point completion-search-distance cdabbrev-stop-point selected-window t nil next-window set-cdabbrev-buffer cdabbrev-wrapped-p] 4 (#$ . 8665)])
#@159 Return the next possible cdabbrev expansion or nil if there isn't one.
`reset-cdabbrev' must've been called already.
This is sensitive to `case-fold-search'.
(defalias 'next-cdabbrev #[nil "\205\273\306\211\211\211\211\211\211\212\307\216\310 \210`\311 \312!\210b\210\313\314#\203\201hz\211\315U\204S\n\316U\205}`\317\320!\210hz\315U	b\210\205}\321 \211\205}
\227\203r\f@\230\204rA\211\204d\203|\306\211\202}\314?\202\237\204\242\203\225d\\^\202\226d\211b\210\314\211\204*
\203\257\fB`*
\206\271\322 \210\323 .\207" [cdabbrev-current-window saved-point-2 syntax tried-list downcase-expansion expansion nil #[nil "\302!\210	b\207" [saved-syntax saved-point set-syntax-table] 2] set-cdabbrev-buffer syntax-table set-syntax-table search-backward t 32 119 forward-word-strictly -1 symbol-under-point reset-cdabbrev-window next-cdabbrev saved-syntax saved-point completion-syntax-table cdabbrev-current-point cdabbrev-abbrev-string cdabbrev-stop-point cdabbrev-completions-tried cdabbrev-wrapped-p completion-search-distance cdabbrev-start-point] 8 (#$ . 9149)])
(defconst cmpl-obarray-length 511)
#@115 An obarray used to store the downcased completion prefixes.
Each symbol is bound to a list of completion entries.
(defvar cmpl-prefix-obarray (make-vector cmpl-obarray-length 0) (#$ . 10322))
#@104 An obarray used to store the downcased completions.
Each symbol is bound to a single completion entry.
(defvar cmpl-obarray (make-vector cmpl-obarray-length 0) (#$ . 10521))
(defalias 'completion-string '(macro . #[(completion-entry) "\301D\207" [completion-entry car] 2]))
(defalias 'completion-num-uses '(macro . #[(completion-entry) "\301\302DD\207" [completion-entry car cdr] 3]))
(defalias 'completion-last-use-time '(macro . #[(completion-entry) "\301\302E\207" [completion-entry nth 2] 3]))
(defalias 'completion-source '(macro . #[(completion-entry) "\301\302E\207" [completion-entry nth 3] 3]))
(defalias 'set-completion-string '(macro . #[(completion-entry string) "\302	E\207" [completion-entry string setcar] 3]))
(defalias 'set-completion-num-uses '(macro . #[(completion-entry num-uses) "\302\303D	E\207" [completion-entry num-uses setcar cdr] 3]))
(defalias 'set-completion-last-use-time '(macro . #[(completion-entry last-use-time) "\302\303\211DD	E\207" [completion-entry last-use-time setcar cdr] 4]))
#@28 Return a completion entry.
(defalias 'make-completion #[(string) "\302\303	F\207" [string current-completion-source 0 nil] 4 (#$ . 11554)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias cmpl-prefix-entry-head car cmpl-prefix-entry-tail cdr] 3)
(defalias 'set-cmpl-prefix-entry-head '(macro . #[(prefix-entry new-head) "\302	E\207" [prefix-entry new-head setcar] 3]))
(defalias 'set-cmpl-prefix-entry-tail '(macro . #[(prefix-entry new-tail) "\302	E\207" [prefix-entry new-tail setcdr] 3]))
#@59 Make a new prefix entry containing only completion-entry.
(defalias 'make-cmpl-prefix-entry #[(completion-entry-list) "\211B\207" [completion-entry-list] 2 (#$ . 12067)])
#@72 Initialize the completion storage.  All existing completions are lost.
(defalias 'clear-all-completions #[nil "\303\304\"\303\304\"\211\207" [cmpl-obarray-length cmpl-prefix-obarray cmpl-obarray make-vector 0] 3 (#$ . 12245) nil])
#@52 Return a list of all the known completion entries.
(defalias 'list-all-completions #[nil "\302\303\304	\"\210)\207" [completions-list-return-value cmpl-prefix-obarray nil mapatoms list-all-completions-1] 3 (#$ . 12486)])
(defalias 'list-all-completions-1 #[(prefix-symbol) "\302!\205\303\304J!	\"\211\207" [prefix-symbol completions-list-return-value boundp append cmpl-prefix-entry-head] 3])
#@77 Return list of lists of known completion entries, organized by hash bucket.
(defalias 'list-all-completions-by-hash-bucket #[nil "\302\303\304	\"\210)\207" [completions-list-return-value cmpl-prefix-obarray nil mapatoms list-all-completions-by-hash-bucket-1] 3 (#$ . 12892)])
(defalias 'list-all-completions-by-hash-bucket-1 #[(prefix-symbol) "\302!\205\303J!	B\211\207" [prefix-symbol completions-list-return-value boundp cmpl-prefix-entry-head] 2])
#@49 Set to a string that is pending its acceptance.
(defvar completion-to-accept nil (#$ . 13356))
#@70 Setup by `find-exact-completion', etc.  The given string, downcased.
(defvar cmpl-db-downcase-string nil (#$ . 13457))
#@93 The interned symbol corresponding to `cmpl-db-downcase-string'.
Set up by `cmpl-db-symbol'.
(defvar cmpl-db-symbol nil (#$ . 13582))
#@72 The interned prefix symbol corresponding to `cmpl-db-downcase-string'.
(defvar cmpl-db-prefix-symbol nil (#$ . 13721))
(defvar cmpl-db-entry nil)
#@45 Set to t if you want to debug the database.
(defvar cmpl-db-debug-p nil (#$ . 13873))
#@104 Return the completion entry for STRING or nil.
Sets up `cmpl-db-downcase-string' and `cmpl-db-symbol'.
(defalias 'find-exact-completion #[(string) "\304\305\227\211\n\"\211!\205J\207" [string cmpl-db-downcase-string cmpl-obarray cmpl-db-symbol boundp intern] 4 (#$ . 13966)])
#@182 Return the prefix entry for string.
Sets `cmpl-db-prefix-symbol'.
Prefix-string must be exactly `completion-prefix-min-length' long
and downcased.  Sets up `cmpl-db-prefix-symbol'.
(defalias 'find-cmpl-prefix-entry #[(prefix-string) "\303\304	\"\211!\205
\nJ\207" [prefix-string cmpl-prefix-obarray cmpl-db-prefix-symbol boundp intern] 4 (#$ . 14255)])
(defvar inside-locate-completion-entry nil)
#@184 Locate the completion entry.
Returns a pointer to the element before the completion entry or nil if
the completion entry is at the head.
Must be called after `find-exact-completion'.
(defalias 'locate-completion-entry #[(completion-entry prefix-entry) "\306!\307\211@=?\205C\n\203\"\nA\211@=\204\"	\211\204\n\206C\f\2031\310\311
\"\202C\f\203;\312 \202C
\307L\210\313!*\207" [prefix-entry next-prefix-list prefix-list completion-entry cmpl-db-debug-p cmpl--completion-string cmpl-prefix-entry-head nil error "Completion entry exists but not on prefix list - %s" locate-completion-db-error locate-completion-entry-retry inside-locate-completion-entry cmpl-db-symbol] 4 (#$ . 14662)])
(defalias 'locate-completion-entry-retry #[(old-entry) "\306\307	@	A@\310	8#\210\311	@!\211\205\312\313\fO!\n\203,
\203,\314\n
\"\202.\315 +\207" [inside-locate-completion-entry old-entry cmpl-entry cmpl-db-downcase-string completion-prefix-min-length pref-entry t add-completion 2 find-exact-completion find-cmpl-prefix-entry 0 locate-completion-entry locate-completion-db-error] 6])
(defalias 'locate-completion-db-error #[nil "\300\301!\207" [error "Completion database corrupted.  Try M-x clear-all-completions.  Send bug report"] 2])
#@303 If STRING is not in the database add it to appropriate prefix list.
STRING is added to the end of the appropriate prefix list with
num-uses = 0.  The database is unchanged if it is there.  STRING must be
longer than `completion-prefix-min-length'.
This must be very fast.
Returns the completion entry.
(defalias 'add-completion-to-tail-if-new #[(string) "\306!\206/\307!C\310	\311\nO!\203#\312!\f\241\210\f\241\210\202)
\313\f!L\210\f\f@L*\207" [string cmpl-db-downcase-string completion-prefix-min-length prefix-entry entry cmpl-db-prefix-symbol find-exact-completion make-completion find-cmpl-prefix-entry 0 cmpl-prefix-entry-tail make-cmpl-prefix-entry cmpl-db-symbol] 5 (#$ . 15920)])
#@341 If COMPLETION-STRING is not in the database, add it to prefix list.
We add COMPLETION-STRING to the head of the appropriate prefix list,
or to the head of the list.
COMPLETION-STRING must be longer than `completion-prefix-min-length'.
Updates the saved string with the supplied string.
This must be very fast.
Returns the completion entry.
(defalias 'add-completion-to-head #[(completion-string) "\n\203	\306 \210\307!\211\203O\310\f\311
O!\312\"\211A\240\210\203JA\241\204<\241\210\313!\241\210\240\210+\202\202\314!C\310\f\311
O!\203s\313!\241\210\240\210\202{\315!L\210@L*)\207" [completion-string cmpl--completion-string completion-to-accept cmpl-db-entry cmpl-db-downcase-string completion-prefix-min-length accept-completion find-exact-completion find-cmpl-prefix-entry 0 locate-completion-entry cmpl-prefix-entry-head make-completion make-cmpl-prefix-entry prefix-entry splice-ptr cmpl-ptr entry cmpl-db-prefix-symbol cmpl-db-symbol] 6 (#$ . 16627)])
#@101 Delete the completion from the database.
String must be longer than `completion-prefix-min-length'.
(defalias 'delete-completion #[(completion-string) "\n\203	\306 \210\307!\211\203N\310\f\311
O!\312\"\313L\210\203;\211AA\241\206J\241\202J\314!A\240\206J\313L*\202R\315\316\")\207" [completion-string cmpl--completion-string completion-to-accept cmpl-db-entry cmpl-db-downcase-string completion-prefix-min-length accept-completion find-exact-completion find-cmpl-prefix-entry 0 locate-completion-entry nil cmpl-prefix-entry-head error "Unknown completion `%s'" prefix-entry splice-ptr cmpl-db-symbol cmpl-db-prefix-symbol] 4 (#$ . 17656)])
(defalias 'interactive-completion-string-reader #[(prompt) "\305 \211\203\306\307	#\202\306\310	\"\311\n\"\211G\312U\203&\206%\313\f+C\207" [default prompt new-prompt cmpl-obarray read symbol-under-or-before-point format "%s (default %s): " "%s: " completing-read 0 ""] 5])
(defalias 'check-completion-length #[(string) "G	W\203\f\302\303\"\207C\207" [string completion-min-length user-error "The string `%s' is too short to be saved as a completion"] 3])
#@148 Add STRING to completion list, or move it to head of list.
The completion is altered appropriately if NUM-USES and/or LAST-USE-TIME
are specified.
(defalias 'add-completion #[(string &optional num-uses last-use-time) "\306!\210\307\310!\203	\202\n\311!\f\203A\f\240\210
\205&AA
\240*\207" [string cmpl-source-interactive current-completion-source entry num-uses last-use-time check-completion-length called-interactively-p interactive add-completion-to-head] 2 (#$ . 18811) (interactive-completion-string-reader "Completion to add")])
#@63 Add STRING if it isn't already listed, and mark it permanent.
(defalias 'add-permanent-completion #[(string) "\303\304!\203\n\202	\305\n\306\307#)\207" [cmpl-source-interactive current-completion-source string called-interactively-p interactive add-completion nil t] 4 (#$ . 19365) (interactive-completion-string-reader "Completion to add permanently")])
(defalias 'kill-completion #[(string) "\301!\210\302!\207" [string check-completion-length delete-completion] 2 nil (interactive-completion-string-reader "Completion to kill")])
#@146 Accept the pending completion in `completion-to-accept'.
This bumps num-uses.  Called by `add-completion-to-head' and
`completion-search-reset'.
(defalias 'accept-completion #[nil "	\306\306\307\f!\211A\nA@T\240\210\310\211+\207" [completion-to-accept cmpl-source-cdabbrev entry current-completion-source string cmpl-completions-accepted-p nil add-completion-to-head t] 4 (#$ . 19912)])
#@76 Add the completion symbol underneath the point into the completion buffer.
(defalias 'use-completion-under-point #[nil "\205\304 	\211\205\305!*\207" [enable-completion cmpl-source-cursor-moves current-completion-source string symbol-under-point add-completion-to-head] 3 (#$ . 20312)])
#@68 Add the completion symbol before point into the completion buffer.
(defalias 'use-completion-before-point #[nil "\205\304 	\211\205\305!*\207" [enable-completion cmpl-source-cursor-moves current-completion-source string symbol-before-point add-completion-to-head] 3 (#$ . 20613)])
#@68 Add the completion symbol before point into the completion buffer.
(defalias 'use-completion-under-or-before-point #[nil "\205\304 	\211\205\305!*\207" [enable-completion cmpl-source-cursor-moves current-completion-source string symbol-under-or-before-point add-completion-to-head] 3 (#$ . 20908)])
#@174 Add the completion symbol before point into the completion buffer.
Completions added this way will automatically be saved if
`completion-on-separator-character' is non-nil.
(defalias 'use-completion-before-separator #[nil "\205\306 	\307\211\205(\310\f!
\205(\nA@\311U\205(\nA\312\240\210\313\211\f+\207" [enable-completion cmpl-source-separator entry current-completion-source string completion-on-separator-character symbol-before-point nil add-completion-to-head 0 1 t cmpl-completions-accepted-p] 4 (#$ . 21222)])
(defvar cmpl-test-string "")
(defvar cmpl-test-regexp "")
(defvar cmpl-last-index 0)
(defvar cmpl-cdabbrev-reset-p nil)
(defvar cmpl-next-possibilities nil)
(defvar cmpl-starting-possibilities nil)
(defvar cmpl-next-possibility nil)
(defvar cmpl-tried-list nil)
#@108 Set up the for completion searching for STRING.
STRING must be longer than `completion-prefix-min-length'.
(defalias 'completion-search-reset #[(string) "\203\306 \210\307\310	\311\nO\227!!	\312	!\313P\314 \207" [completion-to-accept string completion-prefix-min-length cmpl-starting-possibilities cmpl-test-string cmpl-test-regexp accept-completion cmpl-prefix-entry-head find-cmpl-prefix-entry 0 regexp-quote "." completion-search-reset-1] 5 (#$ . 22020)])
(defalias 'completion-search-reset-1 #[nil "\306\211\307\306\211\207" [cmpl-starting-possibilities cmpl-next-possibilities cmpl-next-possibility cmpl-cdabbrev-reset-p cmpl-last-index cmpl-tried-list nil -1] 3])
#@163 Return the next completion entry.
If INDEX is out of sequence, reset and start from the top.
If there are no more entries, try cdabbrev and return only a string.
(defalias 'completion-search-next #[(index) "	T\211U\203\305\306!\210\202f\307W\203M\310 \210\311\n!\305\312!\2033T\211\307W\2033\312\202\203f	\313U\203B\n\202f\nGGZ\n\233\202f\310 \210\305\306!\203fS\211\307W\204f\312\202R\f\312\207" [index cmpl-last-index cmpl-starting-possibilities cmpl-next-possibilities cmpl-next-possibility completion-search-peek t 0 completion-search-reset-1 reverse nil -1] 3 (#$ . 22709)])
#@276 Return the next completion entry without actually moving the pointers.
Calling this again or calling `completion-search-next' results in the same
string being returned.  Depends on `case-fold-search'.
If there are no more entries, try cdabbrev and then return only a string.
(defalias 'completion-search-peek #[(use-cdabbrev) "\206@	\203,\306\n	@@\"\307=\204	A\211\204	\203,	@\211@\227B	A\207\f\205@
\204<\310\"\210\311\312 \211\207" [cmpl-next-possibility cmpl-next-possibilities cmpl-test-regexp cmpl-tried-list use-cdabbrev cmpl-cdabbrev-reset-p string-match 0 reset-cdabbrev t next-cdabbrev cmpl-test-string] 4 (#$ . 23330)])
#@68 Toggle whether or not to add new words to the completion database.
(defalias 'completion-mode #[nil "?\301\302\203
\303\202\304\"\207" [enable-completion message "Completion mode is now %s." "ON" "OFF"] 3 (#$ . 23987) nil])
(defvar cmpl-current-index 0)
(defvar cmpl-original-string nil)
(defvar cmpl-last-insert-location -1)
(defvar cmpl-leave-point-at-start nil)
#@434 Fill out a completion of the word before point.
Point is left at end.  Consecutive calls rotate through all possibilities.
Prefix args ::
  control-u :: leave the point at the beginning of the completion rather
               than at the end.
  a number  :: rotate through the possible completions by that amount
  `-'       :: same as -1 (insert previous completion)
 {See the comments at the top of `completion.el' for more info.}
(defalias 'complete #[(&optional arg) "	=\203\n`|\210\f\206\306\\\202S
\204\307 \210:\203*\310\311\202-\312\313 \211\204=\314\315\316\"\210\203F\f\202G\310\317!\210|\210 !Y\205^\320 ?\"`#\321!$\312%$\203\325$;\203{$\202~$@%\322%\"\211%c\210%&\203\235`#b\210\202\240#\"\205\371\323\310!\205\371\324'!\211$\205\371$;\203\300$\202\303$@%\322%\"%\325\326%\"\202\371c\210\312&\"\203\366\323\310!\203\366\325\327	=\203\363\330\202\364\331\"\210\314\211,\207" [last-command this-command cmpl-last-insert-location cmpl-current-index arg cmpl-initialized-p 1 completion-initialize 0 t nil symbol-before-point-for-complete failed-complete error "To complete, point must be after a symbol at least %d character long" completion-search-reset window-minibuffer-p completion-search-next cmpl-merge-string-cases sit-for completion-search-peek message "Next completion: %s" "No %scompletions." "more " "" current-prefix-arg cmpl-leave-point-at-start cmpl-original-string completion-prefix-min-length cmpl-symbol-start cmpl-symbol-end baud-rate completion-prompt-speed-threshold print-status-p insert-point entry string completion-to-accept completion-cdabbrev-prompt-flag] 5 (#$ . 24365) "*p"])
#@66 Parse possible completions from a FILE and add them to database.
(defalias 'add-completions-from-file #[(file) "\304!\305!\211\211\204\306\307!)\310\216r	q\210\311 ,\207" [file buffer buffer-already-there-p completions-merging-modes expand-file-name get-file-buffer nil find-file-noselect #[nil "?\205\302	!\207" [buffer-already-there-p buffer kill-buffer] 2] add-completions-from-buffer] 3 (#$ . 26077) "fFile: "])
(defalias 'add-completions-from-buffer #[nil "\n\303>\203
\304 \202\n\305>\203\306 \202\307\310\n\")\207" [cmpl-source-file-parsing current-completion-source major-mode (emacs-lisp-mode lisp-mode) add-completions-from-lisp-buffer (c-mode) add-completions-from-c-buffer error "Cannot parse completions in %s buffers"] 3 nil nil])
(defalias 'completion-find-file-hook #[nil "\205!	\303>\203\304\n>\203\305 \207	\306>\205!\307\n>\205!\305 \207" [enable-completion major-mode completions-merging-modes (emacs-lisp-mode lisp-mode) lisp add-completions-from-buffer (c-mode) c] 2])
#@46 Add completions from the current tags table.
(defalias 'add-completions-from-tags-table #[nil "\301 \210\212eb\210\302\3031%\304\305!\210\306u\210\307 \211\203\310!\210\311u\210\202
\210*\302\207" [string visit-tags-table-buffer nil (search-failed) search-forward "" -3 symbol-under-point add-completion-to-tail-if-new 3] 2 (#$ . 27104) nil])
#@50 A regexp that searches for Lisp definition form.
(defconst *lisp-def-regexp* "\n(\\(\\w*:\\)?def\\(\\w\\|\\s_\\)*\\s +(*" (#$ . 27461))
(defalias 'add-completions-from-lisp-buffer #[nil "\302\212eb\210\3031\304	!\210\305 \211\203\n\306!\210\202\n\210*\302\207" [string *lisp-def-regexp* nil (search-failed) re-search-forward symbol-under-point add-completion-to-tail-if-new] 2])
(defconst completion-c-def-syntax-table (byte-code "\306 \307\310\311\312\211\313W\203\314\315#\210T\211\202\f\n\311\211\2036
@\314\f\316#\210
A\211\204&*	\311\211\203O
@\314\f\317#\210
A\211\204?*\314\320\321#\210\314\322\323#\210\314\324\325#\210\314\326\327#\210,\207" [i separator-chars whitespace-chars table char --dolist-tail-- make-syntax-table (32 10 9 12 11 13) (44 42 61 40 59) nil 0 256 modify-syntax-entry "w" "_" " " 91 "(]" 123 "(}" 93 ")[" 125 "){"] 5))
#@47 A regexp that searches for a definition form.
(defconst *c-def-regexp* "\n[_a-zA-Z#]" (#$ . 28354))
(defalias 'add-completions-from-c-buffer #[nil "\306\211\211\212eb\210\3072\342\310 p\311\216\312
!\210\3131\306\3141\273\315\"!\210h\316U\203F\317\320!\203!\321\322!\203!\323 \211\203!\324\n!\210\202!`	\203!\325	\326\"\211\203!	b\210g\211\327U\203k\325`\326\"\211b\210\202X\321\330!\210\331 \211\203}\324\n!\210\202\222\317\332!\203\222\321\330!\210\331 \211\203\222\324\n!\210	b\210z\333U\203\257z\333U\203H\325	\326\"\211f\211\202\235\334U\204H\306\211\202I0#\335\307\336\")\202\336\211#A@\337\235\203\325\326y\202\335\340\341!\210\335\307\336\")\210\202,\207" [char next-point string #1=#:buffer #2=#:table completion-c-def-syntax-table nil finish-add-completions syntax-table #[nil "rq\210\302	!)\207" [#1# #2# set-syntax-table] 2] set-syntax-table (error) (search-failed) re-search-forward 35 looking-at "\\(define\\|ifdef\\)\\>" forward-word-strictly 2 symbol-before-point add-completion-to-tail-if-new scan-sexps 1 42 -1 symbol-under-point "_AP" 40 44 throw t ("Containing expression ends prematurely" "Unbalanced parentheses") message "Error parsing C buffer for completions--please send bug report" *c-def-regexp* e] 4])
(defalias 'kill-emacs-save-completions #[nil "\205	\205\n\205\204\304\305!\207\306 \207" [save-completions-flag enable-completion cmpl-initialized-p cmpl-completions-accepted-p message "Completions database has not changed - not writing." save-completions-to-file] 2])
(defconst completion-version "11")
(defconst saved-cmpl-file-header ";;; Completion Initialization file.\n;; Version = %s\n;; Format is (<string> . <last-use-time>)\n;;  <string> is the completion\n;;  <last-use-time> is the time the completion was last used\n;;    If it is t, the completion will never be pruned from the file.\n;;    Otherwise it is in hours since origin.\n\n")
(defalias 'completion-backup-filename #[(filename) "\301P\207" [filename ".BAK"] 2])
#@106 Save completions in init file FILENAME.
If file name is not specified, use `save-completions-file-name'.
(defalias 'save-completions-to-file #[(&optional filename) "\306\206	!\307!\205
\n\204\310 \210\311\312\"\210\313\314
%\315&\316 '\314\211()\314*\317!+r\320\321!q\210,\322p!\204S\311\323!\210\324\313\"\210\311\325\"\210\326 \210\327 \210\330-.\"c\210\331 \315/\2110\203\3130@/(T(\332/8\211&\313=\203\213)T\211)\204\261/A@\314V\203\234'\211&\202\256&\203\3021\203\261'&Z1W\203\302*T*\333/@&B!\334\261\2100A\2110\204l*\3351\376\336!\211\203\355\336+!\204\346\337+\"\210\340+\313#\210\341 \210\205\371\342+!)0\202
\210\343\315!\210\311\344\"\210\315\2112.\n\207" [filename save-completions-file-name cmpl-initialized-p delete-old-versions kept-old-versions completions-file-versions-kept expand-file-name file-writable-p completion-initialize message "Saving completions to file %s" t 0 nil cmpl-hours-since-origin completion-backup-filename get-buffer-create " *completion-save-buffer*" verify-visited-file-modtime "Completion file has changed.  Merging. . ." load-completions-from-file "Merging finished.  Saving completions to file %s" clear-visited-file-modtime erase-buffer format list-all-completions 2 prin1-to-string "\n" (error) file-exists-p rename-file copy-file save-buffer delete-file set-buffer-modified-p "Couldn't save completion file `%s'" kept-new-versions last-use-time this-use-time total-in-db total-perm total-saved backup-filename buffer-file-name saved-cmpl-file-header completion-version completion --dolist-tail-- save-completions-retention-time cmpl-completions-accepted-p] 5 (#$ . 30386) nil])
#@104 Load a completion init file FILENAME.
If file is not specified, then use `save-completions-file-name'.
(defalias 'load-completions-from-file #[(&optional filename no-message-p) "\306\206	!\307!\310\n!\211\203\n\310!\2051
\f\204.\311\312\203*\313\202+\314#\210r\315\316!q\210\317 \210\320 \210\321p\321\211\211\211\211$\322\211%&'()*+,-.\3231l\324\325\"\210\325\211.0\202q\210\311\326\"\210.\205/
eb\210\3271
\3301
\331-!+&T&+:\203
+@\211,;\203
+A\211*\332=\203\264%T%\325\211*\202\307*\325=\203\304%T\211%\202\307*\250\203
\333\334,!\211)8(*\325=\204\367*\335V\203\202(\325=\204\202(\203\367*(V\203\202)AA*\240\210\202\202\311\336\337+!\"\210\340\341!\210\202\2020\210\311\342!\202/
\210`dU\203,
\f?\205/
\311\343\"\202/
\311\342!.*\207" [filename save-completions-file-name backup-filename backup-readable-p no-message-p buffer-file-name expand-file-name completion-backup-filename file-readable-p message "Loading completions from %sfile %s . . ." "backup " "" get-buffer-create " *completion-save-buffer*" clear-visited-file-modtime erase-buffer nil 0 (file-error) insert-file-contents t "File error trying to load completion file %s." (end-of-file) (search-failed) read T 2 add-completion-to-tail-if-new 1000 "Error: invalid saved completion - %s" prin1-to-string search-forward "\n(" "End of file while reading completions." "Loading completions from file %s . . . Done." cmpl-source-init-file total-perm total-in-file current-completion-source cmpl-last-use-time cmpl-entry last-use-time entry string buffer insert-okay-p] 11 (#$ . 32095) nil])
#@105 Load the default completions file.
Also sets up so that exiting Emacs will automatically save the file.
(defalias 'completion-initialize #[nil "?\205\301 \210\302\211\207" [cmpl-initialized-p load-completions-from-file t] 2 (#$ . 33734) nil])
#@622 Kill between point and mark.
The text is deleted but saved in the kill ring.
The command \[yank] can retrieve it from there.
/(If you want to kill and then yank immediately, use \[copy-region-as-kill].)

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character positions indicating the stretch of text
 to be killed.
Any command that calls this function is a "kill command".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.
Patched to remove the most recent completion.
(defalias 'completion-kill-region #[(&optional beg end) "\306\267\202`	|\210\nc\210\307\211\207\310\f
\"\207" [last-command cmpl-last-insert-location cmpl-original-string completion-to-accept beg end #s(hash-table size 1 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (complete 6)) nil kill-region] 3 (#$ . 33988) "r"])
(defvar completion-separator-chars (append " !%^&()=`|{}[];\\'#,?" ".:" nil))
(defalias 'completion--post-self-insert #[nil "	>\205\303 \211\205\212\nSb\210\304 ))\207" [last-command-event completion-separator-chars after-pos electric--after-char-pos use-completion-before-separator] 3])
#@145 Add a call to update the completion database before function execution.
TYPE is the type of the wrapper to be added.  Can be :before or :under.
(defalias 'completion-def-wrapper #[(function-name type) "\302\303	\304\236A#\207" [function-name type put completion-function ((:separator . use-completion-before-separator) (:before . use-completion-before-point) (:backward-under . use-completion-backward-under) (:backward . use-completion-backward) (:under . use-completion-under-point) (:under-or-before . use-completion-under-or-before-point) (:minibuffer-separator . use-completion-minibuffer-separator))] 5 (#$ . 35251)])
(defalias 'use-completion-minibuffer-separator #[nil "\302 )\207" [completion-standard-syntax-table completion-syntax-table use-completion-before-separator] 1])
(defalias 'use-completion-backward-under #[nil "\300 \207" [use-completion-under-point] 1])
(defalias 'use-completion-backward #[nil "\300\207" [nil] 1])
(defalias 'completion-before-command #[nil "9\203\301N\206\f\302 \207" [this-command completion-function use-completion-under-or-before-point] 2])
(defconst completion-lisp-syntax-table (byte-code "\305!\306	\307\211\203\f@\310\311\n#\210\fA\211\204*\n*\207" [completion-standard-syntax-table symbol-chars table char --dolist-tail-- copy-syntax-table (33 38 63 61 94) nil modify-syntax-entry "_"] 5))
(defalias 'completion-lisp-mode-hook #[nil "\303\302!\210\304\n\305\306\307\"\"\211\207" [completion-lisp-syntax-table completion-syntax-table completion-separator-chars make-local-variable cl-set-difference append "!&%?=^" nil] 5])
(defconst completion-c-syntax-table (byte-code "\305!\306	\307\211\203\f@\310\311\n#\210\fA\211\204*\n*\207" [completion-standard-syntax-table separator-chars table char --dolist-tail-- copy-syntax-table (43 42 47 58 37) nil modify-syntax-entry " "] 5))
(completion-def-wrapper 'electric-c-semi :separator)
(defalias 'completion-c-mode-hook #[nil "\303\302!\210\304\305\n\"\211\207" [completion-c-syntax-table completion-syntax-table completion-separator-chars make-local-variable append "+*/"] 3])
(defconst completion-fortran-syntax-table (byte-code "\305!\306	\307\211\203\f@\310\311\n#\210\fA\211\204*\n*\207" [completion-standard-syntax-table separator-chars table char --dolist-tail-- copy-syntax-table (43 45 42 47 58) nil modify-syntax-entry " "] 5))
(defalias 'completion-setup-fortran-mode #[nil "\303\302!\210\304\305\n\"\211\207" [completion-fortran-syntax-table completion-syntax-table completion-separator-chars make-local-variable append "+-*/"] 3])
(defvar completion-saved-bindings nil)
#@290 Non-nil if Dynamic-Completion mode is enabled.
See the `dynamic-completion-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 `dynamic-completion-mode'.
(custom-declare-variable 'dynamic-completion-mode nil '(#$ . 37888) :set 'custom-set-minor-mode :initialize 'custom-initialize-default :group 'completion :type 'boolean)
#@197 Toggle dynamic word-completion on or off.
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.
(defalias 'dynamic-completion-mode #[(&optional arg) "\306 \307\305	\310=\203\311\305!?\202\312	!\313V\"\210\314\n\315\316#\210\317\320B\321\322B\323\324B\325\326B\327\330B\331\332B\333\334B\257\335\211\203\\\f@
\203N\336@A\"\210\202U\337@A\"\210\fA\211\204=*1\203x1\211A1\2422\3402@2A\"\210)\202]
\203\254\341\3352\211\203\250\f@\2112@\34232@\"B1B1\3402@2A\"\210\fA\211\204\205*\343 \210\344\345\311\305!\203\270\346\202\271\347\"\210\350\351!\203\346\352\305!\210\306 \203\321\306 \232\203\346\3534\354\355\311\305!\203\340\356\202\341\3574#\210))\360 \210\311\305!\207" [#1=#:last-message arg function-key-map x --dolist-tail-- dynamic-completion-mode current-message set-default toggle default-value prefix-numeric-value 0 define-key [C-return] [67108877] find-file-hook completion-find-file-hook pre-command-hook completion-before-command kill-emacs-hook kill-emacs-save-completions post-self-insert-hook completion--post-self-insert lisp-mode-hook completion-lisp-mode-hook c-mode-hook completion-c-mode-hook fortran-mode-hook completion-setup-fortran-mode nil add-hook remove-hook global-set-key (("\215" . complete) ([67108877] . complete) ([remap kill-region] . completion-kill-region)) lookup-key completion-initialize run-hooks dynamic-completion-mode-hook dynamic-completion-mode-on-hook dynamic-completion-mode-off-hook called-interactively-p any customize-mark-as-set "" message "Dynamic-Completion mode %sabled%s" "en" "dis" force-mode-line-update completion-saved-bindings binding global-map local] 9 (#$ . 38354) (list (or current-prefix-arg 'toggle))])
(defvar dynamic-completion-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\305\306\307\310\300!\205\307\211%\210\311\312\313\"\210\311\314\313\"\210\311\315\313\"\210\311\316\317\"\210\311\320\313\"\210\311\321\313\"\210\311\322\323\"\210\311\324\323\"\210\311\325\323\"\210\311\326\323\"\210\311\327\323\"\210\311\330\323\"\210\311\331\323\"\210\311\332\323\"\210\311\333\323\"\210\311\334\335\"\210\311\336\335\"\210\311\337\335\"\210\311\340\341\"\210\311\342\341\"\210\343\344\345\"\210\346\347\350\"\210\351\352!\207" [dynamic-completion-mode-map dynamic-completion-mode-hook variable-documentation put "Hook run after entering or leaving `dynamic-completion-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 dynamic-completion-mode nil boundp completion-def-wrapper newline :separator newline-and-indent comint-send-input exit-minibuffer :minibuffer-separator eval-print-last-sexp eval-last-sexp next-line :under-or-before previous-line beginning-of-buffer end-of-buffer beginning-of-line end-of-line forward-char forward-word forward-sexp backward-char :backward-under backward-word backward-sexp delete-backward-char :backward delete-backward-char-untabify defvaralias cmpl-syntax-table completion-syntax-table defalias initialize-completions completion-initialize provide completion] 6)