;ELC ;;; Compiled by cyd@localhost on Mon Apr 23 22:21:02 2007 ;;; from file /home/cyd/emacs/lisp/pcomplete.el ;;; in Emacs version 22.0.99 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`pcomplete.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\302\301\303\304\305\306\307\310&\207" [provide pcomplete custom-declare-group nil "Programmable completion." :version "21.1" :group processes] 8) #@66 *A regexp of filenames to be disregarded during file completion. (custom-declare-variable 'pcomplete-file-ignore 'nil '(#$ . -738) :type '(choice regexp (const :tag "None" nil)) :group 'pcomplete) #@67 *A regexp of names to be disregarded during directory completion. (custom-declare-variable 'pcomplete-dir-ignore 'nil '(#$ . -941) :type '(choice regexp (const :tag "None" nil)) :group 'pcomplete) #@58 *If non-nil, ignore case when doing filename completion. (custom-declare-variable 'pcomplete-ignore-case '(memq system-type '(ms-dos windows-nt cygwin)) '(#$ . -1144) :type 'boolean :group 'pcomplete) #@114 *If non-nil, automatically list possibilities on partial completion. This mirrors the optional behavior of tcsh. (custom-declare-variable 'pcomplete-autolist 'nil '(#$ . -1352) :type 'boolean :group 'pcomplete) #@57 *A list of characters which constitute a proper suffix. (custom-declare-variable 'pcomplete-suffix-list '(list 47 58) '(#$ . -1569) :type '(repeat character) :group 'pcomplete) #@180 *If non-nil, use shortest completion if characters cannot be added. This mirrors the optional behavior of tcsh. A non-nil value is useful if `pcomplete-autolist' is non-nil too. (custom-declare-variable 'pcomplete-recexact 'nil '(#$ . -1753) :type 'boolean :group 'pcomplete) #@59 *List of characters to quote when completing an argument. (custom-declare-variable 'pcomplete-arg-quote-list 'nil '(#$ . -2036) :type '(choice (repeat character) (const :tag "Don't quote" nil)) :group 'pcomplete) #@418 *A hook which is run to quote a character within a filename. Each function is passed both the filename to be quoted, and the index to be considered. If the function wishes to provide an alternate quoted form, it need only return the replacement string. If no function provides a replacement, quoting shall proceed as normal, using a backslash to quote any character which is a member of `pcomplete-arg-quote-list'. (custom-declare-variable 'pcomplete-quote-arg-hook 'nil '(#$ . -2256) :type 'hook :group 'pcomplete) #@117 *A function to that will be called to display a manual page. It will be passed the name of the command to document. (custom-declare-variable 'pcomplete-man-function ''man '(#$ . -2781) :type 'function :group 'pcomplete) #@121 *This function is used to order file entries for completion. The behavior of most all shells is to sort alphabetically. (custom-declare-variable 'pcomplete-compare-entry-function ''string-lessp '(#$ . -3008) :type '(radio (function-item string-lessp) (function-item file-newer-than-file-p) (function :tag "Other")) :group 'pcomplete) #@327 *A string or function (or nil) used for context-sensitive help. If a string, it should name an Info node that will be jumped to. If non-nil, it must a sexp that will be evaluated, and whose result will be shown in the minibuffer. If nil, the function `pcomplete-man-function' will be called with the current command argument. (custom-declare-variable 'pcomplete-help 'nil '(#$ . -3349) :type '(choice string sexp (const :tag "Use man page" nil)) :group 'pcomplete) #@413 *If non-nil, expand the current argument before completing it. This means that typing something such as '$HOME/bi' followed by \[pcomplete-argument] will cause the variable reference to be resolved first, and the resultant value that will be completed against to be inserted in the buffer. Note that exactly what gets expanded and how is entirely up to the behavior of the `pcomplete-parse-arguments-function'. (custom-declare-variable 'pcomplete-expand-before-complete 'nil '(#$ . -3821) :type 'boolean :group 'pcomplete) #@646 *A function to call to parse the current line's arguments. It should be called with no parameters, and with point at the position of the argument that is to be completed. It must either return nil, or a cons cell of the form: ((ARG...) (BEG-POS...)) The two lists must be identical in length. The first gives the final value of each command line argument (which need not match the textual representation of that argument), and BEG-POS gives the beginning position of each argument, as it is seen by the user. The establishes a relationship between the fully resolved value of the argument, and the textual representation of the argument. (custom-declare-variable 'pcomplete-parse-arguments-function ''pcomplete-parse-buffer-arguments '(#$ . -4352) :type 'function :group 'pcomplete) #@522 *If non-nil, hitting the TAB key cycles through the completion list. Typical Emacs behavior is to complete as much as possible, then pause waiting for further input. Then if TAB is hit again, show a list of possible completions. When `pcomplete-cycle-completions' is non-nil, it acts more like zsh or 4nt, showing the first maximal match first, followed by any further matches on each subsequent pressing of the TAB key. \[pcomplete-list] is the key to press if the user wants to see the list of possible completions. (custom-declare-variable 'pcomplete-cycle-completions 't '(#$ . -5149) :type 'boolean :group 'pcomplete) #@777 *If the number of completions is greater than this, don't cycle. This variable is a compromise between the traditional Emacs style of completion, and the "cycling" style. Basically, if there are more than this number of completions possible, don't automatically pick the first one and then expect the user to press TAB to cycle through them. Typically, when there are a large number of completion possibilities, the user wants to see them in a list buffer so that they can know what options are available. But if the list is small, it means the user has already entered enough input to disambiguate most of the possibilities, and therefore they are probably most interested in cycling through the candidates. Set this value to nil if you want cycling to always be enabled. (custom-declare-variable 'pcomplete-cycle-cutoff-length '5 '(#$ . -5782) :type '(choice integer (const :tag "Always cycle" nil)) :group 'pcomplete) #@533 *The number of seconds to wait before restoring completion windows. Once the completion window has been displayed, if the user then goes on to type something else, that completion window will be removed from the display (actually, the original window configuration before it was displayed will be restored), after this many seconds of idle time. If set to nil, completion windows will be left on second until the user removes them manually. If set to 0, they will disappear immediately after the user enters a key other than TAB. (custom-declare-variable 'pcomplete-restore-window-delay '1 '(#$ . -6713) :type '(choice integer (const :tag "Never restore" nil)) :group 'pcomplete) #@193 *A list of functions which are called before completing an argument. This can be used, for example, for completing things which might apply to all arguments, such as variable names after a $. (custom-declare-variable 'pcomplete-try-first-hook 'nil '(#$ . -7402) :type 'hook :group 'pcomplete) #@63 *Function called for completing the initial command argument. (custom-declare-variable 'pcomplete-command-completion-function '#'(lambda nil (pcomplete-here (pcomplete-executables))) '(#$ . -7701) :type 'function :group 'pcomplete) #@60 *Function called for determining the current command name. (custom-declare-variable 'pcomplete-command-name-function ''pcomplete-command-name '(#$ . -7939) :type 'function :group 'pcomplete) #@122 *Function called when no completion rule can be found. This function is used to generate completions for every argument. (custom-declare-variable 'pcomplete-default-completion-function '#'(lambda nil (while (pcomplete-here (pcomplete-entries)))) '(#$ . -8137) :type 'function :group 'pcomplete) #@210 *If t, pare alternatives that have already been used. If nil, you will always see the completion set of possible options, no matter which of those options have already been used in previous command arguments. (custom-declare-variable 'pcomplete-use-paring 't '(#$ . -8439) :type 'boolean :group 'pcomplete) #@397 *A string that is inserted after any completion or expansion. This is usually a space character, useful when completing lists of words separated by spaces. However, if your list uses a different separator character, or if the completion occurs in a word that is already terminated by a character, this variable should be locally modified to be an empty string, or the desired separation string. (custom-declare-variable 'pcomplete-termination-string '" " '(#$ . -8753) :type 'string :group 'pcomplete) (byte-code "\301B\302\301!\204\303\301\304\"\210\305B\302\305!\204\303\305\304\"\210\306B\302\306!\204-\303\306\304\"\210\307\301!\210\307\310!\210\307\311!\210\307\312!\210\307\305!\210\307\306!\210\313B\302\313!\204T\303\313\304\"\210\314B\302\314!\204c\303\314\304\"\210\315B\302\315!\204r\303\315\304\"\210\304\207" [current-load-list pcomplete-current-completions default-boundp set-default nil pcomplete-last-window-config pcomplete-window-restore-timer make-variable-buffer-local pcomplete-last-completion-length pcomplete-last-completion-stub pcomplete-last-completion-raw pcomplete-show-help pcomplete-show-list pcomplete-expand-only-p] 3) #@184 Support extensible programmable completion. To use this function, just bind the TAB key to it, or add it to your completion functions list (it should occur fairly early in the list). (defalias 'pcomplete #[(&optional interactively) "\203@ \203@\n\203@ \306>\203@\307\f!\210 \310=\203-\311\n!@\nB\311\n\312\"\313\241\210\2026\n\211@C\244\210\nA\314\n@\313$\207\313\211\315\316\215\207" [interactively pcomplete-cycle-completions pcomplete-current-completions last-command pcomplete-last-completion-length this-command (pcomplete pcomplete-expand-and-complete pcomplete-reverse) delete-backward-char pcomplete-reverse last 2 nil pcomplete-insert-entry pcompleted (byte-code "\306\211\306\211\306\211\f\f  \307 \310\"\211\205?@\311=?\205?A\205?\312A@\313>$.\n\207" [pcomplete-stub pcomplete-seen pcomplete-norm-func pcomplete-args pcomplete-last pcomplete-index nil pcomplete-completions pcomplete-do-complete listed pcomplete-insert-entry (sole shortest) pcomplete-autolist pcomplete-suffix-list completions result pcomplete-last-completion-raw] 6) pcomplete-last-completion-stub pcomplete-last-completion-raw] 6 (#$ . 9932) "p"]) #@51 If cycling completion is in use, cycle backwards. (defalias 'pcomplete-reverse #[nil "\300\301!\207" [call-interactively pcomplete] 2 (#$ . 11114) nil]) #@88 Expand the textual value of the current argument. This will modify the current buffer. (defalias 'pcomplete-expand-and-complete #[nil "\301\302 )\207" [pcomplete-expand-before-complete t pcomplete] 1 (#$ . 11273) nil]) #@56 Complete without reference to any cycling completions. (defalias 'pcomplete-continue #[nil "\302\211\303\304!\207" [pcomplete-current-completions pcomplete-last-completion-raw nil call-interactively pcomplete] 3 (#$ . 11499) nil]) #@88 Expand the textual value of the current argument. This will modify the current buffer. (defalias 'pcomplete-expand #[nil "\306\211\307 \210\n\2050\nG\310V\2050\311 !\210\n\2050\312\313\n@\306\f$\204(\314 !\210\nA\211\204\315*\207" [pcomplete-expand-only-p pcomplete-expand-before-complete pcomplete-current-completions pcomplete-last-completion-length pcomplete-last-completion-raw pcomplete-termination-string t pcomplete 0 delete-backward-char pcomplete-insert-entry "" insert-and-inherit nil] 6 (#$ . 11738) nil]) #@64 Display any help information relative to the current argument. (defalias 'pcomplete-help #[nil "\301\302 )\207" [pcomplete-show-help t pcomplete] 1 (#$ . 12270) nil]) #@65 Show the list of possible completions for the current argument. (defalias 'pcomplete-list #[nil "\203 \203\n\306=\203\307 !\210\310\211\311\312 )\207" [pcomplete-cycle-completions pcomplete-current-completions last-command pcomplete-last-completion-length pcomplete-last-completion-raw pcomplete-show-list pcomplete-argument delete-backward-char nil t pcomplete] 3 (#$ . 12444) nil]) (byte-code "\301B\302\301!\204\303\301\304\"\210\305B\302\305!\204\303\305\304\"\210\306B\302\306!\204-\303\306\304\"\210\307B\302\307!\204<\303\307\304\"\210\310B\302\310!\204K\303\310\304\"\210\311B\302\311!\204Z\303\311\304\"\210\312B\302\312!\204i\303\312\304\"\210\304\207" [current-load-list pcomplete-args default-boundp set-default nil pcomplete-begins pcomplete-last pcomplete-index pcomplete-stub pcomplete-seen pcomplete-norm-func] 3) #@637 Return the textual content of the INDEXth argument. INDEX is based from the current processing position. If INDEX is positive, values returned are closer to the command argument; if negative, they are closer to the last argument. If the INDEX is outside of the argument list, nil is returned. The default value for INDEX is 0, meaning the current argument being examined. The special indices `first' and `last' may be used to access those parts of the list. The OFFSET argument is added to/taken away from the index that will be used. This is really only useful with `first' and `last', for accessing absolute argument positions. (defalias 'pcomplete-arg #[(&optional index offset) "\305=\203\n\306\202\307=\203 \202\n\206\306Z \203$ \\\f8\207" [index pcomplete-last pcomplete-index offset pcomplete-args first 0 last] 2 (#$ . 13314)]) #@99 Return the beginning position of the INDEXth argument. See the documentation for `pcomplete-arg'. (defalias 'pcomplete-begin #[(&optional index offset) "\305=\203\n\306\202\307=\203 \202\n\206\306Z \203$ \\\f8\207" [index pcomplete-last pcomplete-index offset pcomplete-begins first 0 last] 2 (#$ . 14179)]) #@226 Return the actual text representation of the last argument. This is different from `pcomplete-arg', which returns the textual value that the last argument evaluated to. This function returns what the user actually typed in. (defalias 'pcomplete-actual-arg #[(&optional index offset) "\302 \"`{\207" [index offset pcomplete-begin] 3 (#$ . 14511)]) (put 'pcomplete-actual-arg 'byte-optimizer 'byte-compile-inline-expand) #@49 Move the various pointers to the next argument. (defalias 'pcomplete-next-arg #[nil "T\303 \nV\205\304\305!\210\306\307\310\"\207" [pcomplete-index pcomplete-stub pcomplete-last pcomplete-arg message "No completions" throw pcompleted nil] 3 (#$ . 14938)]) (put 'pcomplete-next-arg 'byte-optimizer 'byte-compile-inline-expand) #@48 Return the command name of the first argument. (defalias 'pcomplete-command-name #[nil "\300\301\302!!\207" [file-name-nondirectory pcomplete-arg first] 3 (#$ . 15276)]) #@62 Like `string-match', but on the current completion argument. (defalias 'pcomplete-match #[(regexp &optional index offset start) "\305\206\306 \"\211\203\307 \n\f#\202\310\311\312\")\207" [index offset arg regexp start pcomplete-arg 1 string-match throw pcompleted nil] 5 (#$ . 15452)]) #@62 Like `match-string', but on the current completion argument. (defalias 'pcomplete-match-string #[(which &optional index offset) "\304\206\305 \"\211\203\306 \n\"\202\307\310\311\")\207" [index offset arg which pcomplete-arg 1 match-string throw pcompleted nil] 4 (#$ . 15752)]) (byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias pcomplete-match-beginning match-beginning pcomplete-match-end match-end] 3) #@52 Perform a programmable completion predicate match. (defalias 'pcomplete--test #[(pred arg) "\205&\302=\204%\303!\203 !\202\";\205&\304\305\306Q \"\205&\207" [pred arg t functionp string-match "^" "$"] 4 (#$ . 16180)]) (put 'pcomplete--test 'byte-optimizer 'byte-compile-inline-expand) #@60 Predicates to test the current programmable argument with. (defalias 'pcomplete-test #[(predicates &optional index offset) "\306\206\307 \" \205\202 <\204@ \n\211\205<\f\310=\204;\311\f!\203,\f\n!\2028\f;\205<\312\313\f\314Q\n\"\205<\f*\202\202 \315\211\203\200 \204\200\f@\n\211\205w\f\310=\204v\311\f!\203g\f\n!\202s\f;\205w\312\313\f\314Q\n\"\205w\f*\fA\211\204H *)\207" [index offset arg predicates pred found pcomplete-arg 1 t functionp string-match "^" "$" nil] 5 (#$ . 16485)]) #@61 Parse whitespace separated arguments in the current region. (defalias 'pcomplete-parse-buffer-arguments #[nil "ed\304\211\212 b\210`\nW\203)\305\304w\210` B\306\304w\210\307 @`\"B\202\f\310!\310 !-B\207" [args begins end begin nil " \n" "^ \n" buffer-substring-no-properties reverse] 4 (#$ . 17006)]) #@193 Setup a comint buffer to use pcomplete. COMPLETEF-SYM should be the symbol where the dynamic-complete-functions are kept. For comint mode itself, this is `comint-dynamic-complete-functions'. (defalias 'pcomplete-comint-setup #[(completef-sym) "\303\300!\210\304\303 !\210\305 J>\211\203\n\306\240\202\307 \306\")\207" [pcomplete-parse-arguments-function completef-sym elem make-local-variable pcomplete-parse-comint-arguments comint-dynamic-complete-filename pcomplete add-to-list] 4 (#$ . 17326)]) #@36 Setup shell-mode to use pcomplete. (defalias 'pcomplete-shell-setup #[nil "\300\301!\207" [pcomplete-comint-setup shell-dynamic-complete-functions] 2 (#$ . 17838)]) #@61 Parse whitespace separated arguments in the current region. (defalias 'pcomplete-parse-comint-arguments #[nil "\212\305\306!\210`)`\306\211\212 b\210`\nW\203K\307\306w\210` B\310\f\203?\311\306w\210`Sf\312=\2039\307\306w\210\202\"\306\211\204&)\313 @`\"B\202\314!\314 !-B\207" [args begins end begin skip comint-bol nil " \n" t "^ \n" 92 buffer-substring-no-properties reverse] 5 (#$ . 18009)]) #@69 Parse the command line arguments. Most completions need this info. (defalias 'pcomplete-parse-arguments #[(&optional expand-p) " \211\205\363 @\206\306C A\206`C\nGS\307\310\311!\312\311!\203\254<\203\254\204\254\211@G\203\203\307V\203\203\307V\203z\307O@\307@G^O\230\204zS\211\202VA\211\204M\307O\313\203\243\204\243`|\210\314\306\"\210\315\316\",\202\362\203\345;\203\311\203\345`|\210\317!\210\202\345<\203\341\203\341`Z\202\345\320\321!\210\203\361\315\322\313\"\202\362\n))\207" [pcomplete-parse-arguments-function results pcomplete-args pcomplete-begins pcomplete-last pcomplete-index "" 0 pcomplete-arg last pcomplete-begin t pcomplete-insert-entry throw pcomplete-completions insert-and-inherit error "Cannot expand argument" pcompleted pcomplete-stub begin pcomplete-cycle-completions pcomplete-expand-only-p completions common-stub c len pcomplete-autolist pcomplete-show-list expand-p pcomplete-last-completion-length pcomplete-current-completions] 6 (#$ . 18429)]) #@105 Return FILENAME with magic characters quoted. Magic characters are those in `pcomplete-arg-quote-list'. (defalias 'pcomplete-quote-argument #[(filename) "\204 \207 G\306\307\310\211  W\203O\311\312 #\211\203*\f P\202H H\211\203B\n>\203B\f\313\314\n!Q\202H\f\314\n!P T\211\202\f-\207" [pcomplete-arg-quote-list filename char replacement result index 0 "" nil run-hook-with-args-until-success pcomplete-quote-arg-hook "\\" char-to-string len] 6 (#$ . 19535)]) #@50 Return either directories, or qualified entries. (defalias 'pcomplete-dirs-or-entries #[(&optional regexp predicate) "\303\304 \n\206\n\305\")\304\306\307\"\"\207" [pcomplete-stub regexp predicate append pcomplete-entries #[(path) "\301!?\207" [path file-directory-p] 2] nil file-directory-p] 5 (#$ . 20026)]) (put 'pcomplete-dirs-or-entries 'byte-optimizer 'byte-compile-inline-expand) #@434 Complete against a list of directory candidates. If REGEXP is non-nil, it is a regular expression used to refine the match (files not matching the REGEXP will be excluded). If PREDICATE is non-nil, it will also be used to refine the match (files for which the PREDICATE returns nil will be excluded). If no directory information can be extracted from the completed component, `default-directory' is used as the basis for completion. (defalias 'pcomplete-entries #[(&optional regexp predicate) "\306!\307\310 !\206\f\n!\311\312 !\211\313 \n\" \203%\314\f\311\315#\2030\314\f\311\316#\204:\203@\314\f\311\317#\205J\fGV\320\f\321\",\207" [pcomplete-stub name default-directory above-cutoff completions regexp substitute-env-vars expand-file-name file-name-directory nil file-name-nondirectory file-name-all-completions pcomplete-pare-list #[(file) "\302 \"?\207" [regexp file string-match] 3] #[(file) " !?\207" [predicate file] 2] #[(file) "\211GSH\303=\203 \205\304 \"\207\n\205\304\n\"\207" [file pcomplete-dir-ignore pcomplete-file-ignore 47 string-match] 3] sort #[(l r) "\211GSH\306=\203\307GSO\202 \211GSH\306=\203' \307 GSO\202( \f\2034 \n\231\2028 \n\"*\207" [l r right left above-cutoff pcomplete-compare-entry-function 47 0] 4] predicate pcomplete-file-ignore pcomplete-dir-ignore pcomplete-cycle-cutoff-length] 5 (#$ . 20424)]) #@59 Like `pcomplete-entries', but doesn't ignore any entries. (defalias 'pcomplete-all-entries #[(&optional regexp predicate) "\304\211\305\n \"*\207" [pcomplete-dir-ignore pcomplete-file-ignore regexp predicate nil pcomplete-entries] 3 (#$ . 21820)]) (put 'pcomplete-all-entries 'byte-optimizer 'byte-compile-inline-expand) #@41 Complete amongst a list of directories. (defalias 'pcomplete-dirs #[(&optional regexp) "\301\302\"\207" [regexp pcomplete-entries file-directory-p] 3 (#$ . 22149)]) (put 'pcomplete-dirs 'byte-optimizer 'byte-compile-inline-expand) #@57 Complete amongst a list of directories and executables. (defalias 'pcomplete-executables #[(&optional regexp) "\301\302\"\207" [regexp pcomplete-entries file-executable-p] 3 (#$ . 22387)]) (put 'pcomplete-executables 'byte-optimizer 'byte-compile-inline-expand) #@61 Find the completion function to call for the given COMMAND. (defalias 'pcomplete-find-completion-function #[(command) "\303\304\305!\306 R!\211\204\303\304 P!\n\205\307\n!\205\n)\207" [major-mode command sym intern-soft "pcomplete/" symbol-name "/" fboundp] 6 (#$ . 22656)]) #@65 Return a list of completions for the current argument position. (defalias 'pcomplete-completions #[nil "\300\301\215\207" [pcomplete-completions (byte-code "\306!\2055 \nU\203 \207\307\f !\206 \310 T\311  \nV\2030\312\313!\210\314\315\310\"\210 \210)\207" [pcomplete-expand-before-complete pcomplete-index pcomplete-last pcomplete-command-completion-function pcomplete-command-name-function pcomplete-default-completion-function pcomplete-parse-arguments pcomplete-find-completion-function nil pcomplete-arg message "No completions" throw pcompleted sym pcomplete-stub] 4)] 2 (#$ . 22946)]) #@369 Complete a set of OPTIONS, each beginning with PREFIX (?- by default). PREFIX may be t, in which case no PREFIX character is necessary. If NO-GANGING is non-nil, each option is separate (-xy is not allowed). If ARGS-FOLLOW is non-nil, then options which take arguments may have the argument appear after a ganged set of options. This is how tar behaves, for example. (defalias 'pcomplete-opt #[(options &optional prefix no-ganging args-follow) " U\203S\306 \307\230\203S\nG\310\311\211! !W\203H\n H\211\312=\2035\313\n \"\211\"A)\202\f\314>\204A\315\f! B T\211\202\316\317\320\321\322 !\"\",\207\306 \211#G\323V\205L#;\205L#\310H$\206n\324=\205LT\306 % V\203\210\325\326!\210\316\327\311\"\210#\323H\nG\310\311\211\211\"&'! T!W\205J\n H'\n TH\211&\312=\203\307\313\n T\"\211\"A\"@\"\202\312\311\"\f'=\203C&\330>\203C W\203\367T\306 % V\203C\325\326!\210\316\327\311\"\210\202C\316\317&\331=\203\f\311(\332(\333\")\202A&\334=\203\311(\332(\335\")\202A&\336=\203*\311\202A&\337=\2036\332 \202A&\312=\205A\340\"!\"\210 T\211\202\235.)\207" [pcomplete-index pcomplete-last options choices char index pcomplete-arg "-" 0 nil 40 read-from-string (47 42 63 46) char-to-string throw pcomplete-completions mapcar #[(opt) "\301P\207" [opt "-"] 2] pcomplete-uniqify-list 1 45 message "No completions" pcompleted (40 47 42 63 46) 47 pcomplete-entries file-directory-p 42 file-executable-p 63 46 eval len result arg prefix pcomplete-stub arg-char opt-char regexp] 7 (#$ . 23559)]) #@99 Complete against the current argument, if at the end. See the documentation for `pcomplete-here'. (defalias 'pcomplete--here #[(&optional form stub paring form-only) " W\203G\n\306=\203\307\2020\n\310=\2040\311 \211;\203/\n\203)\n\f!\202,\312\f! B)T\311  V\203E\313\314!\210\315\316\307\"\210\310\207\203T\317 \210\315\316\310\"\210\203\\\n\310=\204h\n\306=\203m\307\202t\n\206r\312\204}\320\321!\210\315\322\323!\"\207" [pcomplete-index pcomplete-last paring pcomplete-seen arg pcomplete-stub 0 nil t pcomplete-arg file-truename message "No completions" throw pcompleted pcomplete--help run-hooks pcomplete-try-first-hook pcomplete-completions eval pcomplete-show-help stub pcomplete-norm-func form-only form] 5 (#$ . 25121)]) #@1461 Complete against the current argument, if at the end. If completion is to be done here, evaluate FORM to generate the list of strings which will be used for completion purposes. If STUB is a string, use it as the completion stub instead of the default (which is the entire text of the current argument). For an example of when you might want to use STUB: if the current argument text is 'long-path-name/', you don't want the completions list display to be cluttered by 'long-path-name/' appearing at the beginning of every alternative. Not only does this make things less intelligle, but it is also inefficient. Yet, if the completion list does not begin with this string for every entry, the current argument won't complete correctly. The solution is to specify a relative stub. It allows you to substitute a different argument from the current argument, almost always for the sake of efficiency. If PARING is nil, this argument will be pared against previous arguments using the function `file-truename' to normalize them. PARING may be a function, in which case that function is used for normalization. If PARING is t, the argument dealt with by this call will not participate in argument paring. If it is the integer 0, all previous arguments that have been seen will be cleared. If FORM-ONLY is non-nil, only the result of FORM will be used to generate the completions list. This means that the hook `pcomplete-try-first-hook' will not be run. (defalias 'pcomplete-here '(macro . #[(&optional form stub paring form-only) "\304\305D \n \257\207" [form stub paring form-only pcomplete--here quote] 5 (#$ . 25895)])) #@66 An alternate form which does not participate in argument paring. (defalias 'pcomplete-here* '(macro . #[(&optional form stub form-only) "\303 \304\n\257\207" [form stub form-only pcomplete-here t] 5 (#$ . 27533)])) #@67 If the only window change was due to Completions, restore things. (defalias 'pcomplete-restore-windows #[nil "\203#\304\305!\211\205\306 !\211\203\"\307\n!\203\"\310 !\210\311!\210*\312\211\211\207" [pcomplete-last-window-config cbuf cwin pcomplete-window-restore-timer get-buffer "*Completions*" get-buffer-window window-live-p bury-buffer set-window-configuration nil] 3 (#$ . 27756)]) (byte-code "\300\301!\204 \302\301\303\"\210\300\207" [fboundp event-matches-key-specifier-p defalias eq] 3) (defalias 'pcomplete-read-event #[(&optional prompt) "\301\302!\203\n\302!\207\303!\304H\207" [prompt fboundp read-event read-key-sequence 0] 2]) (byte-code "\300\301!\204 \302\301\303\"\210\300\207" [fboundp event-basic-type defalias event-key] 3) #@77 List in help buffer sorted COMPLETIONS. Typing SPC flushes the help buffer. (defalias 'pcomplete-show-completions #[(completions) "p \203\f\306 !\210\307\n\204\310 \311\220\312 !\221\210\313\314!\210\307\315\316\215\n\2031 \2031\317 \307\320#*\207" [curbuf pcomplete-window-restore-timer pcomplete-last-window-config completions event pcomplete-restore-window-delay cancel-timer nil current-window-configuration "*Completions*" display-completion-list message "Hit space to flush" done (byte-code "r\306\307!q\210\310 \211)\205p\311\312\"\203#\313 !\210\314\315\316\314\"\210\202\311\317\"\2041\311\320\"\203e\321\307\322\"\206<\323\307\324\"\325 \326\327\330 \"r\331\216\332\n\333\"\210\334d!\203Zeb\210\202]\335 \210-\336\337!\210\202C\315\316\314\"\210\202\207" [event pcomplete-last-window-config win save-selected-window-alist save-selected-window-window unread-command-events get-buffer "*Completions*" pcomplete-read-event event-matches-key-specifier-p 32 set-window-configuration nil throw done tab 9 get-buffer-window 0 display-buffer not-this-window selected-window mapcar #[(frame) "\301!D\207" [frame frame-selected-window] 3] frame-list ((byte-code "\305\211\203/\n@\306 @!\203(\307 \211A@)!\203(\310 @ \211A@)\"\210\nA\211\204*\307\f!\203;\311\f\312\"\210\305\207" [save-selected-window-alist elt #1=#:--cl-dolist-temp-- x save-selected-window-window nil frame-live-p window-live-p set-frame-selected-window select-window norecord] 4)) select-window norecord pos-visible-in-window-p scroll-up message ""] 4) run-with-timer pcomplete-restore-windows] 5 (#$ . 28524)]) #@89 Insert a completion entry at point. Returns non-nil if a space was appended at the end. (defalias 'pcomplete-insert-entry #[(stub entry &optional addsuffix raw-p) "` \204\306\n\203 \fG\307O\202\310 \fG\307O!!\210\202H\311\310\f!G!\210`Sf\312=\203:\306 \313\314O!\210 \314\307O\306\n\203C \202F\310 !!\210\307`Sf>\204_\203_\306!\210\315`Z\f *\207" [here pcomplete-ignore-case raw-p entry stub space-added insert-and-inherit nil pcomplete-quote-argument delete-backward-char 92 0 1 t pcomplete-suffix-list addsuffix pcomplete-termination-string pcomplete-last-completion-length pcomplete-last-completion-stub] 5 (#$ . 30159)]) #@182 Dynamically complete at point using STUB and COMPLETIONS. This is basically just a wrapper for `pcomplete-stub' which does some extra checking, and munging of the COMPLETIONS list. (defalias 'pcomplete-do-complete #[(stub completions) ";\204\306\307!\210\310\311\312\"\210 \204)\312\203$G\313V\203$\306\314\"\210\207\306\315!\210\207\n\203o \203o\316 \317 \f\313\fGGZO!!\320\321 \"\211\211\203a\322\303 @!\"\210A\211\204O)\320\323\324\320\325 \" \326#\"*\203x\327 !\207\330 \"\207" [stub completions pcomplete-use-paring pcomplete-seen arg pcomplete-norm-func message "Cannot complete argument" throw pcompleted nil 0 "No completions of %s" "No completions" pcomplete-arg file-name-as-directory mapcar directory-file-name add-to-list #[(elem) "\302 \"\207" [elem prefix file-relative-name] 3] pcomplete-pare-list #[(elem) "\302 \"\207" [elem prefix expand-file-name] 3] #[(elem) "\303 !!\n\235\207" [pcomplete-norm-func elem pcomplete-seen directory-file-name] 3] pcomplete-show-completions pcomplete-stub prefix p pcomplete-show-list] 7 (#$ . 30818)]) #@556 Dynamically complete STUB from CANDIDATES list. This function inserts completion characters at point by completing STUB from the strings in CANDIDATES. A completions listing may be shown in a help buffer if completion is ambiguous. Returns nil if no completion was inserted. Returns `sole' if completed with the only completion match. Returns `shortest' if completed with the shortest of the matches. Returns `partial' if completed as far as possible with the matches. Returns `listed' if a completion listing was shown. See also `pcomplete-filename'. (defalias 'pcomplete-stub #[(stub candidates &optional cycle-p) "\306\307\n\"\310 \n\"\311\211\f\204/ \203( G\312V\203(\313\314 \"\210\202\245\313\315!\210\202\245\fG\316U\203I\f@\211 \230\203C\313\317!\210\320\202\245\203i\204`\203`\fGX\203i\f@\f\202\245\321 \n\"\203\211 \230\203\211 \f\235\203\211\313\322!\210\323\202\245\204\224 \230\203\236\324\f!\210\325\202\245\313\326!\210\327 -B\207" [pcomplete-ignore-case completion-ignore-case candidates stub completions entry mapcar list all-completions nil 0 message "No completions of %s" "No completions" 1 "Sole completion" sole try-completion "Completed shortest" shortest pcomplete-show-completions listed "Partially completed" partial result pcomplete-cycle-completions cycle-p pcomplete-cycle-cutoff-length pcomplete-current-completions pcomplete-recexact pcomplete-autolist] 4 (#$ . 31913)]) #@112 Produce context-sensitive help for the current argument. If specific documentation can't be given, be generic. (defalias 'pcomplete--help #[nil "\203,;\203\304\305!\204<\203,<\203 \306\307\310!\"\207\311\213\210\312\313!\210\305K!\207 \203C\n \211\205A G\314V\205A !)\207\306\315!\207" [pcomplete-help pcomplete-man-function pcomplete-command-name-function cmd fboundp Info-goto-node message "%s" eval ((info)) switch-to-buffer-other-window "*info*" 0 "No context-sensitive help available"] 5 (#$ . 33381)]) #@190 Destructively remove from list L all elements matching any in list R. Test is done using `equal'. If PRED is non-nil, it is a function used for further removal. Returns the resultant list. (defalias 'pcomplete-pare-list #[(l r &optional pred) "\203! \203@ \235\204\n\203!\n@!\203!A\211\204\211\203] A\203V \203; \211A@) \235\204J\n\203V\n \211A@)!\203V \211\211AA)\241\210\202' A\211\204')\207" [l r pred m x] 3 (#$ . 33914)]) #@33 Sort and remove multiples in L. (defalias 'pcomplete-uniqify-list #[(l) "\303\304\"\211\211\203/ A\203( @ \211A@)\230\203( \211\211AA)\241\210\202 A\211\204 )\207" [l m x sort string-lessp] 4 (#$ . 34376)]) #@63 Call CMD using `call-process' and return the simplest result. (defalias 'pcomplete-process-result #[(cmd &rest args) "\303\304!\305\216rq\210\306\307 \310\311\310\n&\210\312\310x\210e`{+\207" [#1=#:temp-buffer cmd args generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) apply call-process nil t "\n"] 7 (#$ . 34602)])