1 ;;; em-cmpl.el --- completion using the TAB key
3 ;; Copyright (C) 1999, 2000 Free Software Foundation
5 ;; Author: John Wiegley <johnw@gnu.org>
7 ;; This file is part of GNU Emacs.
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
10 ;; it under the terms of the GNU General Public License as published by
11 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; GNU Emacs is distributed in the hope that it will be useful,
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 ;; GNU General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22 ;; Boston, MA 02111-1307, USA.
26 (eval-when-compile (require 'esh-maint
))
28 (defgroup eshell-cmpl nil
29 "This module provides a programmable completion function bound to
30 the TAB key, which allows for completing command names, file names,
31 variable names, arguments, etc."
32 :tag
"Argument completion"
33 :group
'eshell-module
)
37 ;; Eshell, by using the pcomplete package, provides a full
38 ;; programmable completion facility that is comparable to shells like
41 ;; Completions are context-sensitive, which means that pressing <TAB>
42 ;; after the command 'rmdir' will result in a list of directories,
43 ;; while doing so after 'rm' will result in a list of all file
46 ;; Many builtin completion rules are provided, for commands such as
47 ;; `cvs', or RedHat's `rpm' utility. Adding new completion rules is
48 ;; no more difficult than writing a plain Lisp functions, and they can
49 ;; be debugged, profiled, and compiled using exactly the same
50 ;; facilities (since in fact, they *are* just Lisp functions). See
51 ;; the definition of the function `pcomplete/make' for an example of
52 ;; how to write a completion function.
54 ;; The completion facility is very easy to use. Just press TAB. If
55 ;; there are a large number of possible completions, a buffer will
56 ;; appear showing a list of them. Completions may be selected from
57 ;; that buffer using the mouse. If no completion is selected, and the
58 ;; user starts doing something else, the display buffer will
59 ;; automatically disappear.
61 ;; If the list of possible completions is very small, Eshell will
62 ;; "cycle" through them, selecting a different entry each time <TAB>
63 ;; is pressed. <S-TAB> may be used to cycle in the opposite
66 ;; Glob patterns can also be cycled. For example, entering 'echo
67 ;; x*<tab>' will cycle through all the filenames beginning with 'x'.
68 ;; This is done because the glob list is treated as though it were a
69 ;; list of possible completions. Pressing <C-c SPC> will insert all
70 ;; of the matching glob patterns at point.
72 ;; If a Lisp form is being entered, <TAB> will complete the Lisp
73 ;; symbol name, in exactly the same way that <M-TAB> does in Emacs
76 ;; The list of possible completions can be viewed at any point by
79 ;; Finally, context-related help can be accessed by pressing <C-c i>.
80 ;; This only works well if the completion function has provided Eshell
81 ;; with sufficient pointers to locate the relevant help text.
85 (defcustom eshell-cmpl-load-hook
'(eshell-cmpl-initialize)
86 "*A list of functions to run when `eshell-cmpl' is loaded."
90 (defcustom eshell-show-lisp-completions nil
91 "*If non-nil, include Lisp functions in the command completion list.
92 If this variable is nil, Lisp completion can still be done in command
93 position by using M-TAB instead of TAB."
97 (defcustom eshell-show-lisp-alternatives t
98 "*If non-nil, and no other completions found, show Lisp functions.
99 Setting this variable means nothing if `eshell-show-lisp-completions'
104 (defcustom eshell-no-completion-during-jobs t
105 "*If non-nil, don't allow completion while a process is running."
109 (defcustom eshell-command-completions-alist
110 '(("acroread" .
"\\.pdf\\'")
111 ("xpdf" .
"\\.pdf\\'")
112 ("ar" .
"\\.[ao]\\'")
113 ("gcc" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
114 ("g++" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
115 ("cc" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
116 ("CC" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
117 ("acc" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
118 ("bcc" .
"\\.[Cc]\\([Cc]\\|[Pp][Pp]\\)?\\'")
119 ("readelf" .
"\\(\\`[^.]*\\|\\.\\([ao]\\|so\\)\\)\\'")
120 ("objdump" .
"\\(\\`[^.]*\\|\\.\\([ao]\\|so\\)\\)\\'")
121 ("nm" .
"\\(\\`[^.]*\\|\\.\\([ao]\\|so\\)\\)\\'")
122 ("gdb" .
"\\`\\([^.]*\\|a\\.out\\)\\'")
123 ("dbx" .
"\\`\\([^.]*\\|a\\.out\\)\\'")
124 ("sdb" .
"\\`\\([^.]*\\|a\\.out\\)\\'")
125 ("adb" .
"\\`\\([^.]*\\|a\\.out\\)\\'"))
126 "*An alist that defines simple argument type correlations.
127 This is provided for common commands, as a simplistic alternative
128 to writing a completion function."
129 :type
'(repeat (cons string regexp
))
132 (defcustom eshell-cmpl-file-ignore
"~\\'"
133 (documentation-property 'pcomplete-file-ignore
134 'variable-documentation
)
135 :type
(get 'pcomplete-file-ignore
'custom-type
)
138 (defcustom eshell-cmpl-dir-ignore
139 (format "\\`\\(\\.\\.?\\|CVS\\)%c\\'" directory-sep-char
)
140 (documentation-property 'pcomplete-dir-ignore
141 'variable-documentation
)
142 :type
(get 'pcomplete-dir-ignore
'custom-type
)
145 (defcustom eshell-cmpl-ignore-case
(eshell-under-windows-p)
146 (documentation-property 'pcomplete-ignore-case
147 'variable-documentation
)
148 :type
(get 'pcomplete-ignore-case
'custom-type
)
151 (defcustom eshell-cmpl-autolist nil
152 (documentation-property 'pcomplete-autolist
153 'variable-documentation
)
154 :type
(get 'pcomplete-autolist
'custom-type
)
157 (defcustom eshell-cmpl-suffix-list
(list directory-sep-char ?
:)
158 (documentation-property 'pcomplete-suffix-list
159 'variable-documentation
)
160 :type
(get 'pcomplete-suffix-list
'custom-type
)
163 (defcustom eshell-cmpl-recexact nil
164 (documentation-property 'pcomplete-recexact
165 'variable-documentation
)
166 :type
(get 'pcomplete-recexact
'custom-type
)
169 (defcustom eshell-cmpl-man-function
'man
170 (documentation-property 'pcomplete-man-function
171 'variable-documentation
)
172 :type
(get 'pcomplete-man-function
'custom-type
)
175 (defcustom eshell-cmpl-compare-entry-function
'file-newer-than-file-p
176 (documentation-property 'pcomplete-compare-entry-function
177 'variable-documentation
)
178 :type
(get 'pcomplete-compare-entry-function
'custom-type
)
181 (defcustom eshell-cmpl-expand-before-complete nil
182 (documentation-property 'pcomplete-expand-before-complete
183 'variable-documentation
)
184 :type
(get 'pcomplete-expand-before-complete
'custom-type
)
187 (defcustom eshell-cmpl-cycle-completions t
188 (documentation-property 'pcomplete-cycle-completions
189 'variable-documentation
)
190 :type
(get 'pcomplete-cycle-completions
'custom-type
)
193 (defcustom eshell-cmpl-cycle-cutoff-length
5
194 (documentation-property 'pcomplete-cycle-cutoff-length
195 'variable-documentation
)
196 :type
(get 'pcomplete-cycle-cutoff-length
'custom-type
)
199 (defcustom eshell-cmpl-restore-window-delay
1
200 (documentation-property 'pcomplete-restore-window-delay
201 'variable-documentation
)
202 :type
(get 'pcomplete-restore-window-delay
'custom-type
)
205 (defcustom eshell-command-completion-function
208 (pcomplete-here (eshell-complete-commands-list))))
209 (documentation-property 'pcomplete-command-completion-function
210 'variable-documentation
)
211 :type
(get 'pcomplete-command-completion-function
'custom-type
)
214 (defcustom eshell-cmpl-command-name-function
215 'eshell-completion-command-name
216 (documentation-property 'pcomplete-command-name-function
217 'variable-documentation
)
218 :type
(get 'pcomplete-command-name-function
'custom-type
)
221 (defcustom eshell-default-completion-function
224 (while (pcomplete-here
225 (pcomplete-dirs-or-entries
226 (cdr (assoc (funcall eshell-cmpl-command-name-function
)
227 eshell-command-completions-alist
)))))))
228 (documentation-property 'pcomplete-default-completion-function
229 'variable-documentation
)
230 :type
(get 'pcomplete-default-completion-function
'custom-type
)
233 (defcustom eshell-cmpl-use-paring t
234 (documentation-property 'pcomplete-use-paring
'variable-documentation
)
235 :type
(get 'pcomplete-use-paring
'custom-type
)
240 (defun eshell-cmpl-initialize ()
241 "Initialize the completions module."
242 (unless (fboundp 'pcomplete
)
243 (load "pcmpl-auto" t t
))
244 (set (make-local-variable 'pcomplete-command-completion-function
)
245 eshell-command-completion-function
)
246 (set (make-local-variable 'pcomplete-command-name-function
)
247 eshell-cmpl-command-name-function
)
248 (set (make-local-variable 'pcomplete-default-completion-function
)
249 eshell-default-completion-function
)
250 (set (make-local-variable 'pcomplete-parse-arguments-function
)
251 'eshell-complete-parse-arguments
)
252 (set (make-local-variable 'pcomplete-file-ignore
)
253 eshell-cmpl-file-ignore
)
254 (set (make-local-variable 'pcomplete-dir-ignore
)
255 eshell-cmpl-dir-ignore
)
256 (set (make-local-variable 'pcomplete-ignore-case
)
257 eshell-cmpl-ignore-case
)
258 (set (make-local-variable 'pcomplete-autolist
)
259 eshell-cmpl-autolist
)
260 (set (make-local-variable 'pcomplete-suffix-list
)
261 eshell-cmpl-suffix-list
)
262 (set (make-local-variable 'pcomplete-recexact
)
263 eshell-cmpl-recexact
)
264 (set (make-local-variable 'pcomplete-man-function
)
265 eshell-cmpl-man-function
)
266 (set (make-local-variable 'pcomplete-compare-entry-function
)
267 eshell-cmpl-compare-entry-function
)
268 (set (make-local-variable 'pcomplete-expand-before-complete
)
269 eshell-cmpl-expand-before-complete
)
270 (set (make-local-variable 'pcomplete-cycle-completions
)
271 eshell-cmpl-cycle-completions
)
272 (set (make-local-variable 'pcomplete-cycle-cutoff-length
)
273 eshell-cmpl-cycle-cutoff-length
)
274 (set (make-local-variable 'pcomplete-restore-window-delay
)
275 eshell-cmpl-restore-window-delay
)
276 (set (make-local-variable 'pcomplete-use-paring
)
277 eshell-cmpl-use-paring
)
278 ;; `pcomplete-arg-quote-list' should only be set after all the
279 ;; load-hooks for any other extension modules have been run, which
280 ;; is true at the time `eshell-mode-hook' is run
281 (add-hook 'eshell-mode-hook
284 (set (make-local-variable 'pcomplete-arg-quote-list
)
285 eshell-special-chars-outside-quoting
))) nil t
)
286 (add-hook 'pcomplete-quote-arg-hook
'eshell-quote-backslash nil t
)
287 (define-key eshell-mode-map
[(meta tab
)] 'lisp-complete-symbol
)
288 (define-key eshell-mode-map
[(meta control ?i
)] 'lisp-complete-symbol
)
289 (define-key eshell-command-map
[(meta ?h
)] 'eshell-completion-help
)
290 (define-key eshell-command-map
[tab] 'pcomplete-expand-and-complete)
291 (define-key eshell-command-map [(control ?i)]
292 'pcomplete-expand-and-complete)
293 (define-key eshell-command-map [space] 'pcomplete-expand)
294 (define-key eshell-command-map [? ] 'pcomplete-expand)
295 (define-key eshell-mode-map [tab] 'pcomplete
)
296 (define-key eshell-mode-map
[(control ?i
)] 'pcomplete
)
297 ;; jww (1999-10-19): Will this work on anything but X?
298 (if (eshell-under-xemacs-p)
299 (define-key eshell-mode-map
[iso-left-tab
] 'pcomplete-reverse
)
300 (define-key eshell-mode-map
[(shift iso-lefttab
)] 'pcomplete-reverse
)
301 (define-key eshell-mode-map
[(shift control ?i
)] 'pcomplete-reverse
))
302 (define-key eshell-mode-map
[(meta ??
)] 'pcomplete-list
))
304 (defun eshell-completion-command-name ()
305 "Return the command name, possibly sans globbing."
306 (let ((cmd (file-name-nondirectory (pcomplete-arg 'first
))))
307 (setq cmd
(if (and (> (length cmd
) 0)
308 (eq (aref cmd
0) eshell-explicit-command-char
))
311 (if (eshell-under-windows-p)
312 (file-name-sans-extension cmd
)
315 (defun eshell-completion-help ()
317 (if (= (point) eshell-last-output-end
)
318 (describe-prefix-bindings)
319 (call-interactively 'pcomplete-help
)))
321 (defun eshell-complete-parse-arguments ()
322 "Parse the command line arguments for `pcomplete-argument'."
323 (when (and eshell-no-completion-during-jobs
324 (eshell-interactive-process))
325 (insert-and-inherit "\t")
326 (throw 'pcompleted t
))
327 (let ((end (point-marker))
328 (begin (save-excursion (eshell-bol) (point)))
331 (when (memq this-command
'(pcomplete-expand
332 pcomplete-expand-and-complete
))
333 (run-hook-with-args 'eshell-expand-input-functions begin end
)
336 (setq end
(point-marker)))
338 (catch 'eshell-incomplete
340 (setq args
(eshell-parse-arguments begin end
)))))
341 (cond ((memq (car delim
) '(?\
{ ?\
<))
342 (setq begin
(1+ (cadr delim
))
343 args
(eshell-parse-arguments begin end
)))
344 ((eq (car delim
) ?\
()
345 (lisp-complete-symbol)
346 (throw 'pcompleted t
))
348 (insert-and-inherit "\t")
349 (throw 'pcompleted t
))))
350 (when (get-text-property (1- end
) 'comment
)
351 (insert-and-inherit "\t")
352 (throw 'pcompleted t
))
355 (if (get-text-property pos
'arg-begin
)
356 (nconc posns
(list pos
)))
357 (setq pos
(1+ pos
))))
358 (setq posns
(cdr posns
))
359 (assert (= (length args
) (length posns
)))
364 (if (and (consp (car a
))
365 (eq (caar a
) 'eshell-operator
))
367 (setq a
(cdr a
) i
(1+ i
)))
369 (setq args
(nthcdr (1+ l
) args
)
370 posns
(nthcdr (1+ l
) posns
))))
371 (assert (= (length args
) (length posns
)))
372 (when (and args
(eq (char-syntax (char-before end
)) ?
))
373 (nconc args
(list ""))
374 (nconc posns
(list (point))))
382 (list 'eshell-commands arg
) t
)))
383 (assert (eq (car result
) 'quote
))
387 (setq val
(number-to-string val
)))
392 (defun eshell-complete-commands-list ()
393 "Generate list of applicable, visible commands."
394 (let ((filename (pcomplete-arg)) glob-name
)
395 (if (file-name-directory filename
)
396 (pcomplete-executables)
397 (if (and (> (length filename
) 0)
398 (eq (aref filename
0) eshell-explicit-command-char
))
399 (setq filename
(substring filename
1)
400 pcomplete-stub filename
402 (let* ((paths (split-string (getenv "PATH") path-separator
))
403 (cwd (file-name-as-directory
404 (expand-file-name default-directory
)))
405 (path "") (comps-in-path ())
406 (file "") (filepath "") (completions ()))
407 ;; Go thru each path in the search path, finding completions.
409 (setq path
(file-name-as-directory
410 (expand-file-name (or (car paths
) ".")))
412 (and (file-accessible-directory-p path
)
413 (file-name-all-completions filename path
)))
414 ;; Go thru each completion found, to see whether it should
417 (setq file
(car comps-in-path
)
418 filepath
(concat path file
))
419 (if (and (not (member file completions
)) ;
420 (or (string-equal path cwd
)
421 (not (file-directory-p filepath
)))
422 (file-executable-p filepath
))
423 (setq completions
(cons file completions
)))
424 (setq comps-in-path
(cdr comps-in-path
)))
425 (setq paths
(cdr paths
)))
426 ;; Add aliases which are currently visible, and Lisp functions.
427 (pcomplete-uniqify-list
431 (append (and (eshell-using-module 'eshell-alias
)
432 (funcall (symbol-function 'eshell-alias-completions
)
439 (all-completions (concat "eshell/" filename
)
441 nil
'(eshell-find-alias-function))
443 (append (and (or eshell-show-lisp-completions
444 (and eshell-show-lisp-alternatives
446 (all-completions filename obarray
'functionp
))
451 ;;; em-cmpl.el ends here