Current File : //usr/local/share/emacs/27.2/lisp/minibuffer.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#@682 Return the boundaries of text on which COLLECTION will operate.
STRING is the string on which completion will be performed.
SUFFIX is the string after point.
If COLLECTION is a function, it is called with 3 arguments: STRING,
PRED, and a cons cell of the form (boundaries . SUFFIX).
The result is of the form (START . END) where START is the position
in STRING of the beginning of the completion field and END is the position
in SUFFIX of the end of the completion field.
E.g. for simple completion tables, the result is always (0 . (length SUFFIX))
and for file names the result is the positions delimited by
the closest directory separators.
(fn STRING COLLECTION PRED SUFFIX)
(defalias 'completion-boundaries #[1028 "\300!\205
\301B#\211\242\301=\204 \302\262\211A@\206 \303AA\206& GB\207" [functionp boundaries nil 0] 9 (#$ . 409)])
#@801 Return the metadata of elements to complete at the end of STRING.
This metadata is an alist. Currently understood keys are:
- `category': the kind of objects returned by `all-completions'.
Used by `completion-category-overrides'.
- `annotation-function': function to add annotations in *Completions*.
Takes one argument (STRING), which is a possible completion and
returns a string to append to STRING.
- `display-sort-function': function to sort entries in *Completions*.
Takes one argument (COMPLETIONS) and should return a new list
of completions. Can operate destructively.
- `cycle-sort-function': function to sort entries when cycling.
Works like `display-sort-function'.
The metadata of a completion table should be constant between two boundaries.
(fn STRING TABLE PRED)
(defalias 'completion-metadata #[771 "\300!\205 \301#\301\242\301=\205 AB\207" [functionp metadata] 7 (#$ . 1266)])
#@20
(fn FIELD-START)
(defalias 'completion--field-metadata #[257 "\302\303`\" #\207" [minibuffer-completion-table minibuffer-completion-predicate completion-metadata buffer-substring-no-properties] 5 (#$ . 2196)])
#@22
(fn METADATA PROP)
(defalias 'completion-metadata-get #[514 "\211\236A\207" [] 4 (#$ . 2416)])
#@114 Apply FUN to each element of XS in turn.
Return the first non-nil returned value.
Like CL's `some'.
(fn FUN XS)
(defalias 'completion--some #[514 "\300\211\211\204+ \203+ \3011 \211A\262\242!\211\2620\202' \204$ \211\262\300\262\210\202 \211\2069 \2059 \302@A\"\207" [nil (debug error) signal] 7 (#$ . 2521)])
#@517 Perform completion according to ACTION.
STRING, COLLECTION and PREDICATE are used as in `try-completion'.
If COLLECTION is a function, it will be called directly to
perform completion, no matter what ACTION is.
If ACTION is `metadata' or a list where the first element is
`boundaries', return nil. If ACTION is nil, this function works
like `try-completion'; if it is t, this function works like
`all-completion'; and any other value makes it work like
`test-completion'.
(fn ACTION COLLECTION STRING PREDICATE)
(defalias 'complete-with-action #[1028 "\300!\203
#\207\242\301=\203 \302\207\303=\203 \302\207\204& \304\2021 \305=\2030 \306\2021 \307#\207" [functionp boundaries nil metadata try-completion t all-completions test-completion] 8 (#$ . 2852)])
#@1017 Use function FUN as a dynamic completion table.
FUN is called with one argument, the string for which completion is requested,
and it should return a completion table containing all the intended possible
completions.
This table is allowed to include elements that do not actually match the
string: they will be automatically filtered out.
The completion table returned by FUN can use any of the usual formats of
completion tables such as lists, alists, and hash-tables.
If SWITCH-BUFFER is non-nil and completion is performed in the
minibuffer, FUN will be called in the buffer from which the minibuffer
was entered.
The result of the `completion-table-dynamic' form is a function
that can be used as the COLLECTION argument to `try-completion' and
`all-completions'. See Info node `(elisp)Programmed Completion'.
The completion table returned by `completion-table-dynamic' has empty
metadata and trivial boundaries.
See also the related function `completion-table-with-cache'.
(fn FUN &optional SWITCH-BUFFER)
(defalias 'completion-table-dynamic #[513 "\300\301\302\303\304\"\305\"\306\307%\207" [make-byte-code 771 "\211\242\302=\206\n \211\303=?\2053 r\301\204 p\202( \304 \305!\203% \306!\202& p\262q\210\307\300!$)\207" vconcat vector [boundaries metadata minibuffer-selected-window window-live-p window-buffer complete-with-action] 8 "\n\n(fn STRING PRED ACTION)"] 9 (#$ . 3636)])
#@498 Create dynamic completion table from function FUN, with cache.
This is a wrapper for `completion-table-dynamic' that saves the last
argument-result pair from FUN, so that several lookups with the
same argument (or with an argument that starts with the first one)
only need to call FUN once. This can be useful when FUN performs a
relatively slow operation, such as calling an external process.
When IGNORE-CASE is non-nil, FUN is expected to be case-insensitive.
(fn FUN &optional IGNORE-CASE)
(defalias 'completion-table-with-cache #[513 "\300C\300C\301\302\303\304\305$\306\"\307\310%\311!\207" [nil make-byte-code 257 "\302\242\203 \304\302\242\301#\203 \303\242\207\303\300!\240\302\240\210\207" vconcat vector [string-prefix-p] 5 "\n\n(fn ARG)" completion-table-dynamic] 13 (#$ . 5047)])
#@565 Initialize variable VAR as a lazy completion table.
If the completion table VAR is used for the first time (e.g., by passing VAR
as an argument to `try-completion'), the function FUN is called with no
arguments. FUN must return the completion table that will be stored in VAR.
If completion is requested in the minibuffer, FUN will be called in the buffer
from which the minibuffer was entered. The return value of
`lazy-completion-table' must be used to initialize the value of VAR.
You should give VAR a non-nil `risky-local-variable' property.
(fn VAR FUN)
(defalias 'lazy-completion-table '(macro . #[514 "\300\301!\302\303C\304\305D\306\307\310\nDDEEF\311BB\207" [make-symbol "string" completion-table-dynamic lambda when functionp setq funcall function ('do-switch-buffer)] 13 (#$ . 5864)]))
(put 'lazy-completion-table 'edebug-form-spec '(symbolp lambda-expr))
#@170 Return new completion TABLE that is case insensitive.
If DONT-FOLD is non-nil, return a completion table that is
case sensitive instead.
(fn TABLE &optional DONT-FOLD)
(defalias 'completion-table-case-fold #[513 "\300\301\302\303\304\"\305\"\306\307%\207" [make-byte-code 771 "\301?\303\300$)\207" vconcat vector [completion-ignore-case complete-with-action] 8 "\n\n(fn STRING PRED ACTION)"] 9 (#$ . 6751)])
#@233 Return a completion table from TABLE with S1 replaced by S2.
The result is a completion table which completes strings of the
form (concat S1 S) in the same way as TABLE completes strings of
the form (concat S2 S).
(fn TABLE S1 S2)
(defalias 'completion-table-subvert #[771 "\300\301\302\303\304#\305\"\306\307%\207" [make-byte-code 771 "\304\301 #\205 \302\305\301G\"P\211\205 \306\300$\211\205\244 \242\307=\203O \211\242\307=\2032 \211A@\2063 \310\307\301G\301G\302GZ\\]\242\307=\205H AABB\262\202\244 \211;\203f \304\302 #\205\244 \301\305\302G\"P\202\244 \311=\203\243 \312\300\313$\211@\302GY\203 \202\236 \314\315\305\302@\"!P\316\317\320\321\322\323\324\325!\326\"\327\330%\"\"\262\262\202\244 \211\207" vconcat vector [completion-ignore-case string-prefix-p substring complete-with-action boundaries 0 t completion-boundaries "" "\\`" regexp-quote delq nil mapcar make-byte-code 257 "\301\300\"\205\f \302\303\225\"\207" vconcat vector [string-match substring 0] 4 "\n\n(fn C)"] 16 "\n\n(fn STRING PRED ACTION)"] 11 (#$ . 7175)])
#@40
(fn PREFIX TABLE STRING PRED ACTION)
(defalias 'completion-table-with-context #[1285 "\300!\204\n \202a \301!\203\" \302\303\304\305\306 \"\307\"\310\311%\202a \312!\203: \302\313\314\305\306 \"\315\"\310\316%\202a \300!\203R \302\303\317\305\306 \"\315\"\320\321%\202a \302\303\322\305\306 \"\315\"\320\321%\242\323=\203\201 G\324A$\323@\\ABB\266\202\202\230 \325$\211;\203\225 P\202\226 \211\262\207" [functionp vectorp make-byte-code 257 "\301\300\302!P!\207" vconcat vector [symbol-name] 5 "\n\n(fn SYM)" hash-table-p 514 "\301\300P!\207" [] "\n\n(fn S V)" "\301\300P!\207" 4 "\n\n(fn S)" "\301\300:\203\f @\202
P!\207" boundaries completion-boundaries complete-with-action] 12 (#$ . 8256)])
#@866 Construct a completion table like TABLE but with an extra TERMINATOR.
This is meant to be called in a curried way by first passing TERMINATOR
and TABLE only (via `apply-partially').
TABLE is a completion table, and TERMINATOR is a string appended to TABLE's
completion if it is complete. TERMINATOR is also used to determine the
completion suffix's boundary.
TERMINATOR can also be a cons cell (TERMINATOR . TERMINATOR-REGEXP)
in which case TERMINATOR-REGEXP is a regular expression whose submatch
number 1 should match TERMINATOR. This is used when there is a need to
distinguish occurrences of the TERMINATOR strings which are really terminators
from others (e.g. escaped). In this form, the car of TERMINATOR can also be,
instead of a string, a function that takes the completion and returns the
"terminated" string.
(fn TERMINATOR TABLE STRING PRED ACTION)
(defalias 'completion-table-with-terminator #[1285 "\211\242\300=\2038 \211A\301$:\203 A\202 \302!\211\205( \303\"\300@A\2064 G^BB\207\211\304\267\202\246 \305#:\203L @\262\211\306=\203f \307!\203_ !\202\243 P\202\243 \211;\203\242 \211G\310U\204\242 \301\311$\211@GW\262\203\242 \305#\306=\203\242 \307!\203\233 !\202\243 \211P\202\243 \211\207\312\207\313$\207" [boundaries completion-boundaries regexp-quote string-match #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 62 lambda 164)) try-completion t functionp 0 "" nil complete-with-action] 13 (#$ . 9006)])
#@636 Make a completion table equivalent to TABLE but filtered through PRED1.
PRED1 is a function of one argument which returns non-nil if and
only if the argument is an element of TABLE which should be
considered for completion. STRING, PRED2, and ACTION are the
usual arguments to completion tables, as described in
`try-completion', `all-completions', and `test-completion'. If
STRICT is non-nil, the predicate always applies; if nil it only
applies if it does not reduce the set of possible completions to
nothing. Note: TABLE needs to be a proper completion table which
obeys predicates.
(fn TABLE PRED1 STRICT STRING PRED2 ACTION)
(defalias 'completion-table-with-predicate #[1542 "\204 \211\300=\203 \301#\207\302\203 \204( \2067 \2027 \303\304\305\306\307
\"\310\"\311\312%$\206K ?\205K \205K \302$\207" [lambda test-completion complete-with-action make-byte-code 257 "\300!\205 \301!\207" vconcat vector [] 3 "\n\n(fn X)"] 17 (#$ . 10536)])
#@87 Create a completion table that tries each table in TABLES in turn.
(fn &rest TABLES)
(defalias 'completion-table-in-turn #[128 "\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 771 "\301\302\303\304\305\306#\307\"\310\311%\300\"\207" vconcat vector [completion--some make-byte-code 257 "\303\302\300\301$\207" vconcat vector [complete-with-action] 6 "\n\n(fn TABLE)"] 12 "\n\n(fn STRING PRED ACTION)"] 7 (#$ . 11521)])
#@89 Create a completion table that collects completions from all TABLES.
(fn &rest TABLES)
(defalias 'completion-table-merge #[128 "\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 771 "\211\2049 \301\302\303\304\305\306\"\307\"\310\311%\300\"\235\203 \2028 \312\301\302\303\313\305\306 !\314\"\315\316%\317\320\"\"#\207\211\321=\203U \322\323\301\302\303\304\305\306\n\n\"\324\"\310\311%\300\"\"\207\325\302\303\326\305\306#\327\"\330\311%\300\"\207" vconcat vector [mapcar make-byte-code 257 "\302\300\301#\207" vconcat vector [try-completion] 5 "\n\n(fn TABLE)" try-completion "\211\301=\203 \300\207\207" [t] 3 "\n\n(fn VALUE)" delq nil t apply append [all-completions] completion--some "\303\302\300\301$\207" [complete-with-action] 6] 13 "\n\n(fn STRING PRED ACTION)"] 7 (#$ . 11964)])
#@635 Return a new completion table operating on quoted text.
TABLE operates on the unquoted text.
UNQUOTE is a function that takes a string and returns a new unquoted string.
REQUOTE is a function of 2 args (UPOS QSTR) where
QSTR is a string entered by the user (and hence indicating
the user's preferred form of quoting); and
UPOS is a position within the unquoted form of QSTR.
REQUOTE should return a pair (QPOS . QFUN) such that QPOS is the
position corresponding to UPOS but in QSTR, and QFUN is a function
of one argument (a string) which returns that argument appropriately quoted
for use at QPOS.
(fn TABLE UNQUOTE REQUOTE)
(defalias 'completion-table-with-quoting #[771 "\300\301\302\303\304#\305\"\306\307%\207" [make-byte-code 771 "\211\303\267\202 \304\305\300#\306\"\207\301!\307\300#\207\211\242\310=\203y \301!A\211G\311U\203/ \2024 \301P!\312\"\204? \313\314!\210\315\316G\"\317\300 $\302@\n\"@A\311U\203^ \311\202s AG\\\302\f P\"@ GZ\262\310BB\207\211\320\267\202\301!\321\300#\211;\204\220 \211\202\232 \322\311\301\302&@\207\301!\323\300#\317\300\324$@\325\301\302&\326!\211:\203\301 \211\315\241\210\207\301!\301\316\311#!\312\"\203\333 \211G\202\301\316\"!\327\"\203\361 GGZ\202 GG^GGZ\311]\\\330\245\262\300\331\332\333\334\335\301\302
$\336\"\337\340%F\207\211\242\310=\205z\301!A\211G\311U\203/\2024\301P!\312\"\204?\313\314!\210\315\316G\"\317\300 $\302@\n\"@A\311U\203^\311\202sAG\\\302\f P\"@ GZ\262\310BB\266\210\207" vconcat vector [#s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (metadata 6 lambda 15)) append completion-metadata ((completion--unquote-requote . t)) test-completion boundaries 0 string-prefix-p cl--assertion-failed (string-prefix-p ustring ufull) nil substring completion-boundaries #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 127 t 155 completion--unquote 195)) try-completion completion--twq-try all-completions "" completion--twq-all last string-suffix-p 2 make-byte-code 514 "\211\304\267\2026 \242;\204 \207\305\302\303@A\300\301&\207\306!\211A\206# \307\2055 \310\241\210\311\302\303\300\301&\207\310\207" vconcat vector [#s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (1 6 2 26)) completion--twq-try last 0 nil completion--twq-all] 11 "\n\n(fn UNQUOTED-RESULT OP)"] 19 "\n\n(fn STRING PRED ACTION)"] 11 (#$ . 12794)])
#@56
(fn STRING USTRING COMPLETION POINT UNQUOTE REQUOTE)
(defalias 'completion--twq-try #[1542 "\300\"\301G]\"G \"\211@A\211 GV\205+ \301\f G
#!!\301\302#Q\f\302U\203C \302\202[ \f\nGV\203S G\\\202[ \n
\"@\f!\232\203k B\202u !\211GB\262\266\204\266\202\207" [fill-common-string-prefix substring 0] 20 (#$ . 15328)])
#@14
(fn S1 S2)
(defalias 'completion--string-equal-p #[514 "\300\301\211\301\211\302&\303=\207" [compare-strings nil ignore-case t] 10 (#$ . 15693)])
#@60
(fn STRING USTRING COMPLETIONS BOUNDARY UNQUOTE REQUOTE)
(defalias 'completion--twq-all #[1542 "\205a \301\302\303\304\"B\")G\\\"\211@A\211\304\f\305#\n\"@\211X\2049 \306\307!\210\301\310\304\"\311\312#\313\314\315\316\317\320\f#\321\"\322\323%\"\244\262\266\203\266\202\266\204\207" [completion-regexp-list nil try-completion "" substring 0 cl--assertion-failed (<= qboundary qfullpos) propertize face completions-common-part mapcar make-byte-code 257 "\304\300\305#\204 \306\307\310\300D\310$\210\311\300G\"\301! \204! \302\202< \311\312\300G#\301!\313\302\"\2039 \314\315\316#\202: \302\266\202\211P\207" vconcat vector [completion-ignore-case string-prefix-p ignore-case cl--assertion-failed (string-prefix-p prefix completion 'ignore-case) nil substring 0 completion--string-equal-p propertize face completions-common-part] 9 "\n\n(fn COMPLETION)"] 25 (#$ . 15850)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\303#\210\304\306\307\305#\210\310\311\303\312\313\314\315\316&\207" [defalias complete-in-turn completion-table-in-turn nil make-obsolete "23.1" dynamic-completion-table completion-table-dynamic custom-declare-group minibuffer "Controlling the behavior of the minibuffer." :link (custom-manual "(emacs)Minibuffer") :group environment] 8)
#@66 Text properties added to the text shown by `minibuffer-message'.
(defvar minibuffer-message-properties nil (#$ . 17180))
#@330 Temporarily display MESSAGE at the end of the minibuffer.
The text is displayed for `minibuffer-message-timeout' seconds,
or until the next input event arrives, whichever comes first.
Enclose MESSAGE in [...] if this is not yet the case.
If ARGS are provided, then pass MESSAGE through `format-message'.
(fn MESSAGE &rest ARGS)
(defalias 'minibuffer-message #[385 "\304p!\204$ \211\203 \305\306#\210\202 \306\307\"\210\310\206 \311!\306\312!\210\207\306\312!\210\211\204B \313\312\314\315#)\266\203\203B \316!\202F \317\320Q\262\211\203S \305\321#\262\n\203e \322\323\"\204e \305\324\n#\262\325dd\312\314\211%\314\326\323\327\330\331!\332\"\333$\216G\323U\204\212 \334\323\335\336\314%\210\337\340#\210\310\206\226 \311!*\207" [minibuffer-message-timeout inhibit-changing-match-data minibuffer-message-properties inhibit-quit minibufferp apply message "%s" sit-for 1000000 nil "\\` *\\[.+\\]\\'" t string-match copy-sequence " [" "]" format-message text-properties-at 0 propertize make-overlay make-byte-code "\301\300!\207" vconcat vector [delete-overlay] 2 put-text-property 1 cursor overlay-put after-string] 9 (#$ . 17308)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable minibuffer-message-clear-timeout funcall function #[0 "\300\207" [nil] 1] "How long to display an echo-area message when the minibuffer is active.\nIf the value is a number, it is the time in seconds after which to\nremove the echo-area message from the active minibuffer.\nIf the value is not a number, such messages are never removed,\nand their text is displayed until the next input event arrives.\nUnlike `minibuffer-message-timeout' used by `minibuffer-message',\nthis option affects the pair of functions `set-minibuffer-message'\nand `clear-minibuffer-message' called automatically via\n`set-message-function' and `clear-message-function'." :type (choice (const :tag "Never time out" nil) (integer :tag "Wait for the number of seconds" 2)) :version "27.1"] 8)
(defvar minibuffer-message-timer nil)
(defvar minibuffer-message-overlay nil)
#@75 Return position where `set-minibuffer-message' shall put message overlay.
(defalias 'minibuffer--message-overlay-pos #[0 "`\300\301\"\211\203
\202 \302\301\303d$\207" [get-text-property minibuffer-message next-single-property-change nil] 7 (#$ . 19406)])
#@506 Temporarily display MESSAGE at the end of the minibuffer.
If some part of the minibuffer text has the `minibuffer-message' property,
the message will be displayed before the first such character, instead of
at the end of the minibuffer.
The text is displayed for `minibuffer-message-clear-timeout' seconds
(if the value is a number), or until the next input event arrives,
whichever comes first.
Unlike `minibuffer-message', this function is called automatically
via `set-message-function'.
(fn MESSAGE)
(defalias 'set-minibuffer-message #[257 "\306 \307!\205 \310!?\205\221 \307!\205\221 \310 =\204& \311\312\"\313=\205\221 r\314!q\210\315\316\317\320#)\266\203\203B \321!\202F \322\323Q\262\n\203Z \324\325\"\204Z \326\327\n#\262\330 \210\331 \332\211\316\317\211%\210G\325U\204x \333\325\334\335\334%\210\336 \337#\210\336 \340\341#\210\f\247\203\217 \342\f\316\330#)\317\207" [noninteractive inhibit-changing-match-data minibuffer-message-properties minibuffer-message-overlay minibuffer-message-clear-timeout minibuffer-message-timer active-minibuffer-window window-live-p window-frame frame-parameter minibuffer only window-buffer "\\` *\\[.+\\]\\'" nil t string-match copy-sequence " [" "]" text-properties-at 0 apply propertize clear-minibuffer-message minibuffer--message-overlay-pos make-overlay put-text-property 1 cursor overlay-put after-string priority 1100 run-with-timer] 10 (#$ . 19673)])
(byte-code "\301\211\207" [set-message-function set-minibuffer-message] 2)
#@79 Clear minibuffer message.
Intended to be called via `clear-message-function'.
(defalias 'clear-minibuffer-message #[0 "?\205 \303 !\203 \304 !\210\305\306\n!\205 \307\n!\210\305\211\207" [noninteractive minibuffer-message-timer minibuffer-message-overlay timerp cancel-timer nil overlayp delete-overlay] 2 (#$ . 21188)])
(byte-code "\301\211\207" [clear-message-function clear-minibuffer-message] 2)
#@200 Return the user input in a minibuffer before point as a string.
In Emacs 22, that was what completion commands operated on.
If the current buffer is not a minibuffer, return everything before point.
(defalias 'minibuffer-completion-contents #[0 "\300 `{\207" [minibuffer-prompt-end] 2 (#$ . 21602)])
(make-obsolete 'minibuffer-completion-contents nil "24.4")
#@110 Delete all user input in a minibuffer.
If the current buffer is not a minibuffer, erase its entire contents.
(defalias 'delete-minibuffer-contents #[0 "\300 d|\207" [minibuffer-prompt-end] 2 (#$ . 21968) nil])
#@62 If non-nil, print helpful inline messages during completion.
(defvar completion-show-inline-help t (#$ . 22184))
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable completion-auto-help funcall function #[0 "\300\207" [t] 1] "Non-nil means automatically provide help for invalid completion input.\nIf the value is t the *Completions* buffer is displayed whenever completion\nis requested but cannot be done.\nIf the value is `lazy', the *Completions* buffer is only displayed after\nthe second failed attempt to complete." :type (choice (const nil) (const t) (const lazy))] 6)
#@501 List of available completion styles.
Each element has the form (NAME TRY-COMPLETION ALL-COMPLETIONS DOC):
where NAME is the name that should be used in `completion-styles',
TRY-COMPLETION is the function that does the completion (it should
follow the same calling convention as `completion-try-completion'),
ALL-COMPLETIONS is the function that lists the completions (it should
follow the calling convention of `completion-all-completions'),
and DOC describes the way this style of completion works.
(defconst completion-styles-alist '((emacs21 completion-emacs21-try-completion completion-emacs21-all-completions "Simple prefix-based completion.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foobar*\".") (emacs22 completion-emacs22-try-completion completion-emacs22-all-completions "Prefix completion that only operates on the text before point.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foo*\" and will add back \"bar\" to the end of it.") (basic completion-basic-try-completion completion-basic-all-completions "Completion of the prefix before point and the suffix after point.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"foo*bar*\".") (partial-completion completion-pcm-try-completion completion-pcm-all-completions "Completion of multiple words, each one taken as a prefix.\nI.e. when completing \"l-co_h\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"l*-co*h*\".\nFurthermore, for completions that are done step by step in subfields,\nthe method is applied to all the preceding fields that do not yet match.\nE.g. C-x C-f /u/mo/s TAB could complete to /usr/monnier/src.\nAdditionally the user can use the char \"*\" as a glob pattern.") (substring completion-substring-try-completion completion-substring-all-completions "Completion of the string taken as a substring.\nI.e. when completing \"foo_bar\" (where _ is the position of point),\nit will consider all completions candidates matching the glob\npattern \"*foo*bar*\".") (flex completion-flex-try-completion completion-flex-all-completions "Completion of an in-order subset of characters.\nWhen completing \"foo\" the glob \"*f*o*o*\" is used, so that\n\"foo\" can complete to \"frodo\".") (initials completion-initials-try-completion completion-initials-all-completions "Completion of acronyms and initialisms.\nE.g. can complete M-x lch to list-command-history\nand C-x C-f ~/sew to ~/src/emacs/work.")) (#$ . 22794))
(defconst completion--styles-type (byte-code "\301\302\303\304\305\306\"BF\207" [completion-styles-alist repeat :tag "insert a new menu to add more styles" choice mapcar #[257 "\300@D\207" [const] 3 "\n\n(fn X)"]] 7))
(defconst completion--cycling-threshold-type '(choice (const :tag "No cycling" nil) (const :tag "Always cycle" t) (integer :tag "Threshold")))
(byte-code "\301\302\303\304\305DD\306\307\310\311&\207" [completion--styles-type custom-declare-variable completion-styles funcall function #[0 "\300\207" [(basic partial-completion emacs22)] 1] "List of completion styles to use.\nThe available styles are listed in `completion-styles-alist'.\n\nNote that `completion-category-overrides' may override these\nstyles for specific categories, such as files, buffers, etc." :type :version "23.1"] 8)
#@420 Default settings for specific completion categories.
Each entry has the shape (CATEGORY . ALIST) where ALIST is
an association list that can specify properties such as:
- `styles': the list of `completion-styles' to use for that category.
- `cycle': the `completion-cycle-threshold' to use for that category.
Categories are symbols such as `buffer' and `file', used when
completing buffer and file names, respectively.
(defvar completion-category-defaults '((buffer (styles basic substring)) (unicode-name (styles basic substring)) (project-file (styles substring)) (info-menu (styles basic substring))) (#$ . 26362))
(byte-code "\302\303\304\305\306DD\307\310\311\312\313\314\315\316\317\320\321\322\320\323\324\257\322\320\325\326 \257\257\257&\207" [completion--styles-type completion--cycling-threshold-type custom-declare-variable completion-category-overrides funcall function #[0 "\300\207" [nil] 1] "List of category-specific user overrides for completion styles.\nEach override has the shape (CATEGORY . ALIST) where ALIST is\nan association list that can specify properties such as:\n- `styles': the list of `completion-styles' to use for that category.\n- `cycle': the `completion-cycle-threshold' to use for that category.\nCategories are symbols such as `buffer' and `file', used when\ncompleting buffer and file names, respectively.\nThis overrides the defaults specified in `completion-category-defaults'." :version "25.1" :type alist :key-type (choice :tag "Category" (const buffer) (const file) (const unicode-name) (const bookmark) symbol) :value-type set :tag "Properties to override" cons "Completion Styles" (const :tag "Select a style from the menu;" styles) "Completion Cycling" (const :tag "Select one value from the menu." cycle)] 20)
#@21
(fn CATEGORY TAG)
(defalias 'completion--category-override #[514 "\211\236A\236\206 \211 \236A\236\207" [completion-category-overrides completion-category-defaults] 5 (#$ . 28134)])
#@17
(fn METADATA)
(defalias 'completion--styles #[257 "\301\302\"\303\304\"\211\203 \305\306A\307!\"!\202 \207" [completion-styles completion-metadata-get category completion--category-override styles delete-dups append copy-sequence] 8 (#$ . 28328)])
#@84 Call the Nth method of completion styles.
(fn N STRING TABLE PRED POINT METADATA)
(defalias 'completion--nth-completion #[1542 "CCC\206 \300\301\242\302\242#\242#\303\304\"\205_ \305\242!\205_ \242\242\242\306#\211A\262\242\240\210\211A\262\242\240\210\211A\262\242\240\210\242\242GX\204W \307\310!\210\211A\262\242\262\311\312\313\314\315\316 %\317\"\320\321%\322!\"\211A\323N\211\203\217 \203\217 !A\241\210\203\234 @\"\202\236 @\266\204\207" [completion-metadata substring 0 completion-metadata-get completion--unquote-requote functionp completion--unquote cl--assertion-failed (<= point (length string)) completion--some make-byte-code 257 "\300
\2368\301\242\302\242\303\304\242$\211\205 \211B\207" vconcat vector [completion-styles-alist] 6 "\n\n(fn STYLE)" completion--styles completion--adjust-metadata] 22 (#$ . 28591)])
#@459 Try to complete STRING using completion table TABLE.
Only the elements of table that satisfy predicate PRED are considered.
POINT is the position of point within STRING.
The return value can be either nil to indicate that there is no completion,
t to indicate that STRING is the only possible completion,
or a pair (NEWSTRING . NEWPOINT) of the completed result string together with
a new position for point.
(fn STRING TABLE PRED POINT &optional METADATA)
(defalias 'completion-try-completion #[1284 "\300\301&\207" [completion--nth-completion 1] 12 (#$ . 29486)])
#@325 List the possible completions of STRING in completion table TABLE.
Only the elements of table that satisfy predicate PRED are considered.
POINT is the position of point within STRING.
The return value is a list of completions and may contain the base-size
in the last `cdr'.
(fn STRING TABLE PRED POINT &optional METADATA)
(defalias 'completion-all-completions #[1284 "\300\301&\207" [completion--nth-completion 2] 12 (#$ . 30071)])
#@35
(fn MODIFIED COMPLETIONS EXACT)
(defalias 'minibuffer--bitset #[771 "\300\203 \301\202\n \302\203 \303\202 \302\203 \304\202 \302#\207" [logior 4 0 2 1] 7 (#$ . 30522)])
#@121 Replace the buffer text between BEG and END with NEWTEXT.
Moves point to the end of the new text.
(fn BEG END NEWTEXT)
(defalias 'completion--replace #[771 "\300\301G\302$\210\301\211GW\203* \\W\203* \\fH=\203* \211T\262\202 \211\301U\204; \\\262\303\"\262\210\301\211GW\203h ZW\203h Z\206S `Sf\304G\305#H=\203h \211T\262\202= \211\301U\204{ Z\262\303\301[#\262b\210Z\306!\210``\\|\266\211u\207" [set-text-properties 0 nil substring - 1 insert-and-inherit] 10 (#$ . 30709)])
(byte-code "\301\302\303\304\305DD\306\307\310\311&\207" [completion--cycling-threshold-type custom-declare-variable completion-cycle-threshold funcall function #[0 "\300\207" [nil] 1] "Number of completion candidates below which cycling is used.\nDepending on this setting `completion-in-region' may use cycling,\nwhereby invoking a completion command several times in a row\ncompletes to each of the candidates in turn, in a cyclic manner.\nIf nil, cycling is never used.\nIf t, cycling is always used.\nIf an integer, cycling is used so long as there are not more\ncompletion candidates than this number." :version "24.1" :type] 8)
#@17
(fn METADATA)
(defalias 'completion--cycle-threshold #[257 "\301\302\"\303\304\"\211\203 \211A\202 \207" [completion-cycle-threshold completion-metadata-get category completion--category-override cycle] 5 (#$ . 31868)])
(defvar completion-all-sorted-completions nil nil)
(make-variable-buffer-local 'completion-all-sorted-completions)
(defvar completion--all-sorted-completions-location nil nil)
(make-variable-buffer-local 'completion--all-sorted-completions-location)
(defvar completion-cycling nil)
#@49 If non-nil, stay quiet when there is no match.
(defvar completion-fail-discreetly nil (#$ . 32383))
#@12
(fn MSG)
(defalias 'completion--message #[257 "\205 \301!\207" [completion-show-inline-help minibuffer-message] 3 (#$ . 32490)])
#@735 Do the completion and return a summary of what happened.
M = completion was performed, the text was Modified.
C = there were available Completions.
E = after completion we now have an Exact match.
MCE
000 0 no possible completion
001 1 was already an exact and unique completion
010 2 no completion happened
011 3 was already an exact completion
100 4 ??? impossible
101 5 ??? impossible
110 6 some completion happened
111 7 completed to an exact completion
TRY-COMPLETION-FUNCTION is a function to use in place of `try-completion'.
EXPECT-EXACT, if non-nil, means that there is no need to tell the user
when the buffer's text is already an exact match.
(fn BEG END &optional TRY-COMPLETION-FUNCTION EXPECT-EXACT)
(defalias 'completion--do-completion #[1026 "{\306!\206 \307 `\nZ%\211\204. \310 \210\n\204& \311 \210\312\313!\210\314\315\211\211#\202k\211\316=\203N \310 \210b\210\317\320?\205D \321#\210\314\315\211\316#\202k\211A@\322\315\211\315\211\316&\316=?\322\315\211 \315\211\211&\316=\211\203x b\210\202\207 \323 #\210\nG\\\262\nGZu\210\211\204\242 \204\242 \324 $\202i\325 #\326!\211\205\314 \203\306 \327\330\331 # \332$@W\205\314 \333
\"\334 \210\211A:\203\376 \3351\341 \233:0\202\343 \210\315\204\376 \316\262\316\262\336#\210\337\"\210\202b\203 \310 \210\203b\317GW\203\340\202\341\"\210\202b\204D \342=\203/\f
=\2020 \203=\343\"\210\202b\312\344!\210\202b\f
=\203U \203U\343\"\210\317\340
?\205`\345#\210\314\316#\266\203\266\204\207" [minibuffer-completion-table minibuffer-completion-predicate completion-fail-discreetly completion-auto-help this-command last-command completion--field-metadata completion-try-completion minibuffer-hide-completions ding completion--message "No match" minibuffer--bitset nil t completion--done finished "Sole completion" compare-strings completion--replace completion--do-completion test-completion completion--cycle-threshold completion-boundaries substring 0 "" completion-all-sorted-completions completion--flush-all-sorted-completions (error) completion--cache-all-sorted-completions minibuffer-force-complete exact unknown lazy minibuffer-completion-help "Next char not unique" "Complete, but not unique"] 18 (#$ . 32631)])
#@283 Complete the minibuffer contents as far as possible.
Return nil if there is no valid completion, else t.
If no characters can be completed, display a list of possible completions.
If you repeat this command after it displayed such a list,
scroll the window of possible completions.
(defalias 'minibuffer-complete #[0 "\302 `X\205 \303\302 d $\207" [minibuffer-completion-table minibuffer-completion-predicate minibuffer-prompt-end completion-in-region] 5 (#$ . 34947) nil])
#@16
(fn BEG END)
(defalias 'completion--in-region-1 #[514 "\305 \305=\204
\306 \210\307\310\n!\203R \311\312\n!!\313=\203R \nr\314!q\210\315d\"\2034 \316e\307#\210\202O \317!r\320\321\322\323\324!\325\"\326$\216\327@\330\"\210\331 \210*\210)\307\207 \203a \f\203a \332\"\210\313\207\333\"\334\321\"?\205n \313\207" [this-command last-command minibuffer-scroll-window completion-cycling completion-all-sorted-completions completion-at-point completion--flush-all-sorted-completions nil window-live-p frame-visible-p window-frame t window-buffer pos-visible-in-window-p set-window-start internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord scroll-up minibuffer-force-complete completion--do-completion eql] 10 (#$ . 35429)])
#@22
(fn BEG END COMPS)
(defalias 'completion--cache-all-sorted-completions #[771 "\302\303\304\305\306$\210\307!\307!B\211\211\207" [completion--all-sorted-completions-location completion-all-sorted-completions add-hook after-change-functions completion--flush-all-sorted-completions nil t copy-marker] 8 (#$ . 36267)])
#@32
(fn &optional START END LEN)
(defalias 'completion--flush-all-sorted-completions #[768 "\205 \205 AV\206 @W?\205) \303\304\305\306#\210 \203& \307 \210\307\211\207" [completion--all-sorted-completions-location completion-cycling completion-all-sorted-completions remove-hook after-change-functions completion--flush-all-sorted-completions t nil] 7 (#$ . 36595)])
#@43
(fn STRING BASE MD-AT-POINT TABLE PRED)
(defalias 'completion--metadata #[1285 "\300\301$\211@=\203 \202 \302\303\304##\207" [completion-boundaries "" completion-metadata substring 0] 11 (#$ . 36978)])
#@28
(fn &optional START END)
(defalias 'completion-all-sorted-completions #[512 "\206\204 \206\n \304 \206 d{\305!\306 \n`Z%\307!\211A\206( \310\311\312`\" \n%\313\314\"\205\202 \315\241\210\316!\262\307!\262\211\203V \211!\262\202w \317\320\"\262\321 \203w J\317\322\323\324\325\326!\327\"\330\331%\"\262\210\332 \244#\266\211\207" [completion-all-sorted-completions minibuffer-completion-table minibuffer-completion-predicate minibuffer-history-variable minibuffer-prompt-end completion--field-metadata completion-all-completions last 0 completion--metadata buffer-substring-no-properties completion-metadata-get cycle-sort-function nil delete-dups sort #[514 "GGW\207" [] 4 "\n\n(fn C1 C2)"] minibufferp make-byte-code 514 " \232\203 \302\207\211 \232\203 \303\207\300\235G\300\235GV\207" vconcat vector [minibuffer-default t nil] 5 "\n\n(fn C1 C2)" completion--cache-all-sorted-completions] 20 (#$ . 37201)])
#@61 Complete the minibuffer with first of the matches and exit.
(defalias 'minibuffer-force-complete-and-exit #[0 "\204\n \301\302\211\303#\210\304\305 d\306\307$\207" [completion-cycling minibuffer-force-complete nil dont-cycle completion--complete-and-exit minibuffer-prompt-end exit-minibuffer #[0 "\203 \301\302!\207\303 \207" [minibuffer--require-match minibuffer-message "Incomplete" exit-minibuffer] 2]] 5 (#$ . 38166) nil])
#@186 Complete the minibuffer to an exact match.
Repeated uses step through the possible completions.
DONT-CYCLE tells the function not to setup cycling.
(fn &optional START END DONT-CYCLE)
(defalias 'minibuffer-force-complete #[768 "\306\307\206 \310 !\206 d\311\"\312!A\206 \313\\:\2040 \314\203+ \315\202, \316!\202\274 A:\204Z @\317\"\232\211\204H \320@#\210\321\317`\"\322\205T \323#\262\202\274 \320@#\210\211@G\\\262\321\317`\"\324\"\210\325?\205\274 \312!\211@AB\241\210\326A#\266\n \f\327\313\330\331\332 $\333\"\334\335\306&\336\337 \340\341#\210\340\332
!#\210\211\262!\211\"\266\204\207" [minibuffer-scroll-window this-command minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties last-command-event nil copy-marker minibuffer-prompt-end completion-all-sorted-completions last 0 completion--message "No more completions" "No completions" buffer-substring-no-properties completion--replace completion--done finished "Sole completion" sole completion-at-point completion--cache-all-sorted-completions make-byte-code "\303 \305\300`\301\302$)\207" vconcat vector [completion-extra-properties completion-in-region] 5 "Cycle through the possible completions." set-transient-map make-sparse-keymap define-key [remap completion-at-point] completion-cycling] 19 (#$ . 38604) nil])
#@117 List of commands which cause an immediately following
`minibuffer-complete-and-exit' to ask for extra confirmation.
(defvar minibuffer-confirm-exit-commands '(completion-at-point minibuffer-complete minibuffer-complete-word PC-complete PC-complete-word) (#$ . 39977))
#@53 Value of REQUIRE-MATCH passed to `completing-read'.
(defvar minibuffer--require-match nil (#$ . 40251))
#@574 Exit if the minibuffer contains a valid completion.
Otherwise, try to complete the minibuffer contents. If
completion leads to a valid completion, a repetition of this
command will exit.
If `minibuffer-completion-confirm' is `confirm', do not try to
complete; instead, ask for confirmation and accept any input if
confirmed.
If `minibuffer-completion-confirm' is `confirm-after-completion',
do not try to complete; instead, ask for confirmation if the
preceding minibuffer command was a member of
`minibuffer-confirm-exit-commands', and accept the input
otherwise.
(defalias 'minibuffer-complete-and-exit #[0 "\300\301 d\302#\207" [completion-complete-and-exit minibuffer-prompt-end exit-minibuffer] 4 (#$ . 40362) nil])
#@30
(fn BEG END EXIT-FUNCTION)
(defalias 'completion-complete-and-exit #[771 "\300\301\302\303\304\305 #\306\"\307$$\207" [completion--complete-and-exit make-byte-code 0 "\3041 \305\300\301\306\307$0\202 \210\310\211\311\267\202, \302 \202- \204$ \302 \202- \312\313!\210\306\202- \306\207" vconcat vector [minibuffer-completion-confirm (error) completion--do-completion nil expect-exact 1 #s(hash-table size 3 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (3 22 1 22 7 27)) minibuffer-message "Confirm"] 5] 15 (#$ . 41097)])
#@180 Exit from `require-match' minibuffer.
COMPLETION-FUNCTION is called if the current buffer's content does not
appear to be a match.
(fn BEG END EXIT-FUNCTION COMPLETION-FUNCTION)
(defalias 'completion--complete-and-exit #[1028 "U\203 \207\306{ #\203? \n\203< {\307 #\211;\203: \232\204: GGU\203: \310#\210\266 \207 \311>\203a \f
=\204X \312=\203[ \f>\204[ \207\313\314!\210\315\207\211 \207" [minibuffer-completion-table minibuffer-completion-predicate completion-ignore-case minibuffer-completion-confirm last-command this-command test-completion try-completion completion--replace (confirm confirm-after-completion) confirm-after-completion minibuffer-message "Confirm" nil minibuffer-confirm-exit-commands] 10 (#$ . 41658)])
#@40
(fn STRING TABLE PREDICATE POINT MD)
(defalias 'completion--try-word-completion #[1285 "\300%\211:\204 \211\202\342 G@GU\203W \301\302\303\"\304\305#\304\"\306\203M \211:\204M \300\211A\262\242Q\n\n\nT\n%\262\202+ \211:\203U \211\262\266\211A@\304\305#\211\307Q\310\311\"\203\335 \312\313\"\304\305\225\"\304\f\n\"\310\314\307Q\"\205\212 \312\313\"\211\204\225 G\305U\203\333 \310\315\316!\317\203\246 \316!\202\247 \320R\"\203\333 \313\225=\203\333 \310\321\313\224#\203\333 \305\225V\203\333 \305\225\304\305#\304 \"P\262\262\266B\266\204\207" [completion-try-completion mapcar #[257 "\300\301\302#\207" [propertize completion-try-word t] 5 "\n\n(fn STR)"] (" " "-") substring 0 nil "\n" string-match "\\(.+\\)\n.*?\\1" match-string 1 "\\`\\(.+\\).*\n.*\\1" ".*" regexp-quote "\\(.*?\\)" "\\'" "\\W"] 20 (#$ . 42420)])
#@234 Complete the minibuffer contents at most a single word.
After one word is completed as much as possible, a space or hyphen
is added, provided that matches some possible completion.
Return nil if there is no valid completion, else t.
(defalias 'minibuffer-complete-word #[0 "\302\303 d $\207" [minibuffer-completion-table minibuffer-completion-predicate completion-in-region--single-word minibuffer-prompt-end] 5 (#$ . 43317) nil])
#@47
(fn BEG END COLLECTION &optional PREDICATE)
(defalias 'completion-in-region--single-word #[1027 "\302\303#\304\305\"?\205 \306\262*\207" [minibuffer-completion-predicate minibuffer-completion-table completion--do-completion completion--try-word-completion eql 0 t] 8 (#$ . 43755)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\207" [custom-declare-face completions-annotations ((t :inherit italic)) "Face to use for annotations in the *Completions* buffer." custom-declare-variable completions-format funcall function #[0 "\300\207" [horizontal] 1] "Define the appearance and sorting of completions.\nIf the value is `vertical', display completions sorted vertically\nin columns in the *Completions* buffer.\nIf the value is `horizontal', display completions sorted\nhorizontally in alphabetical order, rather than down the screen." :type (choice (const horizontal) (const vertical)) :version "23.2"] 8)
#@162 Insert a list of STRINGS into the current buffer.
Uses columns to keep the listing readable but compact.
It also eliminates runs of equal strings.
(fn STRINGS)
(defalias 'completion--insert-strings #[257 "\211:\205F\301\302\303\304\"\"\305p\306\"\211\203 \307!S\202 \310\311\311\\\245]\312G\311\245]^\245\306G\245\306\313\314\n\211\205B\211@\232\204;\211\262\211:\203Y \315@!\315A@!\\\202\\ \315!\316=\203\260 V\203y \317Zy\210\306\262 \\\262\306V\203\332 \314\210iV\203\235 m\203\224 \320c\210\202\203 \312y\210\314\210\202\203 \321c\210\322`S`\323\324\325
ED#\210\202\332 \204\332 \n ] \\W\203\312 \320c\210\306\262\202\332 \321c\210\322`S`\323\324\325
ED#\210\314\262:\204\357 \326`c\210`\327\330$\210\202\326`@c\210`\327\330$\210`A@c\210`\326\327\314$\210\331\332\333$\266\316=\203-\306V\203#\314y\210\202&\320c\210T\262\202: \334\f\"_\\\262\210A\266\202\2028 \262\266\212\207" [completions-format apply max mapcar #[257 "\211:\203 \300@!\300A@!\\\207\300!\207" [string-width] 4 "\n\n(fn S)"] get-buffer-window 0 window-width 79 2 1 t nil string-width vertical -1 "\n" " " set-text-properties display space :align-to put-text-property mouse-face highlight font-lock-prepend-text-property face completions-annotations ceiling] 21 (#$ . 44710)])
(defvar completion-common-substring nil)
(make-obsolete-variable 'completion-common-substring nil "23.1")
#@300 Normal hook run at the end of setting up a completion list buffer.
When this hook is run, the current buffer is the one in which the
command to display the completion list buffer was run.
The completion list buffer is available as the value of `standard-output'.
See also `display-completion-list'.
(defvar completion-setup-hook nil (#$ . 46153))
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [custom-declare-face completions-first-difference ((t (:inherit bold))) "Face for the first character after point in completions.\nSee also the face `completions-common-part'." completions-common-part ((((class color) (min-colors 16) (background light)) :foreground "blue3") (((class color) (min-colors 16) (background dark)) :foreground "lightblue")) "Face for the parts of completions which matched the pattern.\nSee also the face `completions-first-difference'."] 4)
#@505 Apply font-lock highlighting to a list of completions, COMPLETIONS.
PREFIX-LEN is an integer. BASE-SIZE is an integer or nil (meaning zero).
This adds the face `completions-common-part' to the first
(PREFIX-LEN - BASE-SIZE) characters of each completion, and the face
`completions-first-difference' to the first character after that.
It returns a list with font-lock properties applied to each element,
and with BASE-SIZE appended as the last element.
(fn COMPLETIONS PREFIX-LEN &optional BASE-SIZE)
(defalias 'completion-hilit-commonality #[770 "\205 \206\n \300Z\301\302\303\304\305\306!\307\"\310\311%\"\244\262\207" [0 mapcar make-byte-code 257 "\211:\203 \301@!AB\211\262@\202 \301!\211\262\302\303\300G^\304\305%\210\211G\300V\2034 \302\300\211T\304\306%\210\210\207" vconcat vector [copy-sequence font-lock-prepend-text-property 0 face completions-common-part completions-first-difference] 8 "\n\n(fn ELEM)"] 11 (#$ . 47033)])
#@594 Display the list of completions, COMPLETIONS, using `standard-output'.
Each element may be just a symbol or string
or may be a list of two strings to be printed as if concatenated.
If it is a list of two strings, the first is the actual completion
alternative, the second serves as annotation.
`standard-output' must be a buffer.
The actual completion alternatives, as inserted, are given `mouse-face'
properties of `highlight'.
At the end, this runs the normal hook `completion-setup-hook'.
It can find the completion buffer in `standard-output'.
(fn COMPLETIONS &optional COMMON-SUBSTRING)
(defalias 'display-completion-list #[513 "\211\203\f \303G\304#\262\305!\2049 \306\307!r\211q\210\310\311\312\313\314!\315\"\316$\216p\304\317\"\210*\320\321 !\210*\210\202R rq\210db\210\204J \322c\210\202Q \323c\210\324!\210)\211\325\301!)\210\304\207" [standard-output completion-setup-hook completion-common-substring completion-hilit-commonality nil bufferp generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 display-completion-list princ buffer-string "There are no possible completions of what you have typed." "Possible completions are:\n" completion--insert-strings run-hooks] 9 (#$ . 47997)])
(set-advertised-calling-convention 'display-completion-list '(completions) "24.4")
#@927 Property list of extra properties of the current completion job.
These include:
`:annotation-function': Function to annotate the completions buffer.
The function must accept one argument, a completion string,
and return either nil or a string which is to be displayed
next to the completion (but which is not part of the
completion). The function can access the completion data via
`minibuffer-completion-table' and related variables.
`:exit-function': Function to run after completion is performed.
The function must accept two arguments, STRING and STATUS.
STRING is the text to which the field was completed, and
STATUS indicates what kind of operation happened:
`finished' - text is now complete
`sole' - text cannot be further completed but
completion is not finished
`exact' - text is a valid completion but may be further
completed.
(defvar completion-extra-properties nil (#$ . 49365))
#@297 Function to add annotations in the *Completions* buffer.
The function takes a completion and should either return nil, or a string that
will be displayed next to the completion. The function can access the
completion table and predicates via `minibuffer-completion-table' and related
variables.
(defvar completion-annotate-function nil (#$ . 50352))
(make-obsolete-variable 'completion-annotate-function 'completion-extra-properties "24.1")
#@42
(fn STRING &optional FINISHED MESSAGE)
(defalias 'completion--done #[769 "\303\304\"\211\205\n \305 \306>\204 \307\310!\210\2034 \311=\203/ \312 \n#\313=\203, \314\202- \315\262\"\210\205F \211\205? \305 \232\205F \316!\207" [completion-extra-properties minibuffer-completion-table minibuffer-completion-predicate plist-get :exit-function current-message #1=(exact sole finished unknown) cl--assertion-failed (memq finished '#1#) unknown try-completion t finished exact completion--message] 9 (#$ . 50800)])
#@102 Display a list of possible completions of the current minibuffer contents.
(fn &optional START END)
(defalias 'minibuffer-completion-help #[512 "\306\307!\210\206\n \310 \206 d{\311!\312 `Z%\306\313!\210\211\2034 \211A:\204I \211@\232\203I \314 \210\315 \210\316\203C \317\202D \320!\210\202\267\321!\211A\206R \322\211\322U?\205^ \323\322#\324\325 `\" %\326\327\"\206y \330\n\331\"\206y \332 \333\334\335\336 \337 =\203\212 \340\202\213 \341F
\203\224 \342\202\225 \343
\205\232 \344E\345\346!\211 @\347A\236\350A!\205\256 \211A\262\211\205\301 @\351\352\347\353!A\"BB\313\211rq\210\354\206\317 \"\262)\355\211 A B\n\203\343 \n\313\241\210\326\356\"\211\203\363 \211
!\202\370 \357
\360\"\262\262\f\203\361\362\363\364\365\366\f!\367\"\370\371%
\"\262\fr@q\210\372\373!\210\n\\D;\372\374!\210 \n\362\375\376\365\366$\377\"\201C \201D %\266\203<)\201E \f!\262*\201F e\"\210\203z\201G 1u\201H \201I \313#\210!0\202y\210\202z\210\201I A\236A:\203\246\201J \355\201I A\236A@#\210\201J \313\201I A\236AA#\210\350\313!\203\261\313\"\210)\266)\266\313\207" [minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties completion-annotate-function display-buffer-mark-dedicated temp-buffer-resize-mode message "Making completion list..." minibuffer-prompt-end completion--field-metadata completion-all-completions nil minibuffer-hide-completions ding minibuffer-message "Sole completion" "No completions" last 0 substring completion--metadata buffer-substring-no-properties completion-metadata-get annotation-function plist-get :annotation-function soft display-buffer--maybe-same-window display-buffer-reuse-window display-buffer--maybe-pop-up-frame selected-window minibuffer-window display-buffer-at-bottom display-buffer-below-selected (window-height . resize-temp-buffer-window) (window-height . fit-window-to-buffer) (preserve-size nil . t) temp-buffer-window-setup "*Completions*" window-height functionp (window-height . t) assq-delete-all copy-sequence temp-buffer-window-show t display-sort-function sort string-lessp mapcar make-byte-code 257 "\300!\211\203
D\202 \207" vconcat vector [] 4 "\n\n(fn S)" make-local-variable completion-base-position completion-list-insert-choice-function 771 "\300G\306U\204 \300\307e\300GZ]\"\232\204 \310\311!\210\312#\210\301 \302 \303 \300P\313\301\302\314$\315@G=\203= \316\202> \317\"+\207" [minibuffer-completion-table minibuffer-completion-predicate 0 buffer-substring-no-properties message "*Completions* out of date" completion--replace completion-boundaries "" completion--done exact finished completion-extra-properties] standard-output inhibit-modification-hooks inhibit-read-only 9 "\n\n(fn START END CHOICE)" display-completion-list set-window-point (error) set-window-parameter preserve-size window-preserve-size] 30 (#$ . 51330) nil])
#@49 Get rid of an out-of-date *Completions* buffer.
(defalias 'minibuffer-hide-completions #[0 "\300\301\302\"\211\205# \303!r\304\302\305\306\307!\310\"\311$\216\312@\313\"\210\314 *\262\207" [get-buffer-window "*Completions*" 0 internal--before-with-selected-window make-byte-code "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord bury-buffer] 8 (#$ . 54263)])
#@37 Terminate this minibuffer argument.
(defalias 'exit-minibuffer #[0 "\301\302\303\301\"\207" [deactivate-mark nil throw exit] 3 (#$ . 54677) nil])
#@29 Terminate minibuffer input.
(defalias 'self-insert-and-exit #[0 "\301!\203
\302\303!\210\202 \304 \210\305 \207" [last-command-event characterp call-interactively self-insert-command ding exit-minibuffer] 2 (#$ . 54830) nil])
#@105 Wrapper hook around `completion--in-region'.
(See `with-wrapper-hook' for details about wrapper hooks.)
(defvar completion-in-region-functions nil (#$ . 55066))
(make-obsolete-variable 'completion-in-region-functions 'completion-in-region-function "24.4")
#@214 Function to perform the job of `completion-in-region'.
The function is called with 4 arguments: START END COLLECTION PREDICATE.
The arguments and expected return value are as specified for
`completion-in-region'.
(defvar completion-in-region-function 'completion--in-region (#$ . 55329))
(defvar completion-in-region--data nil)
#@205 Predicate to tell `completion-in-region-mode' when to exit.
It is called with no argument and should return nil when
`completion-in-region-mode' should exit (and hence pop down
the *Completions* buffer).
(defvar completion-in-region-mode-predicate nil (#$ . 55664))
#@169 Copy of the value of `completion-in-region-mode-predicate'.
This holds the value `completion-in-region-mode-predicate' had when
we entered `completion-in-region-mode'.
(defvar completion-in-region-mode--predicate nil (#$ . 55937))
#@466 Complete the text between START and END using COLLECTION.
Point needs to be somewhere between START and END.
PREDICATE (a function called with no arguments) says when to exit.
This calls the function that `completion-in-region-function' specifies
(passing the same four arguments that it received) to do the work,
and returns whatever it does. The return value should be nil
if there was no valid completion, else t.
(fn START END COLLECTION &optional PREDICATE)
(defalias 'completion-in-region #[1027 "`X\204 \301\302\303`D\303$\210$\207" [completion-in-region-function cl--assertion-failed (<= start (point)) nil] 9 (#$ . 56175)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable read-file-name-completion-ignore-case funcall function #[0 "\301>\205 \302\207" [system-type (ms-dos windows-nt darwin cygwin) t] 2] "Non-nil means when reading a file name completion ignores case." :type boolean :version "22.1"] 8)
#@318 Default function to use for `completion-in-region-function'.
Its arguments and return value are as specified for `completion-in-region'.
Also respects the obsolete wrapper hook `completion-in-region-functions'.
(See `with-wrapper-hook' for details about wrapper hooks.)
(fn START END COLLECTION &optional PREDICATE)
(defalias 'completion--in-region #[1027 "\301C\211\302\303\304\305\306!\307\"\310\311%\240\210\211\242\312\300!\205 \313\300!F#\207" [completion-in-region-functions nil make-byte-code 771 ":\2030 @\301=\203 \300\242\302A\"\303#\207\304@\305\306\307\310\311\312\300!\313\"\314\315%A##\207\304\316\"\207" vconcat vector [t append nil apply apply-partially make-byte-code 642 "\300\242#\207" vconcat vector [] 7 "\n\n(fn FUNS GLOBAL &rest ARGS)" #[1028 "\n\203! \304!\203 \202 \305!\305\306\"F\307\310!\210\311\"*\207" [minibuffer-completion-predicate minibuffer-completion-table completion-in-region-mode-predicate completion-in-region--data markerp copy-marker t completion-in-region-mode 1 completion--in-region-1] 8 "\n\n(fn START END COLLECTION PREDICATE)"]] 12 "\n\n(fn FUNS GLOBAL ARGS)" local-variable-p default-value] 12 (#$ . 57148)])
#@49 Keymap activated during `completion-in-region'.
(defvar completion-in-region-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\211\207" [make-sparse-keymap define-key "\277" completion-help-at-point " " completion-at-point] 5) (#$ . 58356))
(defalias 'completion-in-region--postch #[0 "\206. \203+ \303 @!p=\203+ ` @Y\203+ `\212 A@b\210\304 )X\203+ \n \206. \305\306!\207" [unread-command-events completion-in-region--data completion-in-region-mode--predicate marker-buffer line-end-position completion-in-region-mode -1] 2])
(defvar completion-in-region-mode nil)
#@331 Transient minor mode used during `completion-in-region'.
If called interactively, enable Completion-In-Region mode if ARG is
positive, and disable it if ARG is zero or negative. If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.
(fn &optional ARG)
(defalias 'completion-in-region-mode #[256 "\306 \307=\203
?\202 \310!\311V\312\313\314\"\210\315\300 \236 \"\2044 \316\317\320 !\321\232\204I \322 \210\202I \204< \323\303!\210 \324\313\314\"\210\300
B B\325\326\203S \327\202T \330\"\210\331\332!\203x \306 \203h \211\306 \232\203x \333\334\335\203s \336\202t \337#\266\210\340 \210\207" [completion-in-region-mode minor-mode-overriding-map-alist completion-in-region--data completion-in-region-mode-predicate completion-in-region-mode--predicate completion-in-region-mode-map current-message toggle prefix-numeric-value 0 remove-hook post-command-hook completion-in-region--postch delq nil buffer-name window-buffer "*Completions*" minibuffer-hide-completions cl--assertion-failed add-hook run-hooks completion-in-region-mode-hook completion-in-region-mode-on-hook completion-in-region-mode-off-hook called-interactively-p any "" message "Completion-In-Region mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 58943) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(defvar completion-in-region-mode-hook nil)
(byte-code "\302\303N\204\f \304\302\303\305#\210\306\307\310\311\300!\205 \310\211%\210\312\307 \236 \"\310\207" [completion-in-region-mode-map minor-mode-map-alist completion-in-region-mode-hook variable-documentation put "Hook run after entering or leaving `completion-in-region-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 completion-in-region-mode nil boundp delq] 6)
#@1324 Special hook to find the completion table for the entity at point.
Each function on this hook is called in turn without any argument and
should return either nil, meaning it is not applicable at point,
or a function of no arguments to perform completion (discouraged),
or a list of the form (START END COLLECTION . PROPS), where:
START and END delimit the entity to complete and should include point,
COLLECTION is the completion table to use to complete the entity, and
PROPS is a property list for additional information.
Currently supported properties are all the properties that can appear in
`completion-extra-properties' plus:
`:predicate' a predicate that completion candidates need to satisfy.
`:exclusive' value of `no' means that if the completion table fails to
match the text at point, then instead of reporting a completion
failure, the completion should try the next completion function.
As is the case with most hooks, the functions are responsible for
preserving things like point and current buffer.
NOTE: These functions should be cheap to run since they're sometimes
run from `post-command-hook'; and they should ideally only choose
which kind of completion table to use, and not pre-filter it based
on the current text between START and END (e.g., they should not
obey `completion-styles').
(defvar completion-at-point-functions '(tags-completion-at-point-function) (#$ . 60864))
#@201 List of functions found on `completion-at-point-functions' that misbehave.
These are functions that neither return completion data nor a completion
function but instead perform completion right away.
(defvar completion--capf-misbehave-funs nil (#$ . 62283))
#@188 List of well-behaved functions found on `completion-at-point-functions'.
These are functions which return proper completion data rather than
a completion function or god knows what else.
(defvar completion--capf-safe-funs nil (#$ . 62548))
#@18
(fn FUN WHICH)
(defalias 'completion--capf-wrapper #[514 "\211\302\267\202 \202 \235\202 \235?\202 \303\205x \211:\203U \304!\204U \235\2041 B\305\306\233\307\"\310=\203o \311\312@`\"\3138\305\306\233\314\"#\204o \303\262\202o \211<\204o \304!\204o \235\204o \315\316\"\210 B\211\205v B\262\207" [completion--capf-safe-funs completion--capf-misbehave-funs #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (all 6 safe 9 optimist 15)) nil functionp plist-get 3 :exclusive no try-completion buffer-substring-no-properties 2 :predicate message "Completion function %S uses a deprecated calling convention"] 9 (#$ . 62794)])
#@118 Perform completion on the text around point.
The completion method is determined by `completion-at-point-functions'.
(defalias 'completion-at-point #[0 "\302\303\304\305#\306:\203\231 @A\307!\203 \211\211 \262\202\224 \211:\203\221 \211@A\211:\203\210 \211@A\211:\203s \211@A\211C \310\242!\204N \311\242!\240\210\312\313\314\315\316\"\317\"\320$\321\242\322 \323\"$*\266\205\266\202\202\203 A\203\200 \324\325 @\"\210A\266\202\202\214 !\266\202\202\224 !\266\202\202\234 \211!\262\207" [completion-extra-properties completion-in-region-mode-predicate run-hook-wrapped completion-at-point-functions completion--capf-wrapper all #[257 "\211A\203 \300\301@\"\210\211A\207" [message #1="Warning: %S failed to return valid completion data!"] 4 "\n\n(fn RES)"] functionp markerp copy-marker make-byte-code 0 "\301 \242\211\205 \211\300\242U\207" vconcat vector [] 3 completion-in-region plist-get :predicate message #1#] 22 (#$ . 63489) nil])
#@123 Display the completions on the text around point.
The completion method is determined by `completion-at-point-functions'.
(defalias 'completion-help-at-point #[0 "\305\306\307\310#\311:\203\241 @A\312!\203 \211\313\314\"\262\202\234 \211:\203\231 \211@A\211:\203\221 \211@A\211:\203\207 \211@A\211C \315\242!\204P \316\242!\240\210\317\320\"\321\322\323\324\325\"\326\"\327$\242\316\330\"\317\320\"F\331\332!\210\333\242\",\266\205\266\202\202\214 !\266\202\202\224 !\266\202\202\234 !\266\202\202\244 \313\334!\262\207" [minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties completion-in-region-mode-predicate completion-in-region--data run-hook-wrapped completion-at-point-functions completion--capf-wrapper optimist #[257 "\300\301\"\210\302\207" [message "%s already performed completion!" nil] 4 "\n\n(fn HOOKFUN)"] functionp message "Don't know how to show completions for %S" markerp copy-marker plist-get :predicate make-byte-code 0 "\301 \242\211\205 \211\300\242U\207" vconcat vector [] 3 t completion-in-region-mode 1 minibuffer-completion-help "Nothing to complete at point"] 22 (#$ . 64478) nil])
(byte-code "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\307#\210\207" [minibuffer-local-map define-key "" abort-recursive-edit "\274" minibuffer-beginning-of-buffer "
" exit-minibuffer "\n"] 5)
#@52 Local keymap for minibuffer input with completion.
(defvar minibuffer-local-completion-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\313#\210\211\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key " " minibuffer-complete " " minibuffer-complete-word "?" minibuffer-completion-help [prior] switch-to-completions "\366"] 5) (#$ . 65893))
#@69 Local keymap for minibuffer input with completion, for exact match.
(defvar minibuffer-local-must-match-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\305#\210\211\207" [minibuffer-local-completion-map make-sparse-keymap set-keymap-parent define-key "
" minibuffer-complete-and-exit "\n"] 5) (#$ . 66328))
#@169 Local keymap for minibuffer input with completion for filenames.
Gets combined either with `minibuffer-local-completion-map' or
with `minibuffer-local-must-match-map'.
(defvar minibuffer-local-filename-completion-map (byte-code "\300 \301\302\303#\210\211\207" [make-sparse-keymap define-key " " nil] 5) (#$ . 66655))
(byte-code "\300\301\302\303#\210\304\211\203( \211@\301N\203! \302N\204! \305\302\301N#\210A\266\202\202 \210\306\301\302\307#\207" [defvaralias minibuffer-local-must-match-filename-map minibuffer-local-filename-must-match-map nil (saved-value saved-variable-comment) put make-obsolete-variable "23.1"] 7)
(defvar minibuffer-local-filename-must-match-map (make-sparse-keymap))
(byte-code "\301\302\303\304#\210\305\306\307#\210\305\310\307#\210\305\311\312#\210\207" [minibuffer-local-ns-map make-obsolete-variable minibuffer-local-filename-must-match-map nil "24.1" define-key " " exit-minibuffer " " "?" self-insert-and-exit] 5)
#@212 Keymap for use in the minibuffer when it is not active.
The non-mouse bindings in this keymap can only be used in minibuffer-only
frames, since the minibuffer can normally not be selected when it is
not active.
(defvar minibuffer-inactive-mode-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\211\207" [make-keymap suppress-keymap define-key "e" find-file-other-frame "f" "b" switch-to-buffer-other-frame "i" info "m" mail "n" make-frame [mouse-1] view-echo-area-messages [down-mouse-1] ignore] 5) (#$ . 67623))
(defvar minibuffer-inactive-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [minibuffer-inactive-mode-hook variable-documentation put "Hook run after entering InactiveMinibuffer mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp minibuffer-inactive-mode-map definition-name minibuffer-inactive-mode] 4)
(defvar minibuffer-inactive-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\311\312 !\210\306\301N\204- \302\306\301\303\313!#\210\302\310\314\315#\207" [minibuffer-inactive-mode-map variable-documentation put purecopy "Keymap for `minibuffer-inactive-mode'." boundp minibuffer-inactive-mode-syntax-table definition-name minibuffer-inactive-mode (lambda (#1=#:def-tmp-var) (defvar minibuffer-inactive-mode-syntax-table #1#)) make-syntax-table "Syntax table for `minibuffer-inactive-mode'." derived-mode-parent nil] 5)
#@261 Major-mode.
Uses keymap `minibuffer-inactive-mode-map' and syntax-table `minibuffer-inactive-mode-syntax-table'.
This mode runs the hook `minibuffer-inactive-mode-hook', as the final or penultimate step
during initialization.
\{minibuffer-inactive-mode-map}
(defalias 'minibuffer-inactive-mode #[0 "\305\300!\210\306\307 \210\310\311\312 !\210\313\f!\210)\314\315!\207" [delay-mode-hooks major-mode mode-name minibuffer-inactive-mode-map minibuffer-inactive-mode-syntax-table make-local-variable t kill-all-local-variables minibuffer-inactive-mode "InactiveMinibuffer" use-local-map set-syntax-table run-mode-hooks minibuffer-inactive-mode-hook] 2 (#$ . 69315) nil])
#@12
(fn STR)
(defalias 'minibuffer--double-dollars #[257 "\300\301\302#\207" [replace-regexp-in-string "\\$" #[257 "\211P\207" [] 3 "\n\n(fn DOLLAR)"]] 5 (#$ . 69993)])
#@142 Protect FILENAME from `substitute-in-file-name', as needed.
Useful to give the user default values that won't be substituted.
(fn FILENAME)
(defalias 'minibuffer-maybe-quote-filename #[257 "\211\303\211?\205 \304\305\306!\")\266\202\204c \307!\203c \310>\203% \311\202& \312\306!\303\313\314#)\266\203\203c \211\303\211?\205? \211?\205H \304\305\306!\")\266\202\203Y \202a \315!\305\306!Q)\207\316!\207" [file-name-handler-alist system-type inhibit-changing-match-data nil string-prefix-p "/:" file-local-name file-name-absolute-p (windows-nt ms-dos) "[/\\]~" "/~" t string-match file-remote-p minibuffer--double-dollars] 9 (#$ . 70169)])
(defalias 'completion--make-envvar-table #[0 "\301\302\"\207" [process-environment mapcar #[257 "\301\302\303\304\305\306#)\266\203#\207" [inhibit-changing-match-data substring 0 "=" nil t string-match] 11 "\n\n(fn ENVENTRY)"]] 3])
(defconst completion--embedded-envvar-re "\\(?:^\\|[^$]\\(?:\\$\\$\\)*\\)\\$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'")
#@182 Completion table for envvars embedded in a string.
The envvar syntax (and escaping) rules followed by this table are the
same as `substitute-in-file-name'.
(fn STRING PRED ACTION)
(defalias 'completion--embedded-envvar-table #[771 "\302\"\205~ \303\224\206 \304\224\305 \306\307#\310=\203 \311\202| \242\312=\204, \313=\203\\ \314\306\"\311#\205| \313=\203B \315\202| A\312\303\224\206L \304\224\302\316\"\205U \307\224BB\262\202| SH\317=\203l \320\321\322#\262\311\323\306 \"\311%)\266\203\207" [completion--embedded-envvar-re completion-ignore-case string-match 2 1 completion--make-envvar-table substring 0 lambda nil boundaries metadata try-completion (metadata (category . environment-variable)) "[^[:alnum:]_]" 123 apply-partially completion-table-with-terminator "}" completion-table-with-context] 12 (#$ . 71193)])
#@59 Completion table for file names.
(fn STRING PRED ACTION)
(defalias 'completion-file-name-table #[771 "\3021\335 \211\303=\203 \304\202\333 \305\306\307\310#)\266\203\2030 \311\312\313\314\315 \"\316\317\"%\202\333 \211\242\320=\203W \321!G\322A\306\307\310#)\266\203\320G^BB\266\202\202\333 \211\323=\203o G\324U?\205\333 \206j \325!\202\333 \326!\321!\211\206z \204\225 \327#\211;\203\217 P\202\220 \211\262\202\331 \307=\205\331 \330\"\331>\204\326 \306\332=\203\261 \333\202\263 \334!\211\203\320 \211@!\203\311 \211B\262A\266\202\202\270 \210)\237\266\203\211\262\266\2030\207\210\306\207" [inhibit-changing-match-data default-directory (file-error) metadata (metadata (category . file)) "\\`~[^/\\]*\\'" nil t string-match completion-table-with-context "~" mapcar #[257 "\211\300P\207" ["/"] 3 "\n\n(fn U)"] system-users substring 1 boundaries file-name-directory "/" lambda 0 file-exists-p file-name-nondirectory file-name-completion file-name-all-completions (nil file-exists-p) file-directory-p #[257 "\211G\211\300V\205 SH\301=\207" [0 47] 4 "\n\n(fn S)"] expand-file-name] 13 (#$ . 72052)])
#@54 Current predicate used by `read-file-name-internal'.
(defvar read-file-name-predicate nil (#$ . 73215))
(make-obsolete-variable 'read-file-name-predicate "use the regular PRED argument" "23.2")
#@18
(fn UPOS QSTR)
(defalias 'completion--sifn-requote #[514 "\300!\301\302#\303\304\305\"\211\205 \301\302#\262\306\300!\"\262\203) \211\262\202 G\211\302V\203H \306\300\301\302S#!\"\203H \211S\262\202+ \211\307B\262\207" [substitute-in-file-name substring 0 nil string-match "\\(\\$+{?\\)?\\w+\\W*\\'" string-prefix-p minibuffer-maybe-quote-filename] 13 (#$ . 73415)])
(byte-code "\300\301\302\303\304\305#\306#\210\300\307\310\311\301\"\312#\207" [defalias completion--file-name-table completion-table-with-quoting completion-file-name-table substitute-in-file-name completion--sifn-requote "Internal subroutine for `read-file-name'. Do not call this.\nThis is a completion table for file names, like `completion-file-name-table'\nexcept that it passes the file name through `substitute-in-file-name'." read-file-name-internal completion-table-in-turn completion--embedded-envvar-table "Internal subroutine for `read-file-name'. Do not call this."] 6)
#@114 The function called by `read-file-name' to do its work.
It should accept the same arguments as `read-file-name'.
(defvar read-file-name-function 'read-file-name-default (#$ . 74398))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\313\314\306\307&\207" [custom-declare-variable insert-default-directory funcall function #[0 "\300\207" [t] 1] "Non-nil means when reading a filename start with default dir in minibuffer.\n\nWhen the initial minibuffer contents show a name of a file or a directory,\ntyping RETURN without editing the initial contents is equivalent to typing\nthe default file name.\n\nIf this variable is non-nil, the minibuffer contents are always\ninitially non-empty, and typing RETURN without editing will fetch the\ndefault name, if one is provided. Note however that this default name\nis not necessarily the same as initial contents inserted in the minibuffer,\nif the initial contents is just the default directory.\n\nIf this variable is nil, the minibuffer often starts out empty. In\nthat case you may have to explicitly fetch the next history element to\nrequest the default name; typing RETURN without editing will leave\nthe minibuffer empty.\n\nFor some commands, exiting with an empty minibuffer has a special meaning,\nsuch as making the current buffer visit no file in the case of\n`set-visited-file-name'." :type boolean minibuffer-beginning-of-buffer-movement #[0 "\300\207" [nil] 1] "Control how the `M-<' command in the minibuffer behaves.\nIf non-nil, the command will go to the end of the prompt (if\npoint is after the end of the prompt). If nil, it will behave\nlike the `beginning-of-buffer' command." :version "27.1"] 8)
#@30
(fn &optional DIR INITIAL)
(defalias 'read-file-name--defaults #[512 "\211\203\n \302!\202 \205 \302!\303\304!\211\203& \305\306\307\310\311D\"\"!\262\312 <\2030 \2022 C<\203; \202= C\"\207" [buffer-file-name minibuffer-default abbreviate-file-name run-hook-with-args-until-success file-name-at-point-functions delete-dups delete "" delq nil append] 11 (#$ . 76102)])
#@2690 Read file name, prompting with PROMPT and completing in directory DIR.
The return value is not expanded---you must call `expand-file-name' yourself.
DIR is the directory to use for completing relative file names.
It should be an absolute directory name, or nil (which means the
current buffer's value of `default-directory').
DEFAULT-FILENAME specifies the default file name to return if the
user exits the minibuffer with the same non-empty string inserted
by this function. If DEFAULT-FILENAME is a string, that serves
as the default. If DEFAULT-FILENAME is a list of strings, the
first string is the default. If DEFAULT-FILENAME is omitted or
nil, then if INITIAL is non-nil, the default is DIR combined with
INITIAL; otherwise, if the current buffer is visiting a file,
that file serves as the default; otherwise, the default is simply
the string inserted into the minibuffer.
If the user exits with an empty minibuffer, return an empty
string. (This happens only if the user erases the pre-inserted
contents, or if `insert-default-directory' is nil.)
Fourth arg MUSTMATCH can take the following values:
- nil means that the user can exit with any input.
- t means that the user is not allowed to exit unless
the input is (or completes to) an existing file.
- `confirm' means that the user can exit with any input, but she needs
to confirm her choice if the input is not an existing file.
- `confirm-after-completion' means that the user can exit with any
input, but she needs to confirm her choice if she called
`minibuffer-complete' right before `minibuffer-complete-and-exit'
and the input is not an existing file.
- anything else behaves like t except that typing RET does not exit if it
does non-null completion.
Fifth arg INITIAL specifies text to start with.
Sixth arg PREDICATE, if non-nil, should be a function of one
argument; then a file name is considered an acceptable completion
alternative only if PREDICATE returns non-nil with the file name
as its argument.
If this command was invoked with the mouse, use a graphical file
dialog if `use-dialog-box' is non-nil, and the window system or X
toolkit in use provides a file dialog box, and DIR is not a
remote file. For graphical file dialogs, any of the special values
of MUSTMATCH `confirm' and `confirm-after-completion' are
treated as equivalent to nil. Some graphical file dialogs respect
a MUSTMATCH value of t, and some do not (or it only has a cosmetic
effect, and does not actually prevent the user from entering a
non-existent file).
See also `read-file-name-completion-ignore-case'
and `read-file-name-function'.
(fn PROMPT &optional DIR DEFAULT-FILENAME MUSTMATCH INITIAL PREDICATE)
(defalias 'read-file-name #[1537 "\206 \301&\207" [read-file-name-function read-file-name-default] 13 (#$ . 76494)])
#@63 Syntax table used when reading a file name in the minibuffer.
(defvar minibuffer-local-filename-syntax (byte-code "\300 \301\302\303\304\305\306\307\"\310\"\311\312%\"\210\313\303\314\315\306\307!\316\"\317\320%\321\"\210\207" [make-syntax-table 1 map-char-table make-byte-code 514 "\211@\301=\205\f \302\303\300#\207" vconcat vector [modify-syntax-entry "_"] 6 "\n\n(fn C SYNTAX)" mapc 257 "\301\302\300#\207" [modify-syntax-entry "."] 5 "\n\n(fn C)" (47 58 92)] 10) (#$ . 79321))
#@167 Default method for reading file names.
See `read-file-name' for the meaning of the arguments.
(fn PROMPT &optional DIR DEFAULT-FILENAME MUSTMATCH INITIAL PREDICATE)
(defalias 'read-file-name-default #[1537 "\204 \206 \306\262\307!\204 \310!\262\2043 \204\" \2021 \311\232\203, \2021 \310\"\262\312!\262\203M :\203H \313\312\"\202K \312!\262\n\203n ;\203n \203h \314P!\314!GB\202w \314!\202w \205w \314!\315B \316\206~ \317\320 \321 \203\217 \322\n!\203\341 \323\310 !!\324\315\325\326\327\f #\330\"\331$\320C\211\324\315\332\326\327\"\333\"\334$\240\210\324\315\335\326\327!\336\"\334$\216\337\340\242\"\210\341\342\f\343&)\266\202\262\202*\344\n!\345>?\n\204\377 G\315U\204\377 \262 \346\f!\262\f\n\203\310 :\203 @\202
\"\262 \316\262\347
\f\350=%\266\202#\242=\n:\203:\n@\262 =\203K\211\204H\316\262\311\262\204S\351\352!\210\n\203o:\203e@\202g\230\203o\n\262\353!\262\211\203\247\314!.\203\212#\354#A\"\241\210\211#A@\230\203\236#\210#A#\202\243#\240\210\210\202\262\203\262\355\343\314!\"\210\266\202*\266\204\207" [default-directory buffer-file-name insert-default-directory read-file-name-completion-ignore-case minibuffer-completing-file-name completion-ignore-case "~/" file-name-absolute-p expand-file-name "" abbreviate-file-name mapcar minibuffer-maybe-quote-filename 0 t file-exists-p nil next-read-file-uses-dialog-p file-remote-p file-name-as-directory make-byte-code "\302\301\242\206 \301\f\242\206 \f\232\203 \f\243\306\305!\210\307\310\311\312\313\300\302\"\314\"\315$\316!\207" vconcat vector [default-directory minibuffer-default minibuffer-default-add-function make-local-variable make-byte-code 0 "r\302\303 !q\210\304\301\300\")\207" vconcat vector [window-buffer minibuffer-selected-window read-file-name--defaults] 3 set-syntax-table minibuffer-local-filename-syntax] 7 "\302\303\301\242\"\210\300 \207" [remove-hook minibuffer-setup-hook] 3 "\301\302\300\242\"\207" [remove-hook minibuffer-setup-hook] add-hook minibuffer-setup-hook completing-read read-file-name-internal file-name-history file-name-nondirectory (nil confirm confirm-after-completion) file-name-directory x-file-dialog file-directory-p error "No file name specified" substitute-in-file-name delete add-to-history history-delete-duplicates] 22 (#$ . 79820)])
#@206 Perform completion on all buffers excluding BUFFER.
BUFFER nil or omitted means use the current buffer.
Like `internal-complete-buffer', but removes BUFFER from the completion list.
(fn &optional BUFFER)
(defalias 'internal-complete-buffer-except #[256 "\211;\203 \211\202\f \300!\301\302\303\304\305\306\307\310!\311\"\312\313%\314$\207" [buffer-name apply-partially completion-table-with-predicate internal-complete-buffer make-byte-code 257 "\211:\203\n \211@\202 \211\300\232?\207" vconcat vector [] 3 "\n\n(fn NAME)" nil] 11 (#$ . 82227)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs21-try-completion #[1028 "\300#\211;\203 \211GB\202 \211\207" [try-completion] 8 (#$ . 82784)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs21-all-completions #[1028 "\300\301#G\302\303$@#\207" [completion-hilit-commonality all-completions completion-boundaries ""] 12 (#$ . 82950)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs22-try-completion #[1028 "\300\"\301\300\302##\211;\204 \211\202C \211G\302U\204= \211GSH\303=\203= G\302U\204= \302H\303=\203= \300\304\"\262\211PGB\207" [substring try-completion 0 47 1] 10 (#$ . 83168)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-emacs22-all-completions #[1028 "\300\301#\302\303#\304\305$@#\207" [substring 0 completion-hilit-commonality all-completions completion-boundaries ""] 13 (#$ . 83454)])
#@170 Merge end of COMPLETION with beginning of SUFFIX.
Simple generalization of the "merge trailing /" done in Emacs-22.
Return the new suffix.
(fn COMPLETION POINT SUFFIX)
(defalias 'completion--merge-suffix #[771 "\211G\300U\204# \301\302\303Q#\203# \304\225G=\203# \305\304\225\304\224Z\"\207\207" [0 string-match "\\(.+\\)\n\\1" "\n" 1 substring] 8 (#$ . 83696)])
#@38
(fn BEFOREPOINT AFTERPOINT BOUNDS)
(defalias 'completion-basic--pattern #[771 "\300@\"\301\300\302A#E\207" [substring point 0] 9 (#$ . 84071)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-basic-try-completion #[1028 "\301\302#\301\"\303$\211A\302U\2039 \304#\211;\204( \211\2024 \211\305#PGB\262\202h \301A\"\301\302@#\306\307#!\310 $\203_ \311!\262\312$\266\204\207" [minibuffer-completing-file-name substring 0 completion-boundaries try-completion completion--merge-suffix completion-pcm--optimize-pattern completion-basic--pattern completion-pcm--all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 16 (#$ . 84227)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-basic-all-completions #[1028 "\300\301#\300\"\302$\300\301@#\303\304\300@\"\305\300\301A#E\"\306\n\n$\307@#\207" [substring 0 completion-boundaries delete "" point completion-pcm--all-completions completion-hilit-commonality] 16 (#$ . 84790)])
#@404 Regular expression matching delimiters controlling the partial-completion.
Typically, this regular expression simply matches a delimiter, meaning
that completion can add something at (match-beginning 0), but if it has
a submatch 1, then completion can add something at (match-end 1).
This is used when the delimiter needs to be of size zero (e.g. the transition
from lowercase to uppercase characters).
(defvar completion-pcm--delim-wild-regex nil (#$ . 85122))
#@15
(fn DELIMS)
(defalias 'completion-pcm--prepare-delim-re #[257 "\301\302Q\211\207" [completion-pcm--delim-wild-regex "[" "*]"] 4 (#$ . 85590)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \210\300\314\302\303\315DD\316\317\320\312\321&\207" [custom-declare-variable completion-pcm-word-delimiters funcall function #[0 "\300\207" [#1="-_./:| "] 1 #1#] "A string of characters treated as word delimiters for completion.\nSome arcane rules:\nIf `]' is in this string, it must come first.\nIf `^' is in this string, it must not come first.\nIf `-' is in this string, it must come first or right after `]'.\nIn other words, if S is this string, then `[S]' must be a valid Emacs regular\nexpression (not containing character ranges like `a-z')." :set #[514 "\300\"\210\301!\207" [set-default completion-pcm--prepare-delim-re] 5 "\n\n(fn SYMBOL VALUE)"] :initialize custom-initialize-reset :type string completion-pcm-complete-word-inserts-delimiters #[0 "\300\207" [nil] 1] "Treat the SPC or - inserted by `minibuffer-complete-word' as delimiters.\nThose chars are treated as delimiters if this variable is non-nil.\nI.e. if non-nil, M-x SPC will just insert a \"-\" in the minibuffer, whereas\nif nil, it will list all possible commands in *Completions* because none of\nthe commands start with a \"-\" or a SPC." :version "24.1" boolean] 10)
#@16
(fn PATTERN)
(defalias 'completion-pcm--pattern-trivial-p #[257 "\211@;\205# \300A\211\203 \211@\211\301\235\204 \302\262A\266\202\202 \210\211\262\207" [t (point "") nil] 6 (#$ . 86961)])
#@171 Split STRING into a pattern.
A pattern is a list where each element is either a string
or a symbol, see `completion-pcm--merge-completions'.
(fn STRING &optional POINT)
(defalias 'completion-pcm--string->pattern #[513 "\211\203 \211GW\203 \302\303#\302\"\304\305!\306\305!#\207\307\303\211\307\310#\211\262\203\234 \204; \311\312#\204\234 \313\225\203D \313\225\262U\204] \211\203S \211B\262\302#B\262\307\262H\314=\203t \315B\262T\262\202\226 \316B\262\313\225\203\204 \262\202\226 \302\303\225#B\262\317\262\303\225\262\262\202\" GV\203\265 \211\203\254 \211B\262\302\"B\262\237\207" [completion-pcm--delim-wild-regex completion-pcm-complete-word-inserts-delimiters substring 0 append completion-pcm--string->pattern (point) nil string-match get-text-property completion-try-word 1 42 star any any-delim] 10 (#$ . 87166)])
#@10
(fn P)
(defalias 'completion-pcm--optimize-pattern #[257 "\211C\211\300\301\242\"\240\210\302C\242\203\234 \303\242:\203\223 \242@\211\304>\203n \242A\211:\203U \211@\211\305=\203? A\211\305B\240\266\202Q \242\211\242A\240\210\242\242B\240\210\210\202j 9\203^ \211\203f \"\210\202j \302\240\210\210\202\217 \2119\203\212 \242A\211\204\201 \302\240\210\202\206 \"\210\210\202\217 \"\210\210\202\230 \211\"\210\210\202\f \211\242\237\262\207" [delete "" nil #[514 "\211\242\211\242A\240\210\242\242B\240\207" [] 6 "\n\n(fn P N)"] (any-delim any) point] 12 (#$ . 88057)])
#@32
(fn PATTERN &optional GROUP)
(defalias 'completion-pcm--pattern->regex #[513 "\300\301\302\303\304\305\306!\307\"\310\311%\312#P\313\314\"\203& \315\312\316\211\317%\262\202 \211\207" ["\\`" mapconcat make-byte-code 257 "\211;\203 \302!\207\211\303=\203 \304P\202 \305\300:\203! \300>\202\" \300\203, \306\307Q\202- \211\207" vconcat vector [completion-pcm--delim-wild-regex regexp-quote any-delim "*?" ".*?" "\\(" "\\)"] 5 "\n\n(fn X)" "" string-match "\\.\\*\\?\\(?:\\\\[()]\\)*\\(\\.\\*\\?\\)" replace-match t 1] 10 (#$ . 88670)])
#@124 Return index of subgroup corresponding to `point' element of PATTERN.
Return nil if there's no such element.
(fn PATTERN)
(defalias 'completion-pcm--pattern-point-idx #[257 "\300\301\211\203\" \211@\211;\204 T\262\211\302=\203 \262A\266\202\202 \210\207" [nil 0 point] 7 (#$ . 89227)])
#@150 Find all completions for PATTERN in TABLE obeying PRED.
PATTERN is as returned by `completion-pcm--string->pattern'.
(fn PREFIX PATTERN TABLE PRED)
(defalias 'completion-pcm--all-completions #[1028 "\304!\203 \305@P#\207\306!\211\nB\305@;\203% @\202& \307P#\310!\2044 \211\202] \311\211\203X \211@\311\312\313#)\266\203\203Q \211B\262A\266\202\2026 \210\211\237\262*\207" [completion-ignore-case case-fold-search completion-regexp-list inhibit-changing-match-data completion-pcm--pattern-trivial-p all-completions completion-pcm--pattern->regex "" functionp nil t string-match] 16 (#$ . 89531)])
#@565 Controls how the `flex' completion style scores its matches.
Value is a positive number. A number smaller than 1 makes the
scoring formula reward matches scattered along the string, while
a number greater than one make the formula reward matches that
are clumped together. I.e "foo" matches both strings
"fbarbazoo" and "fabrobazo", which are of equal length, but
only a value greater than one will score the former (which has
one large "hole" and a clumped-together "oo" match) higher
than the latter (which has two "holes" and three
one-letter-long matches).
(defvar flex-score-match-tightness 3 (#$ . 90162))
#@28
(fn PATTERN COMPLETIONS)
(defalias 'completion-pcm--hilit-commonality #[514 "\211\205\" \302\303\"\304!\305\306\307\310\311\312\"\313\"\314\315%\")\266\202\207" [completion-ignore-case case-fold-search completion-pcm--pattern->regex group completion-pcm--pattern-point-idx mapcar make-byte-code 257 "\211C\211\302\242!\240\210\303\300\242\"\204 \304\305\300\242#\210\301\203! \301\224\202# \306\225\307 \211A\262\242\211A\262\242\242G\306C\306C\306C\310\211\n \211&\210\203w \211\n
@&\210\311 \211A\262 \242\312\313\242%\210\211A\262 \242\262\202G \211\n \211&\210\311\312\313\242%\210 \242G V\203\245 \311 \211T\314\313\242%\210 \242G\306U\204\304 \315\306\316\317\320\242\n \242T_\321#\242%\210\266 \211\242\207" vconcat vector [copy-sequence string-match error "Internal error: %s does not match %s" 0 match-data #[1542 "\211\242Z\\\240\210\242U\2045 \242\301U\2045 \242GU\2045 \302\242\303\304\305 \242\303#\306\245\"#\240\210\240\207" [flex-score-match-tightness 0 + 1 expt - 1.0] 15 "Update score variables given match range (A B).\n\n(fn STR SCORE-NUMERATOR SCORE-DENOMINATOR LAST-B A B)"] add-face-text-property completions-common-part nil completions-first-difference put-text-property 1 completion-score / 1.0] 19 "\n\n(fn STR)"] 12 (#$ . 90783)])
#@294 Find all completions for STRING at POINT in TABLE, satisfying PRED.
POINT is a position inside STRING.
FILTER is a function applied to the return value, that can be used, e.g. to
filter out additional entries (because TABLE might not obey PRED).
(fn STRING TABLE PRED POINT &optional FILTER)
(defalias 'completion-pcm--find-all-completions #[1284 "\211\204 \300\262\301\302#\301\"\303$\301\302@#\301A\"\304\301 @\nA\\#\262 @Z\305\306
\"!\3071S \310$!0\202Y \211\262\304\262\211\204@\302V\203\3111u \312#0\202w \210\304\204\301\302\313#\314G%\211@A\211@A\211@A\211@A\n\211GSH\304C\304\262\211\203\312 \211@\211GSH=\203\303 \211B\262A\266\202\202\255 \210\203f@\301 \302#QG@G\\\303 $AA=\203\371 \211@=\204-\211@W\204-\301A\"\262\301@\"\301 \302A#P\262!\301@#\240\210\305\306\"G@Z\"!\262\211\203d\211@\315\316\317\320\321\322 \"\323\"\324\325% \310
\242Q''$!\"\244\262A\266\202\202/\266\326\327\330!D\242\205u\242C$\262\262\266\211\204\220\203\220\331@A\"\202\227F\266\203\207" [identity substring 0 completion-boundaries nil completion-pcm--optimize-pattern completion-pcm--string->pattern (debug error) completion-pcm--all-completions (error) try-completion -1 completion-pcm--find-all-completions mapcar make-byte-code 257 "\301\300\242Q\207" vconcat vector [] 4 "\n\n(fn S)" append any string signal] 43 (#$ . 92133)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-pcm-all-completions #[1028 "\300$\211@A\211@A\211@A\211@A\n\205' \301\"G\244\266\204\207" [completion-pcm--find-all-completions completion-pcm--hilit-commonality] 20 (#$ . 93624)])
#@58 Return the common suffix of the strings STRS.
(fn STRS)
(defalias 'completion--common-suffix #[257 "\300\301\302\303\"\"\237\207" [try-completion "" mapcar reverse] 6 (#$ . 93881)])
#@770 Extract the commonality in STRS, with the help of PATTERN.
PATTERN can contain strings and symbols chosen among `star', `any', `point',
and `prefix'. They all match anything (aka ".*") but are merged differently:
`any' only grows from the left (when matching "a1b" and "a2b" it gets
completed to just "a").
`prefix' only grows from the right (when matching "a1b" and "a2b" it gets
completed to just "b").
`star' grows from both ends and is reified into a "*" (when matching "a1b"
and "a2b" it gets completed to "a*b").
`point' is like `star' except that it gets reified as the position of point
instead of being reified as a "*" character.
The underlying idea is that we should return a string which still matches
the same set of elements.
(fn STRS PATTERN)
(defalias 'completion-pcm--merge-completions #[514 "A\204 @C\207\302\303\"\304\211\203\\ \211@\305\"\204% \306\307#\210\304\310\311\304\225\211\262\203D \312#B\262\211\262T\262\202) \312\"B\262\237B\262\266A\266\202\202 \210)\304\313\314\315\"\211\203 \211@\211;\203w P\262\202\304\304\262\211\203\226 \211@\211@B\262\211AB\262A\266\202\202| \210\237\262\316\"\211\317=\203\254 \211\262\206\262 \316\"\317=\320=\204\304 \313\232\204\304 B\262\211\204B\262\321>\203\322\317#\204\323G\310U\203\350 \202\375 G\324\325\326\327\330\331!\332\"\333\334%\"\262!\211;\204\335\336!\210\211\313\232\204\211B\262\210\313\262\266A\266\202\202d \210\266\202\207" [completion-ignore-case case-fold-search completion-pcm--pattern->regex group nil string-match error "Internal error: %s doesn't match %s" 0 1 substring "" append (any) try-completion t prefix (star point prefix) assoc-string completion--common-suffix mapcar make-byte-code 257 "\301\300\"\207" vconcat vector [substring] 4 "\n\n(fn STR)" cl--assertion-failed (stringp suffix)] 20 (#$ . 94072)])
#@16
(fn PATTERN)
(defalias 'completion-pcm--pattern->string #[257 "\300\301\302#\207" [mapconcat #[257 "\211;\203 \207\211\300=\203 \301\207\302\207" [star "*" #1=""] 3 "\n\n(fn X)"] #1#] 5 (#$ . 95987)])
#@76 Filter to adjust `all' file completion to the behavior of `try'.
(fn ALL)
(defalias 'completion-pcm--filename-try-filter #[257 "\211\2057 \302\303\304!\305Q\211\203. \211@\302\306\307#)\266\203\204' \211B\262A\266\202\202\f \210\237\2065 \266\202\207" [completion-ignored-extensions inhibit-changing-match-data nil "\\(?:\\`\\.\\.?/\\|" regexp-opt "\\)\\'" t string-match] 12 (#$ . 96199)])
#@34
(fn PATTERN ALL PREFIX SUFFIX)
(defalias 'completion-pcm--merge-try #[1028 ":\204 \207A:\204 \300!@\232\203 \301\207\302\"\303>\206/ \304>\206/ \305>\206/ \211\300!G\300\237!\306\307GS]#\262QG\\B\207" [completion-pcm--pattern->string t completion-pcm--merge-completions point any star completion--merge-suffix 0] 12 (#$ . 96610)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-pcm-try-completion #[1028 "\301\205\n \302%\211@A\211@A\211@A\211@A\n\303$\266\204\207" [minibuffer-completing-file-name completion-pcm--find-all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 22 (#$ . 96976)])
#@263 Match the presumed substring STRING to the entries in TABLE.
Respect PRED and POINT. The pattern used is a PCM-style
substring pattern, but it be massaged by TRANSFORM-PATTERN-FN, if
that is non-nil.
(fn STRING TABLE PRED POINT &optional TRANSFORM-PATTERN-FN)
(defalias 'completion-substring--all-completions #[1284 "\300\301#\300\"\302$\300A\"\300\301@#\303#\211@;\204, \211\202/ \304B\305\203< !\202= !\306$\211\n@\257\207" [substring 0 completion-boundaries completion-basic--pattern prefix completion-pcm--optimize-pattern completion-pcm--all-completions] 19 (#$ . 97294)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-substring-try-completion #[1028 "\301$\211@A\211@A\211@A\211@A\211@A\n
\203+ \302!\262\303$\266\205\207" [minibuffer-completing-file-name completion-substring--all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 25 (#$ . 97918)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-substring-all-completions #[1028 "\300$\211@A\211@A\211@A\211@A\211@A\n
\211\205- \301\"G\244\266\205\207" [completion-substring--all-completions completion-pcm--hilit-commonality] 23 (#$ . 98257)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\312\313\314\315#\207" [custom-declare-variable completion-flex-nospace funcall function #[0 "\300\207" [nil] 1] "Non-nil if `flex' completion rejects spaces in search pattern." :version "27.1" :type boolean put flex completion--adjust-metadata completion--flex-adjust-metadata] 8)
#@17
(fn METADATA)
(defalias 'completion--flex-adjust-metadata #[257 "\300\301\302\303\302\"!B\304\303\304\"!BABBB\207" [#[257 "\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 257 "\300\203\n \300!\202 \211\301 \203 d\302 V\203 \303\304\"\202 \211\207" vconcat vector [window-minibuffer-p minibuffer-prompt-end sort #[514 "\300\301\302#\300\301\302#\206 \301\206 \301V\207" [get-text-property 0 completion-score] 7 "\n\n(fn C1 C2)"]] 5 "\n\n(fn COMPLETIONS)"] 7 "\n\n(fn EXISTING-SORT-FN)"] metadata display-sort-function completion-metadata-get cycle-sort-function] 9 (#$ . 98875)])
#@236 Convert PCM-style PATTERN into PCM-style flex pattern.
This turns
(prefix "foo" point)
into
(prefix "f" any "o" any "o" any point)
which is at the core of flex logic. The extra
'any' is optimized away later on.
(fn PATTERN)
(defalias 'completion-flex--make-flex-pattern #[257 "\300\301\"\207" [mapcan #[257 "\211;\203\n \300\301\"\207\211C\207" [mapcan #[257 "\300!\301D\207" [string any] 3 "\n\n(fn CHAR)"]] 4 "\n\n(fn ELEM)"]] 4 (#$ . 99492)])
#@90 Try to flex-complete STRING in TABLE given PRED and POINT.
(fn STRING TABLE PRED POINT)
(defalias 'completion-flex-try-completion #[1028 "\205 \303\304\305\306#)\266\203?\205L \307\310%\211@A\211@A\211@A\211@A\211@A\n
\n\203A \311!\262\312$\266\205\266\213\207" [completion-flex-nospace inhibit-changing-match-data minibuffer-completing-file-name " " nil t string-match completion-substring--all-completions completion-flex--make-flex-pattern completion-pcm--filename-try-filter completion-pcm--merge-try] 25 (#$ . 99958)])
#@94 Get flex-completions of STRING in TABLE, given PRED and POINT.
(fn STRING TABLE PRED POINT)
(defalias 'completion-flex-all-completions #[1028 "\205 \302\303\304\305#)\266\203?\205G \306\307%\211@A\211@A\211@A\211@A\211@A\n
\211\205C \310\"G\244\266\205\266\213\207" [completion-flex-nospace inhibit-changing-match-data " " nil t string-match completion-substring--all-completions completion-flex--make-flex-pattern completion-pcm--hilit-commonality] 23 (#$ . 100518)])
#@23
(fn STR TABLE PRED)
(defalias 'completion-initials-expand #[771 "\301\302$G\303U\206 \304@#?\205I \211@\303U\203& \305\306\307#\202I \211@\310W\205I \311@S@#\311\303@#\305\306\311@\"#P\262\207" [completion-pcm--delim-wild-regex completion-boundaries "" 0 string-match mapconcat string "-" 3 substring] 11 (#$ . 101019)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-initials-all-completions #[1028 "\300#\211\205 \301G$\207" [completion-initials-expand completion-pcm-all-completions] 10 (#$ . 101368)])
#@32
(fn STRING TABLE PRED POINT)
(defalias 'completion-initials-try-completion #[1028 "\300#\211\205 \301G$\207" [completion-initials-expand completion-pcm-try-completion] 10 (#$ . 101573)])
#@116 The function called by `completing-read' to do its work.
It should accept the same arguments as `completing-read'.
(defvar completing-read-function 'completing-read-default (#$ . 101777))
#@223 Default method for reading from the minibuffer with completion.
See `completing-read' for the meaning of the arguments.
(fn PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)
(defalias 'completing-read-default #[2050 ":\203
@ATB\262\306=?\205 \203% \f\202&
\f\307>\2031 \211\2026 \310
\"\311\n\312 &\211\313\232\203\\ \203\\ :\203Y @\202Z \262,\207" [minibuffer-completion-table minibuffer-completion-predicate minibuffer-completion-confirm minibuffer--require-match minibuffer-local-must-match-map minibuffer-local-completion-map t (nil lambda) make-composed-keymap read-from-minibuffer nil "" minibuffer-completing-file-name minibuffer-local-filename-completion-map] 18 (#$ . 101972)])
#@74 Get a file name at point in original buffer and insert it to minibuffer.
(defalias 'minibuffer-insert-file-name-at-point #[0 "r\300\301 !q\210\302\303!)\211\205 \211c\207" [window-buffer minibuffer-selected-window run-hook-with-args-until-success file-name-at-point-functions] 2 (#$ . 102749) nil])
#@238 Move to the logical beginning of the minibuffer.
This command behaves like `beginning-of-buffer', but if point is
after the end of the prompt, move to the end of the prompt.
Otherwise move to the start of the buffer.
(fn &optional ARG)
(defalias 'minibuffer-beginning-of-buffer #[256 "\211:\204\n \301 \203
\302 \210\211\203& \211:\204& \303e\304deZ\305!_\306\245#\2027 \2031 `\307 X\2035 e\2027 \307 b\210\211\205E \211:?\205E \304y\207" [minibuffer-beginning-of-buffer-movement region-active-p push-mark + 1 prefix-numeric-value 10 minibuffer-prompt-end] 7 (#$ . 103056) "^P"])
(byte-code "\300\301\302\303#\300\207" [function-put minibuffer-beginning-of-buffer interactive-only "use `(goto-char (point-min))' instead."] 4)
#@214 Execute the forms in BODY from the minibuffer in its original window.
When used in a minibuffer window, select the window selected just before
the minibuffer was activated, and execute the forms.
(fn &rest BODY)
(defalias 'with-minibuffer-selected-window '(macro . #[128 "\300\301\302\303\304\303BBEE\207" [let ((window (minibuffer-selected-window))) when window with-selected-window] 8 (#$ . 103793)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-minibuffer-selected-window lisp-indent-function 0 put edebug-form-spec t] 5)
#@91 Run `recenter-top-bottom' from the minibuffer in its original window.
(fn &optional ARG)
(defalias 'minibuffer-recenter-top-bottom #[256 "\300 \211\205\" \301!r\302\303\304\305\306!\307\"\310$\216\311@\312\"\210\313!*\262\207" [minibuffer-selected-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord recenter-top-bottom] 9 (#$ . 104354) "P"])
#@89 Run `scroll-up-command' from the minibuffer in its original window.
(fn &optional ARG)
(defalias 'minibuffer-scroll-up-command #[256 "\300 \211\205\" \301!r\302\303\304\305\306!\307\"\310$\216\311@\312\"\210\313!*\262\207" [minibuffer-selected-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord scroll-up-command] 9 (#$ . 104814) "^P"])
#@91 Run `scroll-down-command' from the minibuffer in its original window.
(fn &optional ARG)
(defalias 'minibuffer-scroll-down-command #[256 "\300 \211\205\" \301!r\302\303\304\305\306!\307\"\310$\216\311@\312\"\210\313!*\262\207" [minibuffer-selected-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord scroll-down-command] 9 (#$ . 105269) "^P"])
#@91 Run `scroll-other-window' from the minibuffer in its original window.
(fn &optional ARG)
(defalias 'minibuffer-scroll-other-window #[256 "\300 \211\205\" \301!r\302\303\304\305\306!\307\"\310$\216\311@\312\"\210\313!*\262\207" [minibuffer-selected-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord scroll-other-window] 9 (#$ . 105730) "P"])
#@96 Run `scroll-other-window-down' from the minibuffer in its original window.
(fn &optional ARG)
(defalias 'minibuffer-scroll-other-window-down #[256 "\300 \211\205\" \301!r\302\303\304\305\306!\307\"\310$\216\311@\312\"\210\313!*\262\207" [minibuffer-selected-window internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord scroll-other-window-down] 9 (#$ . 106190) "^P"])
(provide 'minibuffer)
Mini Shell