WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/obsolete
Viewing File: /usr/share/emacs/24.3/lisp/obsolete/complete.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:52:41 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/obsolete/complete.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(byte-code "\300\301\302\303\304\305\306\307\306\310&	\210\311\312\313\314\315\316\306\301&\210\311\317\320\321\315\322\306\301&\210\311\323\324\325\315\326\306\301&\210\311\327\330\331\315\332\306\301&\210\311\333\302\334\315\322\306\301&\207" [custom-declare-group partial-completion nil "Partial Completion of items." :prefix "pc-" :group minibuffer convenience custom-declare-variable PC-first-char 'find-file "Control how the first character of a string is to be interpreted.\nIf nil, the first character of a string is not taken literally if it is a word\ndelimiter, so that \".e\" matches \"*.e*\".\nIf t, the first character of a string is always taken literally even if it is a\nword delimiter, so that \".e\" matches \".e*\".\nIf non-nil and non-t, the first character is taken literally only for file name\ncompletion." :type (choice (const :tag "delimiter" nil) (const :tag "literal" t) (other :tag "find-file" find-file)) PC-meta-flag t "If non-nil, TAB means PC completion and M-TAB means normal completion.\nOtherwise, TAB means normal completion and M-TAB means Partial Completion." boolean PC-word-delimiters "-_. " "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')." string PC-include-file-path '("/usr/include" "/usr/local/include") "A list of directories in which to look for include files.\nIf nil, means use the colon-separated path in the variable $INCPATH instead." (repeat directory) PC-disable-includes "If non-nil, include-file support in \\[find-file] is disabled."] 10)
#@69 If non-nil, default partial completion key bindings are suppressed.
(defvar PC-default-bindings t (#$ . 2401))
#@54 A list of the environment variable names and values.
(defvar PC-env-vars-alist nil (#$ . 2518))
(defalias 'PC-bindings #[(bind) "	\f\2045\306
\307\310#\210\306\311\312#\210\306\313\314#\210\306\315\316#\210\306\n\317\320#\210\306\n\321\320#\210\306\322\323#\202\216 \205\216\306
\307\324#\210\306\311\325#\210\306\313\326#\210\306\315\327#\210\306\307\325#\210\306\330\326#\210\306\331\332#\210\306\333\332#\210\306\334\327#\210\306\n\317\335#\210\306\n\321\335#\210\306\n\331\335#\210\306\n\333\335#\210\306\336\324#*\207" [minibuffer-local-completion-map minibuffer-local-must-match-map must-match-map completion-map bind read-expression-map define-key "	" lisp-complete-symbol "	" minibuffer-complete " " minibuffer-complete-word "?" minibuffer-completion-help "
" minibuffer-complete-and-exit "\n" [remap lisp-complete-symbol] nil PC-lisp-complete-symbol PC-complete PC-complete-word PC-completion-help " " "
" PC-force-complete-and-exit "\n" "?" PC-complete-and-exit [remap lisp-complete-symbol] global-map PC-default-bindings] 4])
#@47 Internal variable used by `PC-do-completion'.
(defvar PC-do-completion-end nil (#$ . 3588))
(make-variable-buffer-local 'PC-do-completion-end)
#@92 Internal variable set in `PC-do-completion', used in
`choose-completion-string-functions'.
(defvar PC-goto-end nil (#$ . 3737))
(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\312\313\314\315&\207" [make-variable-buffer-local PC-goto-end custom-declare-variable partial-completion-mode nil "Non-nil if Partial-Completion mode is enabled.\nSee the command `partial-completion-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 `partial-completion-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :group partial-completion :type boolean] 12)
#@1275 Toggle Partial Completion mode.
With prefix ARG, turn Partial Completion mode on if ARG is positive.

When Partial Completion mode is enabled, TAB (or M-TAB if `PC-meta-flag' is
nil) is enhanced so that if some string is divided into words and each word is
delimited by a character in `PC-word-delimiters', partial words are completed
as much as possible and `*' characters are treated likewise in file names.

For example, M-x p-c-m expands to M-x partial-completion-mode since no other
command begins with that sequence of characters, and
\[find-file] f_b.c TAB might complete to foo_bar.c if that file existed and no
other file in that directory begins with that sequence of characters.

Unless `PC-disable-includes' is non-nil, the `<...>' sequence is interpreted
specially in \[find-file].  For example,
\[find-file] <sys/time.h> RET finds the file `/usr/include/sys/time.h'.
See also the variable `PC-include-file-path'.

Partial Completion mode extends the meaning of `completion-auto-help' (which
see), so that if it is neither nil nor t, Emacs shows the `*Completions*'
buffer only on the second attempt to complete.  That is, if TAB finds nothing
to complete, the first TAB just says "Next char not unique" and the
second TAB brings up the `*Completions*' buffer.
(defalias 'partial-completion-mode #[(&optional arg) "\306 	\307=\203\n?\202\310	!\311V\312\n!\210\n\204$\313\314\315\"\210\202-\204-\316\314\315\"\210\n\2035\316\2026\313\317\320\"\210\n\203G\f\204G\321\322
\"\323\324\n\203Q\325\202R\326\"\210\327\330!\203w\331\302!\210\306 \203j\306 \232\203w\332\333\n\203t\334\202u\335\"\210)\336 \210\n\207" [#1=#:last-message arg partial-completion-mode PC-disable-includes PC-env-vars-alist process-environment current-message toggle prefix-numeric-value 0 PC-bindings remove-hook find-file-not-found-functions PC-look-for-include-file add-hook choose-completion-string-functions #[(choice buffer &rest ignored) "\204\303	!\203db\210\202\n\203\nb\210\304\304\211\207" [PC-goto-end buffer PC-do-completion-end minibufferp nil] 3] mapcar #[(string) "\302\303\"\304\305	OP	\205	T\306O)B\207" [string d string-match "=" "$" 0 nil] 4] run-hooks partial-completion-mode-hook partial-completion-mode-on-hook partial-completion-mode-off-hook called-interactively-p any customize-mark-as-set message "Partial-Completion mode %sabled" "en" "dis" force-mode-line-update] 3 (#$ . 4451) (list (or current-prefix-arg 'toggle))])
(byte-code "\301\302\303\304\300!\205\n\303\211%\207" [partial-completion-mode-map add-minor-mode partial-completion-mode nil boundp] 6)
#@520 Like minibuffer-complete, but allows "b--di"-style abbreviations.
For example, "M-x b--di" would match `byte-recompile-directory', or any
name which consists of three or more words, the first beginning with "b"
and the third beginning with "di".

The pattern "b--d" is ambiguous for `byte-recompile-directory' and
`beginning-of-defun', so this would produce a list of completions
just like when normal Emacs completions are ambiguous.

Word-delimiters for the purposes of Partial Completion are "-", "_",
".", and SPC.
(defalias 'PC-complete #[nil "\304 \203\305 \207	=\204\306\n\211\203?\307!\203?\310\307!!\203?r\307!q\210\311d\"\2039\312e\306#\202;\313 )\202B\314\306!)\207" [last-command this-command minibuffer-scroll-window window PC-was-meta-key minibuffer-complete nil window-buffer buffer-name pos-visible-in-window-p set-window-start scroll-other-window PC-do-completion] 5 (#$ . 7067) nil])
#@169 Like `minibuffer-complete-word', but allows "b--di"-style abbreviations.
See `PC-complete' for details.
This can be bound to other keys, like `-' and `.', if you wish.
(defalias 'PC-complete-word #[nil "\302 =\203	\303=\203\304 \207\305\306!\207\305\306!\210m\205\307\310!\207" [PC-meta-flag last-command-event PC-was-meta-key 32 minibuffer-complete-word self-insert-command 1 PC-do-completion word] 2 (#$ . 7994) nil])
#@180 Like `minibuffer-complete-word', but allows "b--di"-style abbreviations.
See `PC-complete' for details.
This is suitable for binding to other keys which should act just like SPC.
(defalias 'PC-complete-space #[nil "\301 =\203\n\302 \207\303c\210m\205\304\305!\207" [PC-meta-flag PC-was-meta-key minibuffer-complete-word " " PC-do-completion word] 2 (#$ . 8428) nil])
#@109 Like `minibuffer-complete-and-exit', but allows "b--di"-style abbreviations.
See `PC-complete' for details.
(defalias 'PC-complete-and-exit #[nil "\301 =\203\n\302 \207\303 \207" [PC-meta-flag PC-was-meta-key minibuffer-complete-and-exit PC-do-complete-and-exit] 2 (#$ . 8806) nil])
#@109 Like `minibuffer-complete-and-exit', but allows "b--di"-style abbreviations.
See `PC-complete' for details.
(defalias 'PC-force-complete-and-exit #[nil "\301\302 )\207" [minibuffer-completion-confirm nil PC-do-complete-and-exit] 1 (#$ . 9098) nil])
(defalias 'PC-do-complete-and-exit #[nil "d\306 U\203\n\307 \207\310=\203&	\n=\204\311\312 \f#\203\"\307 \207\313\314!\207\315=\203B	
>\203?\311\312 \f#\204?\313\314!\207\307 \207\316\317!\211\205^\320=\204V\204[\307 \202^\313\314!)\207" [minibuffer-completion-confirm last-command this-command minibuffer-completion-table minibuffer-completion-predicate minibuffer-confirm-exit-commands minibuffer-prompt-end exit-minibuffer confirm test-completion field-string PC-temp-minibuffer-message " [Confirm]" confirm-after-completion PC-do-completion exit complete flag] 5])
#@107 Like `minibuffer-completion-help', but allows "b--di"-style abbreviations.
See `PC-complete' for details.
(defalias 'PC-completion-help #[nil "\301 =\203\n\302 \207\303\304!\207" [PC-meta-flag PC-was-meta-key minibuffer-completion-help PC-do-completion help] 2 (#$ . 9945) nil])
(defalias 'PC-was-meta-key #[nil "\301 G\302U?\206!\301 \303H\211\250\203\304Y\202 \305\306!>??)\207" [key this-command-keys 1 0 128 meta event-modifiers] 4])
(defvar PC-ignored-extensions 'empty-cache)
(defvar PC-delims 'empty-cache)
(defvar PC-ignored-regexp nil)
(defvar PC-word-failed-flag nil)
(defvar PC-delim-regex nil)
(defvar PC-ndelims-regex nil)
(defvar PC-delims-list nil)
#@210 A function testing whether a minibuffer completion now will work filename-style.
The function takes no arguments, and typically looks at the value
of `minibuffer-completion-table' and the minibuffer contents.
(defvar PC-completion-as-file-name-predicate #[nil "\207" [minibuffer-completing-file-name] 1] (#$ . 10625))
(defalias 'PC-chunk-after #[(string regexp) "\305	\"\204\306\302\n	#\210\307\n	#\210)	\310\225\311O\305\f\"\203)\310\211\224O)\207" [regexp string message result PC-delim-regex string-match "String %s didn't match regexp %s" error 0 nil] 4])
#@57 Like `test-completion', but ignores case when possible.
(defalias 'test-completion-ignore-case #[(str table pred) "\203\n\304	\n#\207\305\304	\n#)\207" [pred str table completion-ignore-case test-completion nil] 4 (#$ . 11204)])
#@55 Like `try-completion' but return STRING instead of t.
(defalias 'PC-try-completion #[(string alist &optional predicate) "\304	\n#\211\305=\203\202)\207" [string alist predicate result try-completion t] 5 (#$ . 11444)])
#@305 Internal function to do the work of partial completion.
Text to be completed lies between BEG and END.  Normally when
replacing text in the minibuffer, this function replaces up to
point-max (as is appropriate for completing a file name).  If
GOTO-END is non-nil, however, it instead replaces up to END.
(defalias 'PC-do-completion #[(&optional mode beg end goto-end) "\204\306 	\204
d\n\307=\203\310\202\n\f@ A\311\211BC	{DA\2055\312\313D\"E\311\211FG\311\211HI\311\211JK\311\211LM\311\211NOPQR\314=\203m\315D
#\203m\316\202\363A\203\266\317D!\206z\320\211G\203\266GG\211C\203\266\321G!\211K\203\266GK\230\204\266K\322D!P\211D\203\266	|\210Dc\210DG\\ST\232\204\327ST\323T\324QU\325T\326QV\327T\311\"WA\203.\317D!\322D!
;\203\357\330
!\202\361XXY\211Z;\203\"\331Z!\204\"\332Z!Z\333U\334\322Z!#\335YQY\317Z!\211Z\202\370DHZYPD+A\203\367\312\336D\"\203\367D
;\203H\330
!\202JX\311[X\\\312\337\\\"TK\312U\\K#\211K\203\200\\\340KO\341\\K\311OQ\\K\342\\K\202Y\343\\\341P!\211[\203\335\317[@![KZKA\211K\203\253Z\317K@!\232\204\227K\203\303\311\211A
;?\205\274
\344F\202\331	|\210Z\322D!P\211Dc\210DG\\*\202\366H\203\351HD\202\366\311\211A
;?\205\365
+A\203)E\203DE\311OGD\340EOB\202-\322D!G\317D!\211BGPD\202-DG\345G!\211JG\340V\203XG\340H\346=\204X]\344=\204T]\203XA\203X\347\202Y\340\211LK\312UJK#\211K\203\317JKH\350=\203\231J\340KOVUJKT\311ORJ\351KVGUG#K\202^JKH\352>\203\247\353\202\250\340^J\340K^\\OVJK^\\\311OQJ\351KVG\347#K)\202^\340KA\203\371\312\354JK#\211K\203\371J\340KO\355JK\342\\\311OQJ\202\327\356JPJGG\340V\203G\340H\357U\203\344I_\311\312UA\203$\360\202%\320PDBGL\\#\211K\204\260\361I\203@G\202BD
#\211N\204\260D\320\230\204\260DH\344MA\203\243\312\362D\"\203\202\320G\311K\343\363\364\365\366\347D\"\335#\341Q!NS\202\260\312\367D\"\203\260\356\364\365\366\342D\"\370#PJ\366\347D\"GTK\202\260\356\364\371D\372#PJ\347KK\203]\361I\203\306\322D\340KO!\202\314D\340KO
#\211`K`\2030M\2030A\203\311K`\311a\211b\203b@a\312Ja\"\203aKBKbA\211b\204\361*\373\320K\"G\2020\364\365D\374#G	|\210GG\\Gc\210)K\203]\312JK@\"\203T\375\340K@G\311K@$\210K@NBNKA\211K\2046\376N!\210A\203\306R\377=\204\306Ncde\232\204\216\201~\364\345d\211e\201#\201\200Qf\311Kc\203\274\312fc@\"\204\263\312\201\201c@\"\204\263c@KBKcA\211c\204\226K\203\305KN)N\204#R\201\202=\203\355g\204\355\344g\201\203\353!\210\201\204\201\202!)\202\363M\203\372	|\210Hc\210\201\205 \210\201\206F\203
\201\207\202R\377=\203\201\210\202\201\211!\210\311\202\363N\211OA\2045R\201\212>\203\252R\377=?\205?N\211K\203WK@G\230\204WKA\211K\204EK\203iR\204i\201\206\201\213!\210K\203R\204{hi=\204\344\202\363\311\211\211\356jklmR\377=\204\277\201\214\201\215Gj\"N\"\211l\203\277\344\311noR\201\202=\203\277\201\216lG\"lBG\\b\210\340\211nlGW\203:`	W\203\nlnH\227g\227=\204\370\201\217\201\220!\203\nlnHW>\203\n\201\203\347!\210ln\211TOc\210\2021A\203\"\201\217\201\221!\203\"\201\203\347!\210	S\344mln\211TOc\210	TnT\211n\202\312k\204B`k\201\217U!\203\251j\345l!VQj\201\214\201\215BG\\	{j\"\201\222\201\223N\"\"\211l\203\251n\340V\204\205lG\340V\203\251R\201\202=\203\306o\203\251lG\340V\203\251\311ol\340\347O\211l\204\306R\201\202=\203\266	\202\274k\206\274b\210*R\201\202=\203\347g\204\347m\205\246\315\201\224 	S{
#\205\246	S	|\202\246m\203R\314=\205\246\201\225\201\226 
#\202\246p\344=\204p\203ih=\204R\377=\203\217\306 qXrr\201\227\201\230!q\210p\201\231 \210rX\311\211st\344\211u\344vw\201\232 \210\201\233\201\234!\210+\211xy\201\235\201\236O\201\237\"!\210	z{|ryq\210B\203}C\202\201qZ})\201\240x!\210,\202\227\201\206\201\241!\210M\203\245A\203\245`	|\210\311,\202\363GN@\232\203\322I\203\275A\204\322M\204\322R\204\362\201\206\201\242!\210\202\362	|\210\201\243\201\244A\203\354\321BN@P!\202\357N@\"c\210\344.\207" [beg end minibuffer-completion-table table minibuffer-completion-predicate pred minibuffer-prompt-end read-file-name-internal PC-read-file-name-internal nil string-match "<\\([^\"<>]*\\)>?$" exit test-completion complete file-name-directory "" substitute-in-file-name file-name-nondirectory "[" "]" "[^" "]*" append expand-file-name file-directory-p directory-file-name replace-regexp-in-string "*\\&" "*/" "\\*.*/" "/[^/]*\\'" 0 "*" 2 file-expand-wildcards t regexp-quote 42 1 32 + (36 94 46 42 43 63 91 93 92) -1 "\\\\\\*" "[^/]*" "\\`" 36 "\\|\\*" all-completions "^/?\\([A-Za-z0-9]+\\)$" "/" mapconcat list match-string "^\\(.+/\\)\\([A-Za-z0-9]+\\)$" "[A-Za-z0-9]*[^A-Za-z0-9]" #[(c) "\301\302!!\207" [c regexp-quote string] 3] "[^-]*-" try-completion "-" set-text-properties delete-dups help PC-completion-as-file-name-predicate filename dirname dirlength str incname ambig basestr origstr env-on regex p offset abbreviated poss helpposs completion-ignore-case case-fold-search mode PC-word-delimiters PC-delims PC-delim-regex PC-ndelims-regex PC-delims-list default-directory file dir files pat PC-first-char bump PC-env-vars-alist compl x --dolist-tail-- p2 completion-ignored-extensions PC-ignored-extensions PC-ignored-regexp PC-word-failed-flag this-command last-command skip pt prefix improved i first completion-auto-help prompt-end #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output PC-do-completion-end goto-end PC-goto-end completion-base-size "\\(" "\\|" "\\)\\'" "\\(\\`\\|/\\)[.][.]?/?\\'" word delete-char PC-do-completion beep PC-temp-minibuffer-message " [Ambiguous dir name]" " [No completions]" " [No match]" (help word) " [Complete, but not unique]" PC-try-completion PC-chunk-after PC-chop-word looking-at " " "\\*" mapcar #[(x) "\302	\"\205\f	\303\225\304O\207" [skip x string-match 0 nil] 3] field-beginning test-completion-ignore-case field-string get-buffer-create "*Completions*" kill-all-local-variables erase-buffer run-hooks temp-buffer-setup-hook display-completion-list sort string-lessp internal-temp-output-buffer-show " [Next char not unique]" " [Sole completion]" format "%s"] 8 (#$ . 11678)])
(defalias 'PC-chop-word #[(new old) "\306\211\307\n	T#\211\203\307\n\fT#\211\204\2035
\203-\307\n\fT#\211\2035\f\310TO\2026\f*\207" [j i PC-delim-regex old new PC-word-failed-flag -1 string-match 0] 4])
(defvar PC-not-minibuffer nil)
#@61 A Lisp version of `temp_minibuffer_message' from minibuf.c.
(defalias 'PC-temp-minibuffer-message #[(message) "\203\301\306	\"\210\307\310!\210\301\311!\207\312\313!\203\313	!\207d\212\nb\210	c\210)\314\307\310!\210\nd|\210\f\2058\315\316\211*\207" [PC-not-minibuffer message point-max inhibit-quit quit-flag unread-command-events "%s" sit-for 2 "" fboundp temp-minibuffer-message t nil (7)] 3 (#$ . 18498)])
#@54 Internal variable used by `PC-lisp-complete-symbol'.
(defvar PC-lisp-complete-end nil (#$ . 18923))
#@374 Perform completion on Lisp symbol preceding point.
That symbol is compared against the symbols that exist
and any additional characters determined by what is there
are inserted.
If the symbol starts just after an open-parenthesis,
only symbols with function definitions are considered.
Otherwise, all symbols with function definitions, values
or properties are considered.
(defalias 'PC-lisp-complete-symbol #[nil "\212\306 p\307\216\310\n!\210\311\312!\210`,\212\306 p\313\216\310\n!\210\314\315!\210gz\316U\2030\315u\210\202#`,Sf\317=\203E\320\202F\321\322\323\232\203]\324\325\322$\202x\203k\325\223\210\202q\326\322\"\324\325\322$-\207" [#1=#:buffer #2=#:table lisp-mode-syntax-table end #3=#:buffer #4=#:table syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table skip-syntax-forward "_w" ((byte-code "rq\210\302	!\210)\302\207" [#3# #4# set-syntax-table] 2)) backward-sexp 1 39 40 fboundp #[(sym) "\301!\206\302!\206\303!\207" [sym boundp fboundp symbol-plist] 2] t PC-lisp-complete-symbol PC-do-completion nil copy-marker beg obarray minibuffer-completion-table minibuffer-completion-predicate PC-not-minibuffer last-command PC-lisp-complete-end] 5 (#$ . 19030) nil])
#@100 Perform completion on file names preceding point.
 Environment vars are converted to their values.
(defalias 'PC-complete-as-file-name #[nil "`\305\306e\307#\203`\310\\\202e\311\312\307b\210\313\312	#-\207" [end beg minibuffer-completion-table minibuffer-completion-predicate PC-not-minibuffer re-search-backward "[^\\][ 	\n\"`'][^ 	\n\"`']" t 2 PC-read-file-name-internal nil PC-do-completion] 4 (#$ . 20310) nil])
(defalias 'PC-look-for-include-file #[nil "\306\307\310 \"\205\310 \311\224\311\225O\310 \312\224H\313\211\314p!\210\315\232\203\200r\316 @q\210\212\317 \210\320\321!\203B\311\224\311\225{\311\224Sf\202\320\322!\204T\320\323!\204T\320\324!\203{\311\224\311\225{\325\f\306\326\"\203m\312\327O\202\306\330\"\204\331P\202\332\333!\210*\306\334\"\204\213\335P\n\325=\203\305	\206\227\336 \211\203\256\337\340	@!P!\204\256	A\211\204\234	\203\274\340	@!P\202\301\332\341\"\210)\202\346r\316 @q\210
)(\337(P!\203\340(P\202\345\332\342\"\210)\343!\211\203\364q\210\202\344!q\210\345 \210\346\347\"\210,\347\207" [new-buf path punc name load-path default-directory string-match "[\"<]\\([^\"<>]*\\)[\">]?$" buffer-file-name 1 0 nil kill-buffer "" buffer-list beginning-of-line looking-at "[ 	]*#[ 	]*include[ 	]+[<\"]\\(.+\\)[>\"][ 	]*[\n/]" "[ 	]*([ 	]*load[ 	]+\"\\([^\"]+\\)\"" "[ 	]*([ 	]*load-library[ 	]+\"\\([^\"]+\\)\"" "[ 	]*([ 	]*require[ 	]+'\\([^	 )]+\\)[	 )]" 60 "\\.elc$" -1 "\\.el$" ".el" error "Not on an #include line" "\\.[[:alnum:]]+$" ".h" PC-include-file-path file-exists-p file-name-as-directory "No such include file: <%s>" "No such include file: `%s'" get-file-buffer create-file-buffer erase-buffer insert-file-contents t dir] 5])
(defalias 'PC-include-file-path #[nil "\206/\304\305!\306\211\211\204\307\310!\210\311\312\"\211\203-	T\306O\nB\313	O\202\n+\207" [PC-include-file-path pos path env getenv "INCPATH" nil error "No include file path specified" string-match ":[^:]+$" 0] 4])
#@207 Return all completions for FILE in any directory on SEARCH-PATH.
If optional third argument FULL is non-nil, returned pathnames should be
absolute rather than relative to some directory on the SEARCH-PATH.
(defalias 'PC-include-file-all-completions #[(file search-path &optional full) "\306\307\"\310	!\203\311	!\312\313	!\314	!\"\207\314	!\313	!\315\211\203-\306\316\"\315\203W@\203=
\202>\f\317
!\203P\306\320\312@\"\"\nBA*\202-\321\322\323\n\"\324\"\315\211\203\202@@\232\204y@BA\211\204g-\207" [search-path file file-lists ndfile subdir dir mapcar #[(dir) "\203\302!\207	\207" [dir default-directory file-name-as-directory] 2] file-name-absolute-p expand-file-name file-name-all-completions file-name-nondirectory file-name-directory nil #[(dir) "	P\207" [dir subdir] 2] file-directory-p #[(file) "	P\207" [subdir file] 2] sort apply nconc #[(x y) "	\231?\207" [x y] 2] full compressed sorted] 6 (#$ . 22329)])
#@81 Extend `read-file-name-internal' to handle include files.
This is only used by 
(defalias 'PC-read-file-name-internal #[(string pred action) "\306\307\"\203L\310\311\"\312\224\313O\314\315\316	\317 \"\"\211\204#\313\202J\f\320=\2031\321\n\313#\202J\f\313=\203?\322\n\313#\202J\f\323=\205J\324\n\313#+\207\325
\f#\207" [string name str2 completion-table action pred string-match "<\\([^\"<>]*\\)>?\\'" match-string 1 0 nil mapcar #[(x) "\301\302\303\"\203\f\304\202
\305\"\207" [x format string-match "/\\'" "<%s" "<%s>"] 4] PC-include-file-all-completions PC-include-file-path lambda test-completion PC-try-completion t all-completions read-file-name-internal] 6 (#$ . 23308)])
(provide 'complete)
F1l3 Manager
