;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:06:27 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/pcomplete.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\210\312\313\314\315\316DD\317\320\321\310\303&\210\312\322\314\315\323DD\324\320\325\310\303&\210\312\326\314\315\327DD\330\320\331\310\303&\210\312\332\314\315\333DD\334\320\331\310\303&\210\312\335\314\315\336DD\337\320\340\310\303&\210\341\335\304\342#\210\312\343\314\315\344DD\345\320\331\310\303&\210\346\347\350\304#\210\351\211\203\227\211@\347
N\203\220\350
N\204\220\352\350\347N#\210
A\266\202\202v\210\341\347\350\353#\210\312\354\314\315\355DD\356\320\315\310\303&\210\312\357\314\315\360DD\361\320\362\310\303&\210\312\363\314\315\364DD\365\320\366\310\303&\210\312\367\314\315\370DD\371\320\331\310\303&\210\312\372\314\315\373DD\374\320\315\310\303&\210\312\375\314\315\376DD\377\320\331\310\303&\210\312\201@\314\315\201ADD\201B\320\201C\310\303&\210\312\201D\314\315\201EDD\201F\320\201G\310\303&\210\312\201H\314\315\201IDD\201J\320\201K\310\303&\207" [require comint custom-declare-group pcomplete nil "Programmable completion." :version "21.1" :group processes custom-declare-variable pcomplete-file-ignore funcall function #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A regexp of filenames to be disregarded during file completion." :type (choice regexp (const :tag "None" nil)) pcomplete-dir-ignore #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A regexp of names to be disregarded during directory completion." (choice regexp (const :tag "None" nil)) pcomplete-ignore-case #[0 "\301>\207" [system-type (ms-dos windows-nt cygwin)] 2 "\n\n(fn)"] "If non-nil, ignore case when doing filename completion." boolean pcomplete-autolist #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, automatically list possibilities on partial completion.\nThis mirrors the optional behavior of tcsh." pcomplete-suffix-list #[0 "\300\301D\207" [47 58] 2 "\n\n(fn)"] "A list of characters which constitute a proper suffix." (repeat character) make-obsolete-variable "24.1" pcomplete-recexact #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, use shortest completion if characters cannot be added.\nThis mirrors the optional behavior of tcsh.\n\nA non-nil value is useful if `pcomplete-autolist' is non-nil too." defvaralias pcomplete-arg-quote-list comint-file-name-quote-list (saved-value saved-variable-comment) put "24.3" pcomplete-man-function #[0 "\300\207" [man] 1 "\n\n(fn)"] "A function to that will be called to display a manual page.\nIt will be passed the name of the command to document." pcomplete-compare-entry-function #[0 "\300\207" [string-lessp] 1 "\n\n(fn)"] "This function is used to order file entries for completion.\nThe behavior of most all shells is to sort alphabetically." (radio (function-item string-lessp) (function-item file-newer-than-file-p) (function :tag "Other")) pcomplete-help #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A string or function (or nil) used for context-sensitive help.\nIf a string, it should name an Info node that will be jumped to.\nIf non-nil, it must a sexp that will be evaluated, and whose\nresult will be shown in the minibuffer.\nIf nil, the function `pcomplete-man-function' will be called with the\ncurrent command argument." (choice string sexp (const :tag "Use man page" nil)) pcomplete-expand-before-complete #[0 "\300\207" [nil] 1 "\n\n(fn)"] "If non-nil, expand the current argument before completing it.\nThis means that typing something such as '$HOME/bi' followed by\n\\[pcomplete-argument] will cause the variable reference to be\nresolved first, and the resultant value that will be completed against\nto be inserted in the buffer.  Note that exactly what gets expanded\nand how is entirely up to the behavior of the\n`pcomplete-parse-arguments-function'." pcomplete-parse-arguments-function #[0 "\300\207" [pcomplete-parse-buffer-arguments] 1 "\n\n(fn)"] "A function to call to parse the current line's arguments.\nIt should be called with no parameters, and with point at the position\nof the argument that is to be completed.\n\nIt must either return nil, or a cons cell of the form:\n\n  ((ARG...) (BEG-POS...))\n\nThe two lists must be identical in length.  The first gives the final\nvalue of each command line argument (which need not match the textual\nrepresentation of that argument), and BEG-POS gives the beginning\nposition of each argument, as it is seen by the user.  The establishes\na relationship between the fully resolved value of the argument, and\nthe textual representation of the argument." pcomplete-cycle-completions #[0 "\300\207" [t] 1 "\n\n(fn)"] "If non-nil, hitting the TAB key cycles through the completion list.\nTypical Emacs behavior is to complete as much as possible, then pause\nwaiting for further input.  Then if TAB is hit again, show a list of\npossible completions.  When `pcomplete-cycle-completions' is non-nil,\nit acts more like zsh or 4nt, showing the first maximal match first,\nfollowed by any further matches on each subsequent pressing of the TAB\nkey.  \\[pcomplete-list] is the key to press if the user wants to see\nthe list of possible completions." pcomplete-cycle-cutoff-length #[0 "\300\207" [5] 1 "\n\n(fn)"] "If the number of completions is greater than this, don't cycle.\nThis variable is a compromise between the traditional Emacs style of\ncompletion, and the \"cycling\" style.  Basically, if there are more\nthan this number of completions possible, don't automatically pick the\nfirst one and then expect the user to press TAB to cycle through them.\nTypically, when there are a large number of completion possibilities,\nthe user wants to see them in a list buffer so that they can know what\noptions are available.  But if the list is small, it means the user\nhas already entered enough input to disambiguate most of the\npossibilities, and therefore they are probably most interested in\ncycling through the candidates.  Set this value to nil if you want\ncycling to always be enabled." (choice integer (const :tag "Always cycle" nil)) pcomplete-restore-window-delay #[0 "\300\207" [1] 1 "\n\n(fn)"] "The number of seconds to wait before restoring completion windows.\nOnce the completion window has been displayed, if the user then goes\non to type something else, that completion window will be removed from\nthe display (actually, the original window configuration before it was\ndisplayed will be restored), after this many seconds of idle time.  If\nset to nil, completion windows will be left on second until the user\nremoves them manually.  If set to 0, they will disappear immediately\nafter the user enters a key other than TAB." (choice integer (const :tag "Never restore" nil)) pcomplete-try-first-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "A list of functions which are called before completing an argument.\nThis can be used, for example, for completing things which might apply\nto all arguments, such as variable names after a $." hook] 8)
#@80 Complete amongst a list of directories and executables.

(fn &optional REGEXP)
(defalias 'pcomplete-executables #[256 "\300
\301\"\207" [pcomplete-entries file-executable-p] 4 (#$ . 7416)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\307\313\314&\210\304\315\306\307\316DD\317\312\307\313\314&\210\304\320\306\307\321DD\322\312\307\313\314&\210\304\323\306\307\324DD\325\312\326\313\314&\210\304\327\306\307\330DD\331\312\332\313\314&\207" [put pcomplete-executables byte-optimizer byte-compile-inline-expand custom-declare-variable pcomplete-command-completion-function funcall function #[0 "\300\207" [#[0 "\300\301\302
\303\"\262
!\207" [pcomplete-here nil pcomplete-entries file-executable-p] 5 "\n\n(fn)"]] 1 "\n\n(fn)"] "Function called for completing the initial command argument." :type :group pcomplete pcomplete-command-name-function #[0 "\300\207" [pcomplete-command-name] 1 "\n\n(fn)"] "Function called for determining the current command name." pcomplete-default-completion-function #[0 "\300\207" [#[0 "\300\301 !\205\n\202\207" [pcomplete-here pcomplete-entries] 2 "\n\n(fn)"]] 1 "\n\n(fn)"] "Function called when no completion rule can be found.\nThis function is used to generate completions for every argument." pcomplete-use-paring #[0 "\300\207" [t] 1 "\n\n(fn)"] "If t, pare alternatives that have already been used.\nIf nil, you will always see the completion set of possible options, no\nmatter which of those options have already been used in previous\ncommand arguments." boolean pcomplete-termination-string #[0 "\300\207" [" "] 1 " \n\n(fn)"] "A string that is inserted after any completion or expansion.\nThis is usually a space character, useful when completing lists of\nwords separated by spaces.  However, if your list uses a different\nseparator character, or if the completion occurs in a word that is\nalready terminated by a character, this variable should be locally\nmodified to be an empty string, or the desired separation string." string] 8)
(defvar pcomplete-current-completions nil)
(defvar pcomplete-last-window-config nil)
(defvar pcomplete-window-restore-timer nil)
(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\207" [make-variable-buffer-local pcomplete-current-completions pcomplete-last-completion-length pcomplete-last-completion-stub pcomplete-last-completion-raw pcomplete-last-window-config pcomplete-window-restore-timer] 2)
(defvar pcomplete-show-help nil)
(defvar pcomplete-show-list nil)
(defvar pcomplete-expand-only-p nil)
(defvar pcomplete-args nil)
(defvar pcomplete-begins nil)
(defvar pcomplete-last nil)
(defvar pcomplete-index nil)
(defvar pcomplete-stub nil)
(defvar pcomplete-seen nil)
(defvar pcomplete-norm-func nil)
(defvar pcomplete-unquote-argument-function 'comint--unquote-argument)
(defalias 'pcomplete-unquote-argument #[257 "
!\207" [pcomplete-unquote-argument-function] 3 "\n\n(fn S)"])
(put 'pcomplete-unquote-argument 'byte-optimizer 'byte-compile-inline-expand)
(defvar pcomplete-requote-argument-function 'comint--requote-argument)
(defalias 'pcomplete--common-suffix #[514 "\301\302\303\304Q\"\210\305\225\305\224Z)\207" [case-fold-search nil string-match "\\(?:.\\|\n\\)*?\\(\\(?:.\\|\n\\)*\\)�����\\(?:.\\|\n\\)*\\1\\'" "�����" 1] 7 "\n\n(fn S1 S2)"])
#@130 Provide standard completion using pcomplete's completion tables.
Same as `pcomplete' but using the standard completion UI.

(fn)
(defalias 'pcomplete-completions-at-point #[0 "\300\301\302D\215\207" [pcompleted funcall #[0 "\306\211\306\211\306\211\307 `GZ\310 ]\211`{
!\262
\205\220\311\232\2035\202N\312\"\313\314GZO\314GZO#\262
# \205r	\205r\n\315\316	\"\317\320\321\322\323\"\324\"\325\326%\266\202!\203|\327!\262`\330\331\332\"G!?\205\214\333\257\266\202.\207" [pcomplete-stub pcomplete-seen pcomplete-norm-func pcomplete-args pcomplete-last pcomplete-index nil pcomplete-completions pcomplete-begin completion-table-with-quoting pcomplete--common-suffix completion-table-subvert 0 mapcar #[257 "\301!!\207" [pcomplete-norm-func directory-file-name] 4 "\n\n(fn F)"] make-byte-code 257 "\300\302!!\301\235?\207" vconcat vector [directory-file-name] 4 "\n\n(fn F)" completion-table-case-fold :predicate :exit-function zerop #[514 "\211\301=\205\302\303!!\203\304\225b\207c\207" [pcomplete-termination-string finished looking-at regexp-quote 0] 5 "\n\n(fn S STATUS)"] pcomplete-autolist pcomplete-suffix-list pcomplete-unquote-argument-function pcomplete-requote-argument-function pcomplete-use-paring pcomplete-ignore-case pcomplete-termination-string] 14 "\n\n(fn)"]] 3 (#$ . 10733)])
(defalias 'pcomplete-std-complete #[0 "\300 \301
@A@\3028\303\304\305\233\"$\207" [pcomplete-completions-at-point completion-in-region 2 plist-get :predicate 3] 9 "\n\n(fn)"])
#@214 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).

(fn &optional INTERACTIVELY)
(defalias 'pcomplete #[256 "\211\203@\203@	\203@\n\306>\203@\307[!\210\f\310=\203.\311	!@	B\311	\312\"\313\241\210\2027	\211@C\244\210	A\314
	@\313$\207\313\211\315\316\317D\215\207" [pcomplete-cycle-completions pcomplete-current-completions last-command pcomplete-last-completion-length this-command pcomplete-last-completion-stub (pcomplete pcomplete-expand-and-complete pcomplete-reverse) delete-char pcomplete-reverse last 2 nil pcomplete-insert-entry pcompleted funcall #[0 "\306\211\306\211\306\211\f\f

\307 \310\"\211\2056\211@\311=?\2056\211A\2056\312A@\313>$.\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 pcomplete-last-completion-raw] 8 "\n\n(fn)"] pcomplete-last-completion-raw] 7 (#$ . 12275) "p"])
#@57 If cycling completion is in use, cycle backwards.

(fn)
(defalias 'pcomplete-reverse #[0 "\300\301!\207" [call-interactively pcomplete] 2 (#$ . 13434) nil])
#@94 Expand the textual value of the current argument.
This will modify the current buffer.

(fn)
(defalias 'pcomplete-expand-and-complete #[0 "\301\302 )\207" [pcomplete-expand-before-complete t pcomplete] 1 (#$ . 13597) nil])
#@62 Complete without reference to any cycling completions.

(fn)
(defalias 'pcomplete-continue #[0 "\302\211\303\304!\207" [pcomplete-current-completions pcomplete-last-completion-raw nil call-interactively pcomplete] 3 (#$ . 13827) nil])
#@94 Expand the textual value of the current argument.
This will modify the current buffer.

(fn)
(defalias 'pcomplete-expand #[0 "\306\211\307 \210\n\2051\nG\310V\2051\311[!\210\n\2051\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-char pcomplete-insert-entry "" insert-and-inherit nil] 6 (#$ . 14070) nil])
#@70 Display any help information relative to the current argument.

(fn)
(defalias 'pcomplete-help #[0 "\301\302 )\207" [pcomplete-show-help t pcomplete] 1 (#$ . 14598) nil])
#@71 Show the list of possible completions for the current argument.

(fn)
(defalias 'pcomplete-list #[0 "\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-char nil t pcomplete] 3 (#$ . 14776) nil])
#@666 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.

(fn &optional INDEX OFFSET)
(defalias 'pcomplete-arg #[512 "
\303=\203\n\304\202
\305=\203\202	\206\304Z\262\211\203&

\\\262
\n8\207" [pcomplete-last pcomplete-index pcomplete-args first 0 last] 4 (#$ . 15173)])
#@128 Return the beginning position of the INDEXth argument.
See the documentation for `pcomplete-arg'.

(fn &optional INDEX OFFSET)
(defalias 'pcomplete-begin #[512 "
\303=\203\n\304\202
\305=\203\202	\206\304Z\262\211\203&

\\\262
\n8\207" [pcomplete-last pcomplete-index pcomplete-begins first 0 last] 4 (#$ . 16044)])
#@255 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.

(fn &optional INDEX OFFSET)
(defalias 'pcomplete-actual-arg #[512 "\300\"`{\207" [pcomplete-begin] 5 (#$ . 16381)])
(put 'pcomplete-actual-arg 'byte-optimizer 'byte-compile-inline-expand)
#@55 Move the various pointers to the next argument.

(fn)
(defalias 'pcomplete-next-arg #[0 "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 (#$ . 16803)])
(put 'pcomplete-next-arg 'byte-optimizer 'byte-compile-inline-expand)
#@54 Return the command name of the first argument.

(fn)
(defalias 'pcomplete-command-name #[0 "\300\301\302!!\207" [file-name-nondirectory pcomplete-arg first] 3 (#$ . 17145)])
#@104 Like `string-match', but on the current completion argument.

(fn REGEXP &optional INDEX OFFSET START)
(defalias 'pcomplete-match #[1025 "\300\206\301\"\211\203\302#\202\303\304\305\"\207" [pcomplete-arg 1 string-match throw pcompleted nil] 9 (#$ . 17326)])
#@97 Like `match-string', but on the current completion argument.

(fn WHICH &optional INDEX OFFSET)
(defalias 'pcomplete-match-string #[769 "\300\206\301\"\211\203\302\"\202\303\304\305\"\207" [pcomplete-arg 1 match-string throw pcompleted nil] 7 (#$ . 17601)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias pcomplete-match-beginning match-beginning pcomplete-match-end match-end] 3)
#@67 Perform a programmable completion predicate match.

(fn PRED ARG)
(defalias 'pcomplete--test #[514 "
\205&
\300=\204%\301!\203

!\202\"
;\205&\302\303\304Q\"\205&
\207" [t functionp string-match "^" "$"] 6 (#$ . 18011)])
(put 'pcomplete--test 'byte-optimizer 'byte-compile-inline-expand)
#@100 Predicates to test the current programmable argument with.

(fn PREDICATES &optional INDEX OFFSET)
(defalias 'pcomplete-test #[769 "\300\206\301\"\205~<\204>

\2059
\302=\2048\303!\203)

!\2025
;\2059\304\305\306Q\"\2059
\266\202\202~\307
\203|\211\204|
@
\205q
\302=\204p\303!\203a

!\202m
;\205q\304\305\306Q\"\205q
\266\202\262

A\262\202@\262
\207" [pcomplete-arg 1 t functionp string-match "^" "$" nil] 12 (#$ . 18316)])
#@67 Parse whitespace separated arguments in the current region.

(fn)
(defalias 'pcomplete-parse-buffer-arguments #[0 "ed\300\211\212b\210`W\203'\301\300w\210`B\262\302\300w\210\303@`\"
B\262
\202\211\237\237)B\207" [nil " 	\n" "^ 	\n" buffer-substring-no-properties] 7 (#$ . 18782)])
#@213 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'.

(fn COMPLETEF-SYM)
(defalias 'pcomplete-comint-setup #[257 "\301\300!\210\302\303\304\305\306\307$\210\301
!\310J!L\210\211J\311
>\206-\312
>\206-\313
>\206-\314
>\211\2037\211\315\240\202;\316\315\"\207" [pcomplete-parse-arguments-function make-local-variable pcomplete-parse-comint-arguments add-hook completion-at-point-functions pcomplete-completions-at-point nil local copy-sequence comint-filename-completion shell-filename-completion shell-dynamic-complete-filename comint-dynamic-complete-filename pcomplete add-to-list] 6 (#$ . 19079)])
#@44 Setup `shell-mode' to use pcomplete.

(fn)
(defalias 'pcomplete-shell-setup #[0 "\300\301!\207" [pcomplete-comint-setup comint-dynamic-complete-functions] 2 (#$ . 19832)])
#@67 Parse whitespace separated arguments in the current region.

(fn)
(defalias 'pcomplete-parse-comint-arguments #[0 "\212\300\301!\210`)`\301\211\212b\210`W\203A\302\301w\210`B\262\303\301w\210\301f\304=\2035\305u\210l\2045\305u\210\202\306@`\"
B\262
\202\211\237\237)B\207" [comint-bol nil " 	\n" "^ 	\n\\" 92 1 buffer-substring-no-properties] 7 (#$ . 20010)])
(make-obsolete 'pcomplete-parse-comint-arguments 'comint-parse-pcomplete-arguments "24.1")
#@94 Parse the command line arguments.  Most completions need this info.

(fn &optional EXPAND-P)
(defalias 'pcomplete-parse-arguments #[256 " \211\205\312\211@\206
\306C\211A\206`C	GS\307\310\311!\312\311!\203\212
<\203\212\204\212
\211@

G
\203g\211\307V\203g\211\307V\203`\307O@\307@G^O\230\204`\211S\262
\202B
A\262\2028\307O\313\203\201\204\201`|\210\314\306
\"\210\315\316\"\266\204\202\310\203\273
;\203\242\211\203\273\211`|\210\317
!\210\202\273
<\203\267\203\267`
Z
\202\273\320\321!\210\203\307\315\322\313\"\202\310	\262
\207" [pcomplete-parse-arguments-function pcomplete-args pcomplete-begins pcomplete-last pcomplete-index pcomplete-stub "" 0 pcomplete-arg last pcomplete-begin t pcomplete-insert-entry throw pcomplete-completions insert-and-inherit error "Cannot expand argument" pcompleted pcomplete-cycle-completions pcomplete-expand-only-p pcomplete-autolist pcomplete-show-list pcomplete-last-completion-length pcomplete-current-completions] 12 (#$ . 20480)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias pcomplete-quote-argument comint-quote-filename nil make-obsolete "24.3"] 4)
#@83 Return either directories, or qualified entries.

(fn &optional REGEXP PREDICATE)
(defalias 'pcomplete-dirs-or-entries #[512 "\300\301\302\303\304\305\306\"\307\"\310\311%\"\207" [pcomplete-entries nil make-byte-code 257 "\302
!\206\300\203\303\300\"\205\301?\206\301
!\207" vconcat vector [file-directory-p string-match] 4 "\n\n(fn F)"] 11 (#$ . 21663)])
(put 'pcomplete-dirs-or-entries 'byte-optimizer 'byte-compile-inline-expand)
#@89 Like `pcomplete-entries' but without env-var handling.

(fn &optional REGEXP PREDICATE)
(defalias 'pcomplete--entries #[512 "\204	\205	\302\303\304\305\306\"\307\"\310\311%\266\202\205,\302\303\312\305\306!\313\"\310\311%
\2048\211\2048\202a
\204D\204D\211\202a\211\204P\204P
\202a\302\303\314\305\306#\315\"\316\317%\302\320\321\305\306!\322\"\323\324%\207" [pcomplete-file-ignore pcomplete-dir-ignore make-byte-code 257 "\211
GSH\302=\203\301\205\303\301\"\202\300\205\303\300\"?\207" vconcat vector [47 string-match] 4 "\n\n(fn FILE)" "\301\300\"\207" [string-match] "\302\203\n\302
!\205\301\203\301
!\205\300?\206\300
!\207" [] 3 "\n\n(fn F)" 771 "\211\305=\203	\203\305\306\307B\310#ABB\207\311\n\312\313\300\314&*\207" [pcomplete-compare-entry-function pcomplete-ignore-case completion-ignore-case completion-ignored-extensions metadata cycle-sort-function #[257 "\301
\"\207" [pcomplete-compare-entry-function sort] 4 "\n\n(fn COMPS)"] completion-file-name-table nil completion-table-with-predicate comint-completion-file-name-table strict] 10 "\n\n(fn S P A)"] 12 (#$ . 22115)])
(defconst pcomplete--env-regexp "\\(?:\\`\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(\\$\\(?:{\\([^}]+\\)}\\|\\(?2:[[:alnum:]_]+\\)\\)\\)")
#@467 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.

(fn &optional REGEXP PREDICATE)
(defalias 'pcomplete-entries #[512 "\300\"\301\302\303\304\305!\306\"\307\310%\207" [pcomplete--entries make-byte-code 771 "\302G\303	\"\203)\304\305\224OB\262\306\307\310\"!B\262\305\225\302O\262\202
\203:\311=\204O\242\312=\204O\313\314B\237\315#\316\300$\262
\202\307\317\320\321\322\"\"\313\314B\237\315#\323
\300\243\206k\315$\211@Y\203\223\311=\203\204\316\300\n$\202\305\312
@GZ\\ABB\202\305\311=\203\272\316\300\n$@Z\321\324\325\326\327\330!\331\"\332\333%\"\266\202\202\305\312GZ\\ABB\266\203\207" vconcat vector [pcomplete--env-regexp nil string-match 0 1 getenv match-string 2 t boundaries mapconcat identity "" complete-with-action apply + mapcar length completion-boundaries make-byte-code 257 "\211\300\301O\207" vconcat vector [nil] 4 "\n\n(fn S)"] 17 "\n\n(fn STRING PRED ACTION)"] 9 (#$ . 23407)])
#@92 Like `pcomplete-entries', but doesn't ignore any entries.

(fn &optional REGEXP PREDICATE)
(defalias 'pcomplete-all-entries #[512 "\302\211\303\"*\207" [pcomplete-dir-ignore pcomplete-file-ignore nil pcomplete-entries] 5 (#$ . 24763)])
(put 'pcomplete-all-entries 'byte-optimizer 'byte-compile-inline-expand)
#@64 Complete amongst a list of directories.

(fn &optional REGEXP)
(defalias 'pcomplete-dirs #[256 "\300
\301\"\207" [pcomplete-entries file-directory-p] 4 (#$ . 25082)])
(put 'pcomplete-dirs 'byte-optimizer 'byte-compile-inline-expand)
#@75 Find the completion function to call for the given COMMAND.

(fn COMMAND)
(defalias 'pcomplete-find-completion-function #[257 "\301\302\303!\304R!\211\204\301\302P!\262
\211\205\305
!\205\211\207" [major-mode intern-soft "pcomplete/" symbol-name "/" fboundp] 6 (#$ . 25321)])
#@71 Return a list of completions for the current argument position.

(fn)
(defalias 'pcomplete-completions #[0 "\300\301\302D\215\207" [pcomplete-completions funcall #[0 "\306!\2053	\nU\203 \207\307\f !\206
\310	T\311 	\nV\203.\312\313!\210\314\315\310\"\210
 \210\262
\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 pcomplete-stub] 5 "\n\n(fn)"]] 3 (#$ . 25612)])
#@483 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.
Arguments NO-GANGING and ARGS-FOLLOW are currently ignored.

(fn OPTIONS &optional PREFIX NO-GANGING ARGS-FOLLOW)
(defalias 'pcomplete-opt #[1025 "	U\203O\303 \304\230\203OG\305\306\211W\203EH\262
\307=\2031\310\"\211A\262\210\202
\311>\204>\312!
B\262
T\262\202\313\314\315\316\317!\"\"\207\303 \211G\320V\205,
\211;\205,
\211\305H\206e\321=\205,
T\303 	V\203~\322\323!\210\313\324\306\"\210\211\320HG\305\306\211\211TW\205*
\nH\262\nTH\262
\307=\203\264\310T\"\262
\211A\262\211@\262
\202\267\306\262
=\203#

\325>\203#
	W\203\341T\303 	V\203#
\322\323!\210\313\324\306\"\210\202#
\313\314\326=\203\363\306\327
\330\"\262
\202!
\331=\203
\306\327
\332\"\262
\202!
\333=\203

\306\202!
\334=\203
\327 \202!
\307=\205!
\335!\"\210T\262\202\207\266\206\207" [pcomplete-index pcomplete-last pcomplete-stub pcomplete-arg "-" 0 nil 40 read-from-string (47 42 63 46) char-to-string throw pcomplete-completions mapcar #[257 "\300
P\207" ["-"] 3 "\n\n(fn OPT)"] 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] 17 (#$ . 26243)])
#@142 Complete against the current argument, if at the end.
See the documentation for `pcomplete-here'.

(fn &optional FORM STUB PARING FORM-ONLY)
(defalias 'pcomplete--here #[1024 "	W\203F
\306=\203\307\202/
\310=\204/\311 \211;\203.\203(
!\202+\312
!\nB\210T\311 	V\203D\313\314!\210\315\316\307\"\210\310\207\f\203R\317 \210\315\316\310\"\210\203X
\310=\204d
\306=\203i\307\202o
\206n\312\211\204w\320\321!\210\315\322\323!\203\205 \202\211\324!\"\207" [pcomplete-index pcomplete-last pcomplete-seen pcomplete-stub pcomplete-show-help pcomplete-norm-func 0 nil t pcomplete-arg file-truename message "No completions" throw pcompleted pcomplete--help run-hooks pcomplete-try-first-hook pcomplete-completions functionp eval] 8 (#$ . 27810)])
#@1507 Complete against the current argument, if at the end.
If completion is to be done here, evaluate FORM to generate the completion
table 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
intelligible, 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.

(fn &optional FORM STUB PARING FORM-ONLY)
(defalias 'pcomplete-here '(macro . #[1024 "\300\301\302E\257\207" [pcomplete--here lambda nil] 9 (#$ . 28591)]))
(put 'pcomplete-here 'edebug-form-spec t)
#@102 An alternate form which does not participate in argument paring.

(fn &optional FORM STUB FORM-ONLY)
(defalias 'pcomplete-here* '(macro . #[768 "\300\301\257\207" [pcomplete-here t] 8 (#$ . 30266)]))
(put 'pcomplete-here* 'edebug-form-spec t)
#@73 If the only window change was due to Completions, restore things.

(fn)
(defalias 'pcomplete-restore-windows #[0 "\203\302\303!\211\205\304
!\305
!\203\306!\210\307!\210\266\310\211\211\207" [pcomplete-last-window-config pcomplete-window-restore-timer get-buffer "*Completions*" get-buffer-window window-live-p bury-buffer set-window-configuration nil] 5 (#$ . 30519)])
(defalias 'pcomplete-event-matches-key-specifier-p 'eq)
(defalias 'pcomplete-read-event #[256 "\300\301!\203\n\301
!\207\302
!\303H\207" [fboundp read-event read-key-sequence 0] 3 "\n\n(fn &optional PROMPT)"])
#@95 List in help buffer sorted COMPLETIONS.
Typing SPC flushes the help buffer.

(fn COMPLETIONS)
(defalias 'pcomplete-show-completions #[257 "\203\n\306!\210\307	\204\310 \nr\311\312!q\210p\313 \210
\307\211\314\211\314 !\315 \210\316\317!\210+\211\"\320!\210\321
!\210)\266\322\323!\210\307C\324\325\326\327\330\331\332!\333\"\334\335%D\215	\203g#\203g\336#\307\337#\207" [pcomplete-window-restore-timer pcomplete-last-window-config default-directory buffer-read-only buffer-file-name buffer-undo-list cancel-timer nil current-window-configuration get-buffer-create "*Completions*" kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook display-completion-list internal-temp-output-buffer-show minibuffer-message "Hit space to flush" done funcall make-byte-code 0 "r\303\304!q\210\300\305 \240)\205\306\300@\307\"\203$\310	!\210\311\312\313\311\"\210\202\306\300@\314\"\2044\306\300@\315\"\203s\316\304\317\"\206?\320\304\321\"\322
!r\323\324\317\325\326\327!\330\"\331\332%DC\216\333
@\334\"\210\335d!\203feb\210\202i\336 \210*\266\337\340!\210\202\300@C\312\313\311\"\210\202\207" vconcat vector [pcomplete-last-window-config unread-command-events get-buffer "*Completions*" pcomplete-read-event pcomplete-event-matches-key-specifier-p 32 set-window-configuration nil throw done tab 9 get-buffer-window 0 display-buffer not-this-window 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 pos-visible-in-window-p scroll-up message ""] 9 "\n\n(fn)" run-with-timer pcomplete-restore-windows inhibit-modification-hooks inhibit-read-only standard-output pcomplete-restore-window-delay] 11 (#$ . 31118)])
#@132 Insert a completion entry at point.
Returns non-nil if a space was appended at the end.

(fn STUB ENTRY &optional ADDSUFFIX RAW-P)
(defalias 'pcomplete-insert-entry #[1026 "`\204 \305\203G\306O\202\307G\306O!!\210\202L\310\307!G[!\210`Sf\311=\203>\305\312\313O!\210\313\306O\262\305\203G\202J\307!!\210\306`Sf	>\204`\203`\305\n!\210\314\262
`Z\211\262
\207" [pcomplete-ignore-case pcomplete-suffix-list pcomplete-termination-string pcomplete-last-completion-length pcomplete-last-completion-stub insert-and-inherit nil comint-quote-filename delete-char 92 0 1 t] 10 (#$ . 32899)])
#@205 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.

(fn STUB COMPLETIONS)
(defalias 'pcomplete-do-complete #[514 "
;\204\304\305!\210\306\307\310\"\210\211\204)\310\203$G\311V\203$\304\312\"\210\207\304\313!\210\207\203X	\203X\314\315	\"\211\211\203K\211@\316\301\n!\"\210
A\266\202\2027\210\317\320	\205T\321\322$\262
\203c\323\324\"!\207\325\"\207" [pcomplete-use-paring pcomplete-seen pcomplete-norm-func pcomplete-show-list message "Cannot complete argument" throw pcompleted nil 0 "No completions of %s" "No completions" mapcar directory-file-name add-to-list apply-partially completion-table-with-predicate #[257 "\302!!	\235?\207" [pcomplete-norm-func pcomplete-seen directory-file-name] 4 "\n\n(fn F)"] strict pcomplete-show-completions all-completions pcomplete-stub] 9 (#$ . 33519)])
#@596 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'.

(fn STUB CANDIDATES &optional CYCLE-P)
(defalias 'pcomplete-stub #[770 "\306\"\307\"\310
\204*\203#G\311V\203#\312\313\"\210\202\300\312\314!\210\202\300
\315=\203=\262\312\316!\210\317\262
\202\300G\320U\203J\317\262
\202\300\n\203\212\204]\203]GX\203\212\321\310\322$@\323
!\204\200\324\325\326\327\330\331\f\"\332\"\333\334%\"\262@\262\210\202\300
\203\244\230\203\244
\235\203\244\312\335!\210\336\262
\202\300#\204\257\230\203\271\337!\210\340\262
\202\300\312\341!\210\342\262
\211)B\207" [pcomplete-ignore-case completion-ignore-case pcomplete-cycle-completions pcomplete-cycle-cutoff-length pcomplete-current-completions pcomplete-recexact all-completions try-completion nil 0 message "No completions of %s" "No completions" t "Sole completion" sole 1 completion-boundaries "" zerop mapcar make-byte-code 257 "\300\302\301O
P\207" vconcat vector [0] 4 "\n\n(fn C)" "Completed shortest" shortest pcomplete-show-completions listed "Partially completed" partial pcomplete-autolist] 15 (#$ . 34475)])
#@118 Produce context-sensitive help for the current argument.
If specific documentation can't be given, be generic.

(fn)
(defalias 'pcomplete--help #[0 "\203A;\203\303\304!\204<\203A<\203 \305\306\307!\"\207\310 \311\312\313\314\315\316!\317\"\320\321%DC\216\322 \210)\210\323\324!\210\304K!\207	\203V\n \211\205U\211G\313V\205U	
!\207\305\325!\207" [pcomplete-help pcomplete-man-function pcomplete-command-name-function fboundp Info-goto-node message "%s" eval current-window-configuration funcall make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 "\n\n(fn)" info switch-to-buffer-other-window "*info*" "No context-sensitive help available"] 8 (#$ . 36103)])
#@41 Sort and remove multiples in L.

(fn L)
(defalias 'pcomplete-uniqify-list #[257 "\301
\302\"\262
\211\211\203/\211A\203(\211@
\211A@)\230\203(\211
\211AA)\241\210\202\211A\262
\202\210\207" [x sort string-lessp] 5 (#$ . 36810)])
#@84 Call CMD using `call-process' and return the simplest result.

(fn CMD &rest ARGS)
(defalias 'pcomplete-process-result #[385 "\300\301!r\211q\210\302\303\304\305\306\307!\310\"\311\312%DC\216\313\314\315\316\315&\210\317\315x\210e`{*\207" [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)" apply call-process nil t "\n"] 10 (#$ . 37054)])
(provide 'pcomplete)