| Current Path : /usr/share/emacs/24.3/lisp/ |
Linux gator3171.hostgator.com 4.19.286-203.ELK.el7.x86_64 #1 SMP Wed Jun 14 04:33:55 CDT 2023 x86_64 |
| Current File : //usr/share/emacs/24.3/lisp/minibuffer.elc |
;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:12:50 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/minibuffer.el
;;; in Emacs version 24.3
;;; 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.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
#@558 Return the boundaries of the completions returned by TABLE for STRING.
STRING is the string on which completion will be performed.
SUFFIX is the string after point.
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 TABLE PRED SUFFIX)
(defalias 'completion-boundaries #[1028 "\301!\205
\302B#\211\242\302=\204 \303\262\211\211A@)\206! \304\211AA)\206, GB\207" [x functionp boundaries nil 0] 10 (#$ . 552)])
#@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#\211\242\301=\203 \211\202 \302\207" [functionp metadata (metadata)] 7 (#$ . 1300)])
(defalias 'completion--field-metadata #[257 "\302\303`\" #\207" [minibuffer-completion-table minibuffer-completion-predicate completion-metadata buffer-substring-no-properties] 5 "\n\n(fn FIELD-START)"])
(defalias 'completion-metadata-get #[514 "\211\236A\207" [] 4 "\n\n(fn METADATA PROP)"])
#@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 "\211C\300C\300C\211@\204< @\203< \301\302\303\304\305\306\307 \n #\310\"\311\312%D\313\302\303\314\315\306\307\n!\316\"\317\320%\301EDC\217\210\202 \211@\206N @\205N \321@@@A\"\266\202\207" [nil #1=#:err funcall make-byte-code 0 "\302\300\301@\301\211@A\240\210@!\240\207" vconcat vector [] 5 "\n\n(fn)" error 257 "\300@\204 \300\240\210\301\207" [nil] 3 "\n\n(fn ERR)" signal] 15 (#$ . 2548)])
#@197 Perform completion ACTION.
STRING is the string to complete.
TABLE is the completion table.
PRED is a completion predicate.
ACTION can be one of nil, t or `lambda'.
(fn ACTION TABLE STRING PRED)
(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 (#$ . 3109)])
#@639 Use function FUN as a dynamic completion table.
FUN is called with one argument, the string for which completion is required,
and it should return an alist containing all the intended possible completions.
This alist may be a full list of possible completions so that FUN can ignore
the value of its argument. If 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'.
(fn FUN)
(defalias 'completion-table-dynamic #[257 "\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 771 "\211\242\301=\206\n \211\302=?\205+ r\303 \304!\203 \305!\202 p\262q\210\306\300!$)\207" vconcat vector [boundaries metadata minibuffer-selected-window window-live-p window-buffer complete-with-action] 8 "\n\n(fn STRING PRED ACTION)"] 7 (#$ . 3572)])
#@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\nDDEEFD\207" [make-symbol "string" completion-table-dynamic lambda when functionp setq funcall function] 13 (#$ . 4584)]))
(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 (#$ . 5446)])
#@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 "\305\306\301G\301\307\211 &\310=\205 \302\301G\307OP\211\205\" \311\300$\211\205\272 \242\312=\203] \211\242\312=\203= \211 \211A@)\206> \306\312\301G\301G\302GZ\\]\242\312=\205V \211 AA)BB\262\202\272 \211;\203| \305\306\302G\302\307\211 &\310=\205\272 \301\302G\307OP\202\272 \310=\203\271 \313\300\314$\211@\302GY\203\225 \202\264 \315\316\302@\307O!P\317\307\320\321\322\323\324\325!\326\"\327\330%\"\"\262\262\202\272 \211\207" vconcat vector [completion-ignore-case x compare-strings 0 nil t complete-with-action boundaries completion-boundaries "" "\\`" regexp-quote delq mapcar make-byte-code 257 "\301\300\"\205\f \211\302\225\303O\207" vconcat vector [string-match 0 nil] 4 "\n\n(fn C)"] 17 "\n\n(fn STRING PRED ACTION)"] 11 (#$ . 5870)])
(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 "\n\n(fn PREFIX TABLE STRING PRED ACTION)"])
#@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=\203\244 \305#:\203L @\262\211\306=\203f \307!\203_ !\202\243 P\202\243 \211;\203\242 \310G!\204\242 \301\311$\211@GW\262\203\242 \305#\306=\203\242 \307!\203\233 !\202\243 \211P\202\243 \211\207\211\312=\203\254 \304\207\313$\207" [boundaries completion-boundaries regexp-quote string-match nil try-completion t functionp zerop "" lambda complete-with-action] 13 (#$ . 7734)])
#@627 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 t, 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%$\206O ?\205O \205O \205O \302$\207" [lambda test-completion complete-with-action make-byte-code 257 "\300!\205 \301!\207" vconcat vector [] 3 "\n\n(fn X)"] 17 (#$ . 9181)])
#@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 (#$ . 10163)])
#@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=\203 \304\305\300#\306\"\207\211\307=\203 \301!\310\300#\207\211\242\311=\203\201 \301!A\312G!\2035 \202: \301P!\313\"\204G \314\315\316C\"\210\317G\317O\320\300 $\302@\n\"@\312A!\203f \321\202{ AG\\\302\f P\"@ GZ\262\311BB\207\211\317=\203\243 \301!\322\300#\211;\204\230 \211\202\242 \323\321\301\302&@\207\211\324=\203\321 \301!\325\300#\320\300\326$@\327\301\302&\330!\211:\203\317 \211\317\241\210\207\211\331=\205\301!\301\321O!\313\"\204\355 \314\315\332C\"\210\300G\333\334\335\336\337\301\302\f$\340\"\341\342%F\266\202\207" vconcat vector [metadata append completion-metadata ((completion--unquote-requote . t)) lambda test-completion boundaries zerop string-prefix-p signal cl-assertion-failed (string-prefix-p ustring ufull) nil completion-boundaries 0 try-completion completion--twq-try t all-completions "" completion--twq-all last completion--unquote (string-prefix-p uprefix ustring) make-byte-code 514 "\211\304=\203 \242;\204 \207\305\302\303@A\300\301&\207\211\306=\203< \307!\211A\206) \310\205; \311\241\210\312\302\303\300\301&\207\311\207" vconcat vector [1 completion--twq-try 2 last 0 nil completion--twq-all] 11 "\n\n(fn UNQUOTED-RESULT OP)"] 17 "\n\n(fn STRING PRED ACTION)"] 11 (#$ . 10607)])
(defalias 'completion--twq-try #[1542 "\300\"G]\301OG \"\211@A\211 GV\205* G\fO!!\302OQ\303
!\203A \302\202Y \f\nGV\203Q G\\\202Y \n
\"@\f!\232\203i B\202s !\211GB\262\266\204\266\202\207" [fill-common-string-prefix nil 0 zerop] 20 "\n\n(fn STRING USTRING COMPLETION POINT UNQUOTE REQUOTE)"])
(defalias 'completion--string-equal-p #[514 "\300\301\211\301\211\302&\303=\207" [compare-strings nil ignore-case t] 10 "\n\n(fn S1 S2)"])
(defalias 'completion--twq-all #[1542 "\205a \301\302\303\301OB\")G\\\"\211@A\211 \304O\n\"@\211X\2049 \305\306\307C\"\210\301\310\301O\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 "" 0 signal cl-assertion-failed (<= qboundary qfullpos) propertize face completions-common-part mapcar make-byte-code 257 "\303\300\304#\204 \305\306\307\300E\"\210\211\300G\310O\301!\302P\207" vconcat vector [string-prefix-p ignore-case signal cl-assertion-failed (string-prefix-p prefix completion 'ignore-case) nil] 6 "\n\n(fn COMPLETION)"] 25 "\n\n(fn STRING USTRING COMPLETIONS BOUNDARY UNQUOTE REQUOTE)"])
(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)
#@322 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'.
(fn MESSAGE &rest ARGS)
(defalias 'minibuffer-message #[385 "\306p!\204$ \211\203 \307\310#\210\202 \310\311\"\210\312\206 \313!\310\314!\210\207\310\314!\210\211\204C \315\314\316 \317 \n #,\203C \320!\202G \321\322Q\262\211\203T \307\323#\262\324dd\314\316\211%\316 \325\326\327\330\331\332!\333\"\334\335%DC\216\336G!\204~ \337\327\340\341\316%\210\342\343#\210\312\206\212 \313!*\207" [minibuffer-message-timeout start string regexp inhibit-changing-match-data inhibit-quit minibufferp apply message "%s" sit-for 1000000 nil "\\` *\\[.+\\]\\'" t string-match copy-sequence " [" "]" format make-overlay funcall make-byte-code 0 "\301\300!\207" vconcat vector [delete-overlay] 2 "\n\n(fn)" zerop put-text-property 1 cursor overlay-put after-string] 10 (#$ . 14282)])
#@116 Return the user input in a minibuffer before point as a string.
That is what completion commands operate on.
(fn)
(defalias 'minibuffer-completion-contents #[0 "\300 `{\207" [field-beginning] 2 (#$ . 15380)])
#@116 Delete all user input in a minibuffer.
If the current buffer is not a minibuffer, erase its entire contents.
(fn)
(defalias 'delete-minibuffer-contents #[0 "\300 d|\207" [minibuffer-prompt-end] 2 (#$ . 15597) nil])
#@62 If non-nil, print helpful inline messages during completion.
(defvar completion-show-inline-help t (#$ . 15819))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable completion-auto-help funcall function #[0 "\300\207" [t] 1 "\n\n(fn)"] "Non-nil means automatically provide help for invalid completion input.\nIf the value is t the *Completion* 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)) :group minibuffer] 8)
#@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*\".") (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.")) (#$ . 16466))
(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 "\302\303\304\305\306DD\307\310\311\312\313\314& \210\302\315\304\305\316DD\317\313\320\310\321\322\323\324\325\326\327\330\326\331\332\257\330\326\333\334 \257\257\257&\207" [completion--styles-type completion--cycling-threshold-type custom-declare-variable completion-styles funcall function #[0 "\300\207" [(basic partial-completion emacs22)] 1 "\n\n(fn)"] "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 :group minibuffer :version "23.1" completion-category-overrides #[0 "\300\207" [((buffer (styles basic substring)))] 1 "\n\n(fn)"] "List of `completion-styles' overrides for specific categories.\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." "24.1" 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)
(defalias 'completion--styles #[257 "\302\303\"\304\236A\236\211\203 \305\306A\307 !\"!\202 \207" [completion-category-overrides completion-styles completion-metadata-get category styles delete-dups append copy-sequence] 8 "\n\n(fn METADATA)"])
#@84 Call the Nth method of completion styles.
(fn N STRING TABLE PRED POINT METADATA)
(defalias 'completion--nth-completion #[1542 "CCC\204 \300@\301@O@#\262\302\303\"\205K @@@\304#\211A\262@\240\210\211A\262@\240\210\211A\262@\240\210\211A\262@\262\305\306\307\310\311\312\n
%\313\"\314\315%\316!\"\203r \f\"\202s \211\266\202\207" [completion-metadata 0 completion-metadata-get completion--unquote-requote completion--unquote completion--some make-byte-code 257 "\300
\2368\301@\302@\303\304@$\207" vconcat vector [completion-styles-alist] 6 "\n\n(fn STYLE)" completion--styles] 21 (#$ . 21120)])
#@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 (#$ . 21766)])
#@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 (#$ . 22351)])
(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 "\n\n(fn MODIFIED COMPLETIONS EXACT)"])
#@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 \303!\204; \\\262\302O\262\210\301\211GW\203d ZW\203d ZSf\304G\305#H=\203d \211T\262\202= \303!\204v Z\262\301[O\262b\210\306!\210``Z\\|\210\211u\207" [set-text-properties 0 nil zerop - 1 insert-and-inherit] 10 (#$ . 22974)])
(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 "\n\n(fn)"] "Number of completion candidates below which cycling is used.\nDepending on this setting `minibuffer-complete' may use cycling,\nlike `minibuffer-force-complete'.\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)
(defalias 'completion--cycle-threshold #[257 "\302\303\"\304\236A\236\211\203 \211A\202 \207" [completion-category-overrides completion-cycle-threshold completion-metadata-get category cycle] 5 "\n\n(fn METADATA)"])
(defvar completion-all-sorted-completions 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 (#$ . 24527))
(defalias 'completion--message #[257 "\205 \301!\207" [completion-show-inline-help minibuffer-message] 3 "\n\n(fn MSG)"])
#@727 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 &optional TRY-COMPLETION-FUNCTION EXPECT-EXACT)
(defalias 'completion--do-completion #[512 "\306 \307 {\310!\206 \311 `Z%\211\2042 \312 \210\n\204* \313 \210\314\315!\210\316\317\211\211#\202Z\211\320=\203R \312 \210b\210\321\322?\205H \323#\210\316\317\211\320#\202Z\211A@\324\317\211\317\211\320&\320=?\324\317\211 \317\211\211&\320=\211\203| b\210\202\204 \325 #\210GZu\210\211\204\233 \204\233 \326 \"\202X\327 #\330!\211\205\277 \203\275 \331\332O \333$@W\205\277 \334 \335 \210\211A:\203\365 \336\337\340\332\341\342\343\"\344\"\345\346%D\347\337\350\336EDC\217\204\365 \320\262\320\262\351!\210\352 \210\202Q\203\312 \210\203Q\321GW\203\353\202\354\"\210\202Q\2047 \355=\203&\f
=\202' \2030\356 \210\202Q\314\357!\210\202Q\f
=\203D \203D\356 \210\321\353?\205O\360#\210\316\320#\266\203\266\204\207" [minibuffer-completion-table minibuffer-completion-predicate completion-fail-discreetly completion-auto-help this-command last-command field-beginning field-end 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 0 "" completion-all-sorted-completions completion--flush-all-sorted-completions #1=#:err funcall make-byte-code "\300\301\233:\207" vconcat vector [] 2 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] completion--cache-all-sorted-completions minibuffer-force-complete exact unknown lazy minibuffer-completion-help "Next char not unique" "Complete, but not unique"] 23 (#$ . 24760)])
#@289 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.
(fn)
(defalias 'minibuffer-complete #[0 "\305 \305=\204
\306 \210\307\310\n!\2030 \nr\311!q\210\312d\"\203* \313e\307#\210\202- \314 \210)\307\207 \203= \f\203= \315 \210\316\207\317 \211\320=?\205G \316\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 window-buffer pos-visible-in-window-p set-window-start scroll-other-window minibuffer-force-complete t completion--do-completion 0] 5 (#$ . 27211) nil])
(defalias 'completion--cache-all-sorted-completions #[257 "\302\303\304\305\306$\210\307\310 !\307\311 !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 field-beginning field-end] 6 "\n\n(fn COMPS)"])
(defalias 'completion--flush-all-sorted-completions #[768 "\205 \205 AV\206 @W?\205\" \303\304\305\306#\210\307\211\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] 8 "\n\n(fn &optional START END LEN)"])
(defalias 'completion--metadata #[1285 "\300\301$\211@=\203 \202 \302\303O#\207" [completion-boundaries "" completion-metadata 0] 10 "\n\n(fn STRING BASE MD-AT-POINT TABLE PRED)"])
(defalias 'completion-all-sorted-completions #[0 "\206k \304 \305 {\306!\307 \n`Z%\310!\211A\206! \311\312\313`\" \n%\314\315\"\205i \316\241\210\211\203C \211!\202G \317\320\"\262\321 \203d 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 field-beginning field-end completion--field-metadata completion-all-completions last 0 completion--metadata buffer-substring-no-properties completion-metadata-get cycle-sort-function nil sort #[514 "GGW\207" #1=[] 4 "\n\n(fn C1 C2)"] minibufferp make-byte-code 514 "\300\235G\300\235GV\207" vconcat vector #1# 5 "\n\n(fn C1 C2)" completion--cache-all-sorted-completions] 18 "\n\n(fn)"])
#@103 Complete the minibuffer to an exact match.
Repeated uses step through the possible completions.
(fn)
(defalias 'minibuffer-force-complete #[0 "\305\306 !\307 \310 \311!A\206 \312\\:\204% \313\203 \314\202! \315!\202\240 A:\204O @\316\"\232\211\204= \317@#\210\320\316`\"\321\205I \322#\262\202\240 \317@#\210\320\316`\"\323\"\210\324\311!\211@AB\241\210\325A!\266 \n \326\312\327\330\331 $\332\"\333\334\335&\336\337 \340\341#\210\340\331\f!#\210\211\262!\266\204\207" [completion-cycling minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties last-command-event copy-marker field-beginning field-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 t 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.\n\n(fn)" nil set-temporary-overlay-map make-sparse-keymap define-key [remap completion-at-point]] 16 (#$ . 29749) nil])
#@119 A 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) (#$ . 30949))
#@580 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.
(fn)
(defalias 'minibuffer-complete-and-exit #[0 "\306 \307 U\203 \310 \202\234 \311{ #\203E \n\203@ {\312 #\211;\203> \232\204> GGU\203> \313#\210\266\310 \202\234 \314>\203k \f
=\204^ \315=\203c \f>\204c \310 \202\234 \316\317!\210\320\202\234 \321\322\323D\324\322\325\321EDC\217\211\326>\203\202 \310 \202\232 \211\327=\203\231 \204\221 \310 \202\232 \316\317!\210\320\202\232 \320\262\207" [minibuffer-completion-table minibuffer-completion-predicate completion-ignore-case minibuffer-completion-confirm last-command this-command field-beginning field-end exit-minibuffer test-completion try-completion completion--replace (confirm confirm-after-completion) confirm-after-completion minibuffer-message "Confirm" nil #1=#:err funcall #[0 "\300\301\302\"\207" [completion--do-completion nil expect-exact] 3 "\n\n(fn)"] error #[257 "\300\207" [1] 2 "\n\n(fn IGNORED)"] (1 3) 7 minibuffer-confirm-exit-commands] 8 (#$ . 31226) nil])
(defalias 'completion--try-word-completion #[1285 "\300%\211:\204 \211\202\335 G@GU\203T \301\302\303\"\304O\305O\305\203J \211:\204J \300\211A\262@Q\n\n\nT\n%\262\202( \211:\203R \211\262\266\211A@\304O\211\306Q\307\310\"\203\330 \311\312\"\304\225\305O \305O\307\313\306Q\"\205\206 \311\312\"\211\204\221 \314G!\203\326 \307\315\316!\317\203\242 \316!\202\243 \320R\"\203\326 \312\225=\203\326 \307\321\312\224#\203\326 \304\225V\203\326 \304\225\304O\n\305OP\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)"] (" " "-") 0 nil "\n" string-match "\\(.+\\)\n.*?\\1" match-string 1 "\\`\\(.+\\).*\n.*\\1" zerop ".*" regexp-quote "\\(.*?\\)" "\\'" "\\W"] 20 "\n\n(fn STRING TABLE PREDICATE POINT MD)"])
#@240 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.
(fn)
(defalias 'minibuffer-complete-word #[0 "\300\301!\211\302=?\205 \303\207" [completion--do-completion completion--try-word-completion 0 t] 3 (#$ . 33620) nil])
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315\316\317& \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 "\n\n(fn)"] "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)) :group minibuffer :version "23.2"] 10)
#@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:\205A\302\303\304\305\"\"\306p\307\"\211\203 \310!S\202 \311\312\312\\\245]\313G\312\245]^\245\307G\245\307\314\315\n\211\205=\211@\232\2046\211\262\211:\203\\ \316@!\316\211A@)!\\\202_ \316! \317=\203\263 V\203| \320Zy\210\307\262 \\\262\307V\203\335 \315\210iV\203\240 m\203\227 \321c\210\202\206 \313y\210\315\210\202\206 \322c\210\323`S`\324\325\326
ED#\210\202\335 \204\335 \n ] \\W\203\315 \321c\210\307\262\202\335 \322c\210\323`S`\324\325\326
ED#\210\315\262:\204\362 \327`c\210`\330\331$\210\202 \327`@c\210`\330\331$\210\332`\211A@)c\210`\333#\210 \317=\203(\307V\203 \315y\210\202!\321c\210T\262\2025 \334\f\"_\\\262\210A\266\202\2028 \262\266\212\207" [x completions-format apply max mapcar #[257 "\211:\203 \301@!\301\211A@)!\\\207\301!\207" [x string-width] 5 "\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 add-text-properties (mouse-face nil face completions-annotations) ceiling] 22 (#$ . 34720)])
(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 (#$ . 36164))
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\304\305%\207" [custom-declare-face completions-first-difference ((t (:inherit bold))) "Face put on the first uncommon character in completions in *Completions* buffer." :group completion completions-common-part ((t (:inherit default))) "Face put on the common prefix substring in completions in *Completions* buffer.\nThe idea of `completions-common-part' is that you can use it to\nmake the common parts less visible than normal, so that the rest\nof the differing parts is, by contrast, slightly highlighted."] 6)
(defalias 'completion-hilit-commonality #[771 "\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 put-text-property 0 font-lock-face completions-common-part completions-first-difference] 8 "\n\n(fn ELEM)"] 11 "\n\n(fn COMPLETIONS PREFIX-LEN BASE-SIZE)"])
#@809 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'.
The obsolete optional arg COMMON-SUBSTRING, if non-nil, should be a string
specifying a common substring for adding the faces
`completions-first-difference' and `completions-common-part' to
the completions buffer.
(fn COMPLETIONS &optional COMMON-SUBSTRING)
(defalias 'display-completion-list #[513 "\211\203\f \303G\304#\262\305!\204> \306\307!r\211q\210\310\311\312\313\314\315!\316\"\317\320%DC\216p\304\321\"\210*\322\323 !\210*\210\202W rq\210db\210\204O \324c\210\202V \325c\210\326!\210)\211\327\301!)\210\304\207" [standard-output completion-setup-hook completion-common-substring completion-hilit-commonality nil bufferp generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" 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] 10 (#$ . 37572)])
#@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 (#$ . 39103))
#@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 (#$ . 40090))
(make-obsolete-variable 'completion-annotate-function 'completion-extra-properties "24.1")
(defalias 'completion--done #[769 "\303\304\"\211\205\n \305 \306>\204 \307\310\311C\"\210\2036 \312=\2031 \313 \n#\314=\203. \315\202/ \316\262\"\210\205H \211\205A \305 \232\205H \317!\207" [completion-extra-properties minibuffer-completion-table minibuffer-completion-predicate plist-get :exit-function current-message #1=(exact sole finished unknown) signal cl-assertion-failed (memq finished '#1#) unknown try-completion t finished exact completion--message] 9 "\n\n(fn STRING &optional FINISHED MESSAGE)"])
#@82 Display a list of possible completions of the current minibuffer contents.
(fn)
(defalias 'minibuffer-completion-help #[0 "\306\307!\210\310 \311 \312 \313!\314 `\310 Z%\306\315!\210\211\203, \211A:\204A \211@\232\203A \316 \210\317 \210\320\203; \321\202< \322!\210\202\323!\211A\324!?\205Q \325O\326\327 `\" %\330\331\"\206l \332\n\333\"\206l \334
r\335\336!q\210p\337 \210\315\211:;\340\211<\340 = >\341 \210\342\343!\210+\211 ?\203\237 \315\241\210\330\344\"\211\203\256 \211 !\202\263 \345 \346\"\262\262\203\316 \347\350\351\352\353\354!\355\"\356\357% \"\262r?q\210\360\361!\210 \\ D1\360\362!\210 \n\350\363\364\353\354\f$\365\"\366\367%\266\2032)\370!\210\371!\210)\266)\266\315\207" [minibuffer-completion-table minibuffer-completion-predicate completion-extra-properties completion-annotate-function display-buffer-mark-dedicated default-directory message "Making completion list..." field-beginning field-end field-string completion--field-metadata completion-all-completions nil minibuffer-hide-completions ding minibuffer-message "Sole completion" "No completions" last zerop 0 completion--metadata buffer-substring-no-properties completion-metadata-get annotation-function plist-get :annotation-function soft get-buffer-create "*Completions*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook 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 "\306\300G!\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 zerop buffer-substring-no-properties message "*Completions* out of date" completion--replace completion-boundaries "" completion--done exact finished completion-extra-properties] 9 "\n\n(fn START END CHOICE)" display-completion-list internal-temp-output-buffer-show buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only standard-output] 25 (#$ . 41064) nil])
#@55 Get rid of an out-of-date *Completions* buffer.
(fn)
(defalias 'minibuffer-hide-completions #[0 "\300\301\302\"\211\205( \303!r\304\305\302\306\307\310!\311\"\312\313%DC\216\314@\315\"\210\316 *\262\207" [get-buffer-window "*Completions*" 0 internal--before-with-selected-window funcall make-byte-code "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 "\n\n(fn)" select-window norecord bury-buffer] 9 (#$ . 43294)])
#@43 Terminate this minibuffer argument.
(fn)
(defalias 'exit-minibuffer #[0 "\301\302\303\301\"\207" [deactivate-mark nil throw exit] 3 (#$ . 43744) nil])
#@35 Terminate minibuffer input.
(fn)
(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 (#$ . 43903) nil])
#@504 Wrapper hook around `completion-in-region'.
The functions on this special hook are called with 5 arguments:
NEXT-FUN START END COLLECTION PREDICATE.
NEXT-FUN is a function of four arguments (START END COLLECTION PREDICATE)
that performs the default operation. The other four arguments are like
the ones passed to `completion-in-region'. The functions on this hook
are expected to perform completion on START..END using COLLECTION
and PREDICATE, either by calling NEXT-FUN or by doing it themselves.
(defvar completion-in-region-functions nil (#$ . 44145))
(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 (#$ . 44752))
#@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 (#$ . 45025))
#@276 Complete the text between START and END using COLLECTION.
Return nil if there is no valid completion, else t.
Point needs to be somewhere between START and END.
PREDICATE (a function called with no arguments) says when to
exit.
(fn START END COLLECTION &optional PREDICATE)
(defalias 'completion-in-region #[1027 "`X\204 \301\302\303`E\"\210\304C\211\305\306\307\310\311!\312\"\313\314%\240\210\211@\315\300!\205- \316\300!F#\207" [completion-in-region-functions signal cl-assertion-failed (<= start (point)) nil make-byte-code 771 ":\2030 @\301=\203 \300@\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@#\207" vconcat vector [] 7 "\n\n(fn FUNS GLOBAL &rest ARGS)" #[1028 "\304\305\211\306%\305\262\305\262\307\310\311#\210\307\312\313#\210\n\203A \314\315!\210\316!\2035 \2029 \317!\317!E\320\321\322\323\324\325!\326\"\327\330%DC\216\331\332!+\207" [minibuffer-completion-predicate minibuffer-completion-table completion-in-region-mode-predicate completion-in-region--data make-overlay nil t overlay-put field completion priority 100 completion-in-region-mode 1 markerp copy-marker funcall make-byte-code 0 "\301\300!\207" vconcat vector [delete-overlay] 2 "\n\n(fn)" call-interactively minibuffer-complete] 14 "\n\n(fn START END COLLECTION PREDICATE)"]] 12 "\n\n(fn FUNS GLOBAL ARGS)" local-variable-p default-value] 12 (#$ . 45263)])
#@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) (#$ . 46782))
(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 "\n\n(fn)"])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315& \207" [custom-declare-variable completion-in-region-mode funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil if Completion-In-Region mode is enabled.\nSee the command `completion-in-region-mode' for a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `completion-in-region-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :group completion-in-region :type boolean] 12)
#@236 Transient minor mode used during `completion-in-region'.
With a prefix argument ARG, enable the modemode if ARG is
positive, and disable it otherwise. If called from Lisp, enable
the mode if ARG is omitted or nil.
(fn &optional ARG)
(defalias 'completion-in-region-mode #[256 "\306 \307=\203
?\202 \310!\311V\312\313\314\315\"\210\316\300\n\236\n\"\2044 \317\320 !\321\232\204K \322 \210\202K \204> \323\324\303C\"\210 \325\314\315\"\210\300
B\nB\326\327\203U \330\202V \331\"\210\332\333!\203{ \334\300!\210\306 \203n \211\306 \232\203{ \335\336\203x \337\202y \340\"\210\210\341 \210\207" [completion-in-region-mode completion-in-region--data minor-mode-overriding-map-alist completion-in-region-mode-predicate completion-in-region-mode--predicate completion-in-region-mode-map current-message toggle prefix-numeric-value 0 nil remove-hook post-command-hook completion-in-region--postch delq buffer-name window-buffer "*Completions*" minibuffer-hide-completions signal 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 customize-mark-as-set message "Completion-In-Region mode %sabled" "en" "dis" force-mode-line-update] 5 (#$ . 47935) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(byte-code "\302\303\304\305\300!\205\n \304\211%\210\306\303 \236 \"\304\207" [completion-in-region-mode-map minor-mode-map-alist add-minor-mode completion-in-region-mode nil boundp delq] 6)
#@1014 Special hook to find the completion table for the thing at point.
Each function on this hook is called in turns without any argument and should
return either nil to mean that it is not applicable at point,
or a function of no argument 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 it, 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' If `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 to preserve
things like point and current buffer.
(defvar completion-at-point-functions '(tags-completion-at-point-function) (#$ . 49470))
#@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 (#$ . 50579))
#@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 (#$ . 50844))
(defalias 'completion--capf-wrapper #[514 "\211\302=\204# \211\303=\203 \235\202 \211\304=\203 \235?\202 \305\205\201 \211:\203^ \306!\204^ \235\204: B\307\310\233\311\"\312=\203x \313\314@`\"\3158\307\310\233\316\"#\204x \305\262\202x \211<\204x \306!\204x \235\204x \317\320\"\210 B\211\205 B\262\207" [completion--capf-safe-funs completion--capf-misbehave-funs all safe optimist 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 "\n\n(fn FUN WHICH)"])
#@124 Perform completion on the text around point.
The completion method is determined by `completion-at-point-functions'.
(fn)
(defalias 'completion-at-point #[0 "\302\303\304\305#\211:\203\211 \211@A\306!\203 \211\211 \262\202\204 \211:\203\202 \211@A\211:\203{ \211@A\211:\203s \211@A\211C \307@!\204M \310@!\240\210\311\312\313\314\315\"\316\"\317\320%\321@\322 \323\"$*\266\205\266\202\202v A\266\202\202} A\266\202\202\204 A\266\202\202\213 \211A\207" [completion-extra-properties completion-in-region-mode-predicate run-hook-wrapped completion-at-point-functions completion--capf-wrapper all functionp markerp copy-marker make-byte-code 0 "\301 \242\211\205 \211\300@U\207" vconcat vector [] 3 "\n\n(fn)" completion-in-region plist-get :predicate] 21 (#$ . 51699) nil])
#@129 Display the completions on the text around point.
The completion method is determined by `completion-at-point-functions'.
(fn)
(defalias 'completion-help-at-point #[0 "\305\306\307\310#\311:\203\302 @A\312!\203 \211\313\314\"\262\202\275 \211:\203\272 \211@A\211:\203\262 \211@A\211:\203\250 \211@A\211C \315@!\204P \316@!\240\210\317\320\"\321\322\323\324\325\"\326\"\327\330%\331@\332\211\333%\334\335\336#\210\334\337\340#\210\341\342!\210@\316!E\343\321\322\344\324\325!\345\"\346\330%DC\216\347\350!-\262\266\205\266\202\202\255 !\266\202\202\265 !\266\202\202\275 !\266\202\202\305 \313\351!\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@U\207" vconcat vector [] 3 "\n\n(fn)" make-overlay nil t overlay-put field completion priority 100 completion-in-region-mode 1 funcall "\301\300!\207" [delete-overlay] 2 call-interactively minibuffer-completion-help "Nothing to complete at point"] 23 (#$ . 52510) nil])
(byte-code "\301\302\303#\210\301\304\305#\210\301\306\305#\210\207" [minibuffer-local-map define-key "" abort-recursive-edit "
" 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\211\207" [minibuffer-local-map make-sparse-keymap set-keymap-parent define-key " " minibuffer-complete " " minibuffer-complete-word "?" minibuffer-completion-help] 5) (#$ . 54089))
#@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) (#$ . 54451))
#@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) (#$ . 54778))
(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] #[0 "r\300q\210db\210\301p!)\207" ["*Messages*" display-buffer] 2 "\n\n(fn)" nil] [down-mouse-1] ignore] 5) (#$ . 55746))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [minibuffer-inactive-mode-hook variable-documentation put purecopy "Hook run when 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] 5)
(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\300\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] 5)
(defvar minibuffer-inactive-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [minibuffer-inactive-mode-syntax-table variable-documentation put purecopy "Syntax table for `minibuffer-inactive-mode'." minibuffer-inactive-mode derived-mode-parent nil] 5)
#@272 Major-mode.
Uses keymap `minibuffer-inactive-mode-map', abbrev table `nil' and syntax-table `minibuffer-inactive-mode-syntax-table'.
This mode runs the hook `minibuffer-inactive-mode-hook', as the final step
during initialization.
\{minibuffer-inactive-mode-map}
(fn)
(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 (#$ . 57547) nil])
(defalias 'minibuffer--double-dollars #[257 "\300\301\302#\207" [replace-regexp-in-string "\\$" #[257 "\211P\207" [] 3 "\n\n(fn DOLLAR)"]] 5 "\n\n(fn STR)"])
(defalias 'completion--make-envvar-table #[0 "\301\302\"\207" [process-environment mapcar #[257 "\211\304\305\306\307\310\n #,O\207" [start string regexp inhibit-changing-match-data 0 "=" nil t string-match] 7 "\n\n(fn ENVENTRY)"]] 3 "\n\n(fn)"])
(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 \306O\307=\203 \310\202{ \242\311=\204+ \312=\203[ \313\310O\310#\205{ \312=\203A \314\202{ A\311\303\224\206K \304\224\302\315\"\205T \306\224BB\262\202{ SH\316=\203k \317\320\321#\262\310\322\310O\310%)\266\203\207" [completion--embedded-envvar-re completion-ignore-case string-match 2 1 completion--make-envvar-table 0 lambda nil boundaries metadata try-completion (metadata (category . environment-variable)) "[^[:alnum:]_]" 123 apply-partially completion-table-with-terminator "}" completion-table-with-context] 12 (#$ . 58765)])
#@59 Completion table for file names.
(fn STRING PRED ACTION)
(defalias 'completion-file-name-table #[771 "\300\301\302\303\304\305\306 #\307\"\310\311%D\312\301\313\300EDC\217\207" [#1=#:err funcall make-byte-code 0 "\302\306=\203 \307\207\310\300\311 \312 \313
\f #,\203) \314\315\316\317\320 \"\300\321\311O\301\302%\207\302\242\322=\203M \323\300!G\324\302A\311 \312 \313
\f #,\322\300G^BB\207\302\325=\203c \326\300G!?\205\316 \301\206` \327\300!\207\330\300!\323\300!\211\206o \302\204\211 \331\301#\211;\203\203 P\202\204 \211\262\202\314 \302\312=\205\314 \332\"\301\333>\204\311 \311\301\334=\203\244 \335\202\245 \301\336! \211\203\303 \211@!\203\274 \211B\262A\266\202\202\253 \210)\237\266\203\211\262\266\203\207" vconcat vector [start string regexp metadata (metadata (category . file)) "\\`~[^/\\]*\\'" nil t string-match completion-table-with-context "~" mapcar #[257 "\211\300P\207" ["/"] 3 "\n\n(fn U)"] system-users 1 boundaries file-name-directory "/" lambda zerop 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 inhibit-changing-match-data default-directory] 10 "\n\n(fn)" file-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 13 (#$ . 59607)])
#@54 Current predicate used by `read-file-name-internal'.
(defvar read-file-name-predicate nil (#$ . 60966))
(make-obsolete-variable 'read-file-name-predicate "use the regular PRED argument" "23.2")
(defalias 'completion--sifn-requote #[514 "\300!\211\301O\302\303\304\"\211\205 \301O\262\305\300!\"\262\203' \211\262\202 G\211\301V\203D \305\300\301SO!\"\203D \211S\262\202) \211\306B\262\207" [substitute-in-file-name 0 nil string-match "\\(\\$+{?\\)?\\w+\\W*\\'" string-prefix-p minibuffer--double-dollars] 12 "\n\n(fn UPOS QSTR)"])
(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 (#$ . 62109))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \210\300\314\302\303\315DD\316\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 "\n\n(fn)"] "Non-nil means when reading a file name completion ignores case." :group minibuffer :type boolean :version "22.1" insert-default-directory #[0 "\300\207" [t] 1 "\n\n(fn)"] "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'."] 10)
(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 "\n\n(fn &optional DIR INITIAL)"])
#@2679 Read file name, prompting with PROMPT and completing in directory DIR.
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 (#$ . 64142)])
#@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) (#$ . 66958))
#@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 \262\306!\204 \307!\262\204% \203\" \307\"\202# \262\310!\262\203? :\203: \311\310\"\202= \310!\262\n\203` ;\203` \203Z \312P!\312!GB\202i \312!\202i \205i \312!\313B \314\206p \315\316 \316\262 \316\262\317 \203\207 \320\n!\203\323 \321\307 !!\316C\211\322\313\323\324\325
$\326\"\327\330%\240\210\331\322\313\332\324\325!\333\"\334\330%DC\216\335\336@\"\210\337
\340
\341&)\262\262\202 \342\n!\343>?\n\204\361 \344G!\204\361 \262 \345\f!\262\f\n\203\n\307 :\203 @\202
\"\262 \314\262\346
\f\347=%\266\202!\242=\n:\203,\n@\262 =\203=\211\204:\314\262\350\262\204E\351\352!\210\n\203a:\203W@\202Y\230\203a\n\262\353!\262\211\203\235\312!-\203|!\354!A\"\241\210\211!\211 .A@)\230\203\224!\210!A!\202\231!\240\210\210\202\306\203\306\312!!:\203\262!@\232\204\305\211-\203\300\354!\"\202\302!B!\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--double-dollars 0 t file-exists-p nil next-read-file-uses-dialog-p file-remote-p file-name-as-directory make-byte-code "\304\305\303@\"\210\306\307\310\311\312\300\301\302#\313\"\314\315% \207" vconcat vector [remove-hook minibuffer-setup-hook make-byte-code 0 "\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%\317!\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 "\n\n(fn)" set-syntax-table minibuffer-local-filename-syntax] 7 "\n\n(fn)"] 8 "\n\n(fn)" funcall "\301\302\300@\"\207" [remove-hook minibuffer-setup-hook] 3 add-hook minibuffer-setup-hook completing-read read-file-name-internal file-name-history file-name-nondirectory (nil confirm confirm-after-completion) zerop file-name-directory x-file-dialog file-directory-p "" error "No file name specified" substitute-in-file-name delete history-delete-duplicates x] 24 (#$ . 67457)])
#@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 (#$ . 69984)])
(defalias 'completion-emacs21-try-completion #[1028 "\300#\211;\203 \211GB\202 \211\207" [try-completion] 8 "\n\n(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 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-emacs22-try-completion #[1028 "\300O\301\302O#\211;\204 \211\202A \303G!\204; \211GSH\304=\203; \303G!\204; \302H\304=\203; \305\300O\262\211PGB\207" [nil try-completion 0 zerop 47 1] 9 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-emacs22-all-completions #[1028 "\300O\301\302#\303\304$@#\207" [0 completion-hilit-commonality all-completions completion-boundaries ""] 13 "\n\n(fn STRING TABLE PRED POINT)"])
#@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 "\300G!\204# \301\302\303Q#\203# \304\225G=\203# \211\304\225\304\224Z\305O\207\207" [zerop string-match "\\(.+\\)\n\\1" "\n" 1 nil] 8 (#$ . 71368)])
(defalias 'completion-basic--pattern #[771 "\300\301@\302O\303\304AOE\"\207" [delete "" nil point 0] 10 "\n\n(fn BEFOREPOINT AFTERPOINT BOUNDS)"])
(defalias 'completion-basic-try-completion #[1028 "\301O\302O\303$\304A!\2038 \305#\211;\204' \211\2023 \211\306#PGB\262\202n A\302O\301@O\307\310@\302O\311\301AOE\"\312 $\203e \313!\262\314$\266\204\207" [minibuffer-completing-file-name 0 nil completion-boundaries zerop try-completion completion--merge-suffix delete "" point completion-pcm--all-completions completion-pcm--filename-try-filter completion-pcm--merge-try] 16 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-basic-all-completions #[1028 "\300O\301O\302$\300@O\303\304@\301O\305\300AOE\"\306\n\n$\307@#\207" [0 nil completion-boundaries delete "" point completion-pcm--all-completions completion-hilit-commonality] 15 "\n\n(fn STRING TABLE PRED POINT)"])
#@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 (#$ . 72698))
(defalias 'completion-pcm--prepare-delim-re #[257 "\301\302Q\211\207" [completion-pcm--delim-wild-regex "[" "*]"] 4 "\n\n(fn DELIMS)"])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315& \210\300\316\302\303\317DD\320\321\322\314\323&\207" [custom-declare-variable completion-pcm-word-delimiters funcall function #[0 "\300\207" ["-_./:| "] 1 "-_./:| \n\n(fn)"] "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 :group minibuffer :type string completion-pcm-complete-word-inserts-delimiters #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Treat the SPC or - inserted by `minibuffer-complete-word' as delimiters.\nThose chars are treated as delimiters iff 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] 12)
(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 "\n\n(fn PATTERN)"])
#@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 \302O\303O\304\305!\306\305!#\207\303\302\211\307#\211\262\203m \2049 \310\311#\204m \312\225\203B \312\225\262OB\262H\313=\203^ \314B\262T\262\202f \315B\262\262T\262\202 \316\317\303OB\237\"\207" [completion-pcm--delim-wild-regex completion-pcm-complete-word-inserts-delimiters 0 nil append completion-pcm--string->pattern (point) string-match get-text-property completion-try-word 1 42 star any delete ""] 10 (#$ . 74761)])
(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 \301!\207\300:\203 \211\300>\202 \300\203 \302\207\303\207" vconcat vector [regexp-quote "\\(.*?\\)" ".*?"] 3 "\n\n(fn X)" "" string-match "\\.\\*\\?\\(?:\\\\[()]\\)*\\(\\.\\*\\?\\)" replace-match t 1] 10 "\n\n(fn PATTERN &optional GROUP)"])
#@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 "\306!\203 \307@P#\207\310!\211\nB\307@;\203% @\202& \311P#\312!\2044 \211\202^ \313\211\203Z \211@\313 \314 \315
\f #,\203S \211B\262A\266\202\2026 \210\211\262*\207" [completion-ignore-case case-fold-search completion-regexp-list start string regexp completion-pcm--pattern-trivial-p all-completions completion-pcm--pattern->regex "" functionp nil t string-match inhibit-changing-match-data] 13 (#$ . 75932)])
(defalias 'completion-pcm--hilit-commonality #[514 "\211\205 \302\303\"\304\305\306\307\310\311!\312\"\313\314%\")\262\207" [completion-ignore-case case-fold-search completion-pcm--pattern->regex (point) mapcar make-byte-code 257 "\301!\262\302\300\"\204 \303\304\300#\210\305\224\206 \306\225\307\306\310\311%\210GV\2033 \307\211T\310\312%\210\210\207" vconcat vector [copy-sequence string-match error "Internal error: %s does not match %s" 1 0 put-text-property font-lock-face completions-common-part completions-first-difference] 8 "\n\n(fn STR)"] 10 "\n\n(fn PATTERN COMPLETIONS)"])
#@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 "\211C\211@\204 \211\300\240\210\301O\302O\303$\301@OCA\302O\302C @\nA\\O\262\f@Z\304
\"C\305\306\307\301\310\311\312 %\313\"\314\315%D\316\306\307\317\320\311\312 !\321\"\322\323%\305EDC\217\211\204\244@\301V\203\244\324\306\307\301\325\311\312#\326\"\327\315%D\316\306\330\324EDC\217\204\244@\301\331O\332G@%\211@A\211@A\211@A\211@A\n@@GSH\302C\302\262\211\203\353 \211@\211GSH=\203\344 \211B\262A\266\202\202\316 \210\203\206@ \301OQG@G\\\303!! $AA=\203\211@=\204K\211@W\204KA\302O\262@\302O\301AOP\262\"@O\240\210\304#G@Z\"\240\210\211\203\204\211@\333\307\317\334\311\312 \"\335\"\327\336% @\337
@Q@(($!\"\244\262A\266\202\202M\266\340\341\342!D@\205\230@C@$\240\210\240\266\211\204\270@\203\270\343@@@A\"\202\301@@F\266\203\266\206\207" [identity 0 nil completion-boundaries completion-pcm--string->pattern #1=#:err funcall make-byte-code "\302@\305\303@\304@\300\301$!\207" vconcat vector [completion-pcm--all-completions] 6 "\n\n(fn)" error 257 "\300@\204 \300\240\210\301\207" [nil] 3 "\n\n(fn ERR)" #2=#:err "\303\302@\300\301#\207" [try-completion] 4 #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] -1 completion-pcm--find-all-completions mapcar "\301\300@Q\207" [] "\n\n(fn S)" completion-pcm--all-completions append any string signal] 44 (#$ . 77185)])
(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 "\n\n(fn STRING TABLE PRED POINT)"])
#@67 Like `reverse' but for a string STR rather than a list.
(fn STR)
(defalias 'completion--sreverse #[257 "\300\301\302\303\"\237\"\207" [apply string mapcar identity] 6 (#$ . 79211)])
#@58 Return the common suffix of the strings STRS.
(fn STRS)
(defalias 'completion--common-suffix #[257 "\300\301\302\303\300\"\"!\207" [completion--sreverse try-completion "" mapcar] 7 (#$ . 79401)])
#@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\203C OB\262\211\262T\262\202) \304OB\262\237B\262\266A\266\202\202 \210)\304\312\313\314\"\211\203\372 \211@\211;\203v P\262\202\363 \304\304\262\211\203\225 \211@\211@B\262\211AB\262A\266\202\202{ \210\237\262\315\"\211\316=\203\253 \211\262\206\261 \315\"\316=\317=\204\303 \312\232\204\303 B\262\211\204\356 B\262\320>\203\356 \321!\211;\204\341 \322\323\324C\"\210\211\312\232\204\355 \211B\262\210\312\262\266A\266\202\202c \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 "" append (any) try-completion t prefix (star point prefix) completion--common-suffix signal cl-assertion-failed (stringp suffix)] 15 (#$ . 79606)])
(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 "\n\n(fn PATTERN)"])
#@76 Filter to adjust `all' file completion to the behavior of `try'.
(fn ALL)
(defalias 'completion-pcm--filename-try-filter #[257 "\211\2057 \305\306\307!\310Q\211\203/ \211@\305\311 \312 \n #,\204( \211B\262A\266\202\202\f \210\2065 \266\202\207" [completion-ignored-extensions start string regexp inhibit-changing-match-data nil "\\(?:\\`\\.\\.?/\\|" regexp-opt "\\)\\'" t string-match] 9 (#$ . 81536)])
(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#\262QG\\B\207" [completion-pcm--pattern->string t completion-pcm--merge-completions point any star completion--merge-suffix] 12 "\n\n(fn PATTERN ALL PREFIX SUFFIX)"])
(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 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-substring--all-completions #[1028 "\300O\301O\302$A\301O\300@O\303#\211@;\204) \211\202, \304B\305\f\f$\211 @\257\207" [0 nil completion-boundaries completion-basic--pattern prefix completion-pcm--all-completions] 17 "\n\n(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 "\n\n(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 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-initials-expand #[771 "\301\302$\303G!\206 \304@#?\205F \303@!\203& \305\306\307#\202F \211@\310W\205F @S@O\311@O\305\306@\312O#P\262\207" [completion-pcm--delim-wild-regex completion-boundaries "" zerop string-match mapconcat string "-" 3 0 nil] 11 "\n\n(fn STR TABLE PRED)"])
(defalias 'completion-initials-all-completions #[1028 "\300#\211\205 \301G$\207" [completion-initials-expand completion-pcm-all-completions] 10 "\n\n(fn STRING TABLE PRED POINT)"])
(defalias 'completion-initials-try-completion #[1028 "\300#\211\205 \301G$\207" [completion-initials-expand completion-pcm-try-completion] 10 "\n\n(fn STRING TABLE PRED POINT)"])
#@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 (#$ . 84188))
#@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# \202$ \f
\307>\203. \211\2023 \310\f\"\311\n\312 &\211\313\232\203Y \203Y :\203V @\202W \262+\207" [minibuffer-completion-table minibuffer-completion-predicate minibuffer-completion-confirm minibuffer-local-must-match-map minibuffer-local-completion-map minibuffer-completing-file-name t (nil lambda) make-composed-keymap read-from-minibuffer nil "" minibuffer-local-filename-completion-map] 18 (#$ . 84382)])
#@80 Get a file name at point in original buffer and insert it to minibuffer.
(fn)
(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 (#$ . 85127) nil])
(provide 'minibuffer)