29876
|
1 ;;; pcomplete --- programmable completion
|
|
2
|
|
3 ;; Copyright (C) 1999, 2000 Free Sofware Foundation
|
|
4
|
|
5 ;; Author: John Wiegley <johnw@gnu.org>
|
|
6 ;; Keywords: processes
|
|
7
|
|
8 ;; This file is part of GNU Emacs.
|
|
9
|
|
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
11 ;; it under the terms of the GNU General Public License as published by
|
|
12 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
13 ;; any later version.
|
|
14
|
|
15 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
18 ;; GNU General Public License for more details.
|
|
19
|
|
20 ;; You should have received a copy of the GNU General Public License
|
|
21 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
23 ;; Boston, MA 02111-1307, USA.
|
|
24
|
|
25 ;;; Commentary:
|
|
26
|
|
27 ;; This module provides a programmable completion facility using
|
|
28 ;; "completion functions". Each completion function is responsible
|
|
29 ;; for producing a list of possible completions relevant to the current
|
|
30 ;; argument position.
|
|
31 ;;
|
|
32 ;; To use pcomplete with shell-mode, for example, you will need the
|
|
33 ;; following in your .emacs file:
|
|
34 ;;
|
|
35 ;; (load "pcmpl-auto")
|
|
36 ;; (add-hook 'shell-mode-hook 'pcomplete-shell-setup)
|
|
37 ;;
|
|
38 ;; Most of the code below simply provides support mechanisms for
|
|
39 ;; writing completion functions. Completion functions themselves are
|
|
40 ;; very easy to write. They have few requirements beyond those of
|
|
41 ;; regular Lisp functions.
|
|
42 ;;
|
|
43 ;; Consider the following example, which will complete against
|
|
44 ;; filenames for the first two arguments, and directories for all
|
|
45 ;; remaining arguments:
|
|
46 ;;
|
|
47 ;; (defun pcomplete/my-command ()
|
|
48 ;; (pcomplete-here (pcomplete-entries))
|
|
49 ;; (pcomplete-here (pcomplete-entries))
|
|
50 ;; (while (pcomplete-here (pcomplete-dirs))))
|
|
51 ;;
|
|
52 ;; Here are the requirements for completion functions:
|
|
53 ;;
|
|
54 ;; @ They must be called "pcomplete/MAJOR-MODE/NAME", or
|
|
55 ;; "pcomplete/NAME". This is how they are looked up, using the NAME
|
|
56 ;; specified in the command argument (the argument in first
|
|
57 ;; position).
|
|
58 ;;
|
|
59 ;; @ They must be callable with no arguments.
|
|
60 ;;
|
|
61 ;; @ Their return value is ignored. If they actually return normally,
|
|
62 ;; it means no completions were available.
|
|
63 ;;
|
|
64 ;; @ In order to provide completions, they must throw the tag
|
|
65 ;; `pcomplete-completions'. The value must be the list of possible
|
|
66 ;; completions for the final argument.
|
|
67 ;;
|
|
68 ;; @ To simplify completion function logic, the tag `pcompleted' may
|
|
69 ;; be thrown with a value of nil in order to abort the function. It
|
|
70 ;; means that there were no completions available.
|
|
71 ;;
|
|
72 ;; When a completion function is called, the variable `pcomplete-args'
|
|
73 ;; is in scope, and contains all of the arguments specified on the
|
|
74 ;; command line. The variable `pcomplete-last' is the index of the
|
|
75 ;; last argument in that list.
|
|
76 ;;
|
|
77 ;; The variable `pcomplete-index' is used by the completion code to
|
|
78 ;; know which argument the completion function is currently examining.
|
|
79 ;; It always begins at 1, meaning the first argument after the command
|
|
80 ;; name.
|
|
81 ;;
|
|
82 ;; To facilitate writing completion logic, a special macro,
|
|
83 ;; `pcomplete-here', has been provided which does several things:
|
|
84 ;;
|
|
85 ;; 1. It will throw `pcompleted' (with a value of nil) whenever
|
|
86 ;; `pcomplete-index' exceeds `pcomplete-last'.
|
|
87 ;;
|
|
88 ;; 2. It will increment `pcomplete-index' if the final argument has
|
|
89 ;; not been reached yet.
|
|
90 ;;
|
|
91 ;; 3. It will evaluate the form passed to it, and throw the result
|
|
92 ;; using the `pcomplete-completions' tag, if it is called when
|
|
93 ;; `pcomplete-index' is pointing to the final argument.
|
|
94 ;;
|
|
95 ;; Sometimes a completion function will want to vary the possible
|
|
96 ;; completions for an argument based on the previous one. To
|
|
97 ;; facilitate tests like this, the function `pcomplete-test' and
|
|
98 ;; `pcomplete-match' are provided. Called with one argument, they
|
|
99 ;; test the value of the previous command argument. Otherwise, a
|
|
100 ;; relative index may be given as an optional second argument, where 0
|
|
101 ;; refers to the current argument, 1 the previous, 2 the one before
|
|
102 ;; that, etc. The symbols `first' and `last' specify absolute
|
|
103 ;; offsets.
|
|
104 ;;
|
|
105 ;; Here is an example which will only complete against directories for
|
|
106 ;; the second argument if the first argument is also a directory:
|
|
107 ;;
|
|
108 ;; (defun pcomplete/example ()
|
|
109 ;; (pcomplete-here (pcomplete-entries))
|
|
110 ;; (if (pcomplete-test 'file-directory-p)
|
|
111 ;; (pcomplete-here (pcomplete-dirs))
|
|
112 ;; (pcomplete-here (pcomplete-entries))))
|
|
113 ;;
|
|
114 ;; For generating completion lists based on directory contents, see
|
|
115 ;; the functions `pcomplete-entries', `pcomplete-dirs',
|
|
116 ;; `pcomplete-executables' and `pcomplete-all-entries'.
|
|
117 ;;
|
|
118 ;; Consult the documentation for `pcomplete-here' for information
|
|
119 ;; about its other arguments.
|
|
120
|
|
121 ;;; Code:
|
|
122
|
|
123 (provide 'pcomplete)
|
|
124
|
|
125 (defgroup pcomplete nil
|
|
126 "Programmable completion."
|
|
127 :group 'processes)
|
|
128
|
|
129 ;;; User Variables:
|
|
130
|
|
131 (defcustom pcomplete-file-ignore nil
|
|
132 "*A regexp of filenames to be disregarded during file completion."
|
|
133 :type 'regexp
|
|
134 :group 'pcomplete)
|
|
135
|
|
136 (defcustom pcomplete-dir-ignore nil
|
|
137 "*A regexp of names to be disregarded during directory completion."
|
|
138 :type 'regexp
|
|
139 :group 'pcomplete)
|
|
140
|
|
141 (defcustom pcomplete-ignore-case (memq system-type '(ms-dos windows-nt))
|
|
142 "*If non-nil, ignore case when doing filename completion."
|
|
143 :type 'boolean
|
|
144 :group 'pcomplete)
|
|
145
|
|
146 (defcustom pcomplete-autolist nil
|
|
147 "*If non-nil, automatically list possibilities on partial completion.
|
|
148 This mirrors the optional behavior of tcsh."
|
|
149 :type 'boolean
|
|
150 :group 'pcomplete)
|
|
151
|
|
152 (defcustom pcomplete-suffix-list (list directory-sep-char ?:)
|
|
153 "*A list of characters which constitute a proper suffix."
|
|
154 :type '(repeat character)
|
|
155 :group 'pcomplete)
|
|
156
|
|
157 (defcustom pcomplete-recexact nil
|
|
158 "*If non-nil, use shortest completion if characters cannot be added.
|
|
159 This mirrors the optional behavior of tcsh.
|
|
160
|
|
161 A non-nil value is useful if `pcomplete-autolist' is non-nil too."
|
|
162 :type 'boolean
|
|
163 :group 'pcomplete)
|
|
164
|
|
165 (defcustom pcomplete-arg-quote-list nil
|
|
166 "*List of characters to quote when completing an argument."
|
|
167 :type '(choice (repeat character)
|
|
168 (const :tag "Don't quote" nil))
|
|
169 :group 'pcomplete)
|
|
170
|
|
171 (defcustom pcomplete-quote-arg-hook nil
|
|
172 "*A hook which is run to quote a character within a filename.
|
|
173 Each function is passed both the filename to be quoted, and the index
|
|
174 to be considered. If the function wishes to provide an alternate
|
|
175 quoted form, it need only return the replacement string. If no
|
|
176 function provides a replacement, quoting shall proceed as normal,
|
|
177 using a backslash to quote any character which is a member of
|
|
178 `pcomplete-arg-quote-list'."
|
|
179 :type 'hook
|
|
180 :group 'pcomplete)
|
|
181
|
|
182 (defcustom pcomplete-man-function 'man
|
|
183 "*A function to that will be called to display a manual page.
|
|
184 It will be passed the name of the command to document."
|
|
185 :type 'function
|
|
186 :group 'pcomplete)
|
|
187
|
|
188 (defcustom pcomplete-compare-entry-function 'string-lessp
|
|
189 "*This function is used to order file entries for completion.
|
|
190 The behavior of most all shells is to sort alphabetically."
|
|
191 :type '(radio (function-item string-lessp)
|
|
192 (function-item file-newer-than-file-p)
|
|
193 (function :tag "Other"))
|
|
194 :group 'pcomplete)
|
|
195
|
|
196 (defcustom pcomplete-help nil
|
|
197 "*A string or function (or nil) used for context-sensitive help.
|
|
198 If a string, it should name an Info node that will be jumped to.
|
|
199 If non-nil, it must a sexp that will be evaluated, and whose
|
|
200 result will be shown in the minibuffer.
|
|
201 If nil, the function `pcomplete-man-function' will be called with the
|
|
202 current command argument."
|
|
203 :type '(choice string sexp (const :tag "Use man page" nil))
|
|
204 :group 'pcomplete)
|
|
205
|
|
206 (defcustom pcomplete-expand-before-complete nil
|
|
207 "*If non-nil, expand the current argument before completing it.
|
|
208 This means that typing something such as '$HOME/bi' followed by
|
|
209 \\[pcomplete-argument] will cause the variable reference to be
|
|
210 resolved first, and the resultant value that will be completed against
|
|
211 to be inserted in the buffer. Note that exactly what gets expanded
|
|
212 and how is entirely up to the behavior of the
|
|
213 `pcomplete-parse-arguments-function'."
|
|
214 :type 'boolean
|
|
215 :group 'pcomplete)
|
|
216
|
|
217 (defcustom pcomplete-parse-arguments-function
|
|
218 'pcomplete-parse-buffer-arguments
|
|
219 "*A function to call to parse the current line's arguments.
|
|
220 It should be called with no parameters, and with point at the position
|
|
221 of the argument that is to be completed.
|
|
222
|
|
223 It must either return nil, or a cons cell of the form:
|
|
224
|
|
225 ((ARG...) (BEG-POS...))
|
|
226
|
|
227 The two lists must be identical in length. The first gives the final
|
|
228 value of each command line argument (which need not match the textual
|
|
229 representation of that argument), and BEG-POS gives the beginning
|
|
230 position of each argument, as it is seen by the user. The establishes
|
|
231 a relationship between the fully resolved value of the argument, and
|
|
232 the textual representation of the argument."
|
|
233 :type 'function
|
|
234 :group 'pcomplete)
|
|
235
|
|
236 (defcustom pcomplete-cycle-completions t
|
|
237 "*If non-nil, hitting the TAB key cycles through the completion list.
|
|
238 Typical Emacs behavior is to complete as much as possible, then pause
|
|
239 waiting for further input. Then if TAB is hit again, show a list of
|
|
240 possible completions. When `pcomplete-cycle-completions' is non-nil,
|
|
241 it acts more like zsh or 4nt, showing the first maximal match first,
|
|
242 followed by any further matches on each subsequent pressing of the TAB
|
|
243 key. \\[pcomplete-list] is the key to press if the user wants to see
|
|
244 the list of possible completions."
|
|
245 :type 'boolean
|
|
246 :group 'pcomplete)
|
|
247
|
|
248 (defcustom pcomplete-cycle-cutoff-length 5
|
|
249 "*If the number of completions is greater than this, don't cycle.
|
|
250 This variable is a compromise between the traditional Emacs style of
|
|
251 completion, and the \"cycling\" style. Basically, if there are more
|
|
252 than this number of completions possible, don't automatically pick the
|
|
253 first one and then expect the user to press TAB to cycle through them.
|
|
254 Typically, when there are a large number of completion possibilities,
|
|
255 the user wants to see them in a list buffer so that they can know what
|
|
256 options are available. But if the list is small, it means the user
|
|
257 has already entered enough input to disambiguate most of the
|
|
258 possibilities, and therefore they are probably most interested in
|
|
259 cycling through the candidates. Set this value to nil if you want
|
|
260 cycling to always be enabled."
|
|
261 :type '(choice integer (const :tag "Always cycle" nil))
|
|
262 :group 'pcomplete)
|
|
263
|
|
264 (defcustom pcomplete-restore-window-delay 1
|
|
265 "*The number of seconds to wait before restoring completion windows.
|
|
266 Once the completion window has been displayed, if the user then goes
|
|
267 on to type something else, that completion window will be removed from
|
|
268 the display (actually, the original window configuration before it was
|
|
269 displayed will be restored), after this many seconds of idle time. If
|
|
270 set to nil, completion windows will be left on second until the user
|
|
271 removes them manually. If set to 0, they will disappear immediately
|
|
272 after the user enters a key other than TAB."
|
|
273 :type '(choice integer (const :tag "Never restore" nil))
|
|
274 :group 'pcomplete)
|
|
275
|
|
276 (defcustom pcomplete-try-first-hook nil
|
|
277 "*A list of functions which are called before completing an argument.
|
|
278 This can be used, for example, for completing things which might apply
|
|
279 to all arguments, such as variable names after a $."
|
|
280 :type 'hook
|
|
281 :group 'pcomplete)
|
|
282
|
|
283 (defcustom pcomplete-command-completion-function
|
|
284 (function
|
|
285 (lambda ()
|
|
286 (pcomplete-here (pcomplete-executables))))
|
|
287 "*Function called for completing the initial command argument."
|
|
288 :type 'function
|
|
289 :group 'pcomplete)
|
|
290
|
|
291 (defcustom pcomplete-command-name-function 'pcomplete-command-name
|
|
292 "*Function called for determining the current command name."
|
|
293 :type 'function
|
|
294 :group 'pcomplete)
|
|
295
|
|
296 (defcustom pcomplete-default-completion-function
|
|
297 (function
|
|
298 (lambda ()
|
|
299 (while (pcomplete-here (pcomplete-entries)))))
|
|
300 "*Function called when no completion rule can be found.
|
|
301 This function is used to generate completions for every argument."
|
|
302 :type 'function
|
|
303 :group 'pcomplete)
|
|
304
|
31241
|
305 (defcustom pcomplete-use-paring t
|
|
306 "*If t, pare alternatives that have already been used.
|
|
307 If nil, you will always see the completion set of possible options, no
|
|
308 matter which of those options have already been used in previous
|
|
309 command arguments."
|
|
310 :type 'boolean
|
|
311 :group 'pcomplete)
|
|
312
|
29876
|
313 ;;; Internal Variables:
|
|
314
|
|
315 ;; for cycling completion support
|
|
316 (defvar pcomplete-current-completions nil)
|
|
317 (defvar pcomplete-last-completion-length)
|
|
318 (defvar pcomplete-last-completion-stub)
|
|
319 (defvar pcomplete-last-completion-raw)
|
|
320 (defvar pcomplete-last-window-config nil)
|
|
321 (defvar pcomplete-window-restore-timer nil)
|
|
322
|
|
323 (make-variable-buffer-local 'pcomplete-current-completions)
|
|
324 (make-variable-buffer-local 'pcomplete-last-completion-length)
|
|
325 (make-variable-buffer-local 'pcomplete-last-completion-stub)
|
|
326 (make-variable-buffer-local 'pcomplete-last-completion-raw)
|
|
327 (make-variable-buffer-local 'pcomplete-last-window-config)
|
|
328 (make-variable-buffer-local 'pcomplete-window-restore-timer)
|
|
329
|
|
330 ;; used for altering pcomplete's behavior. These global variables
|
|
331 ;; should always be nil.
|
|
332 (defvar pcomplete-show-help nil)
|
|
333 (defvar pcomplete-show-list nil)
|
|
334 (defvar pcomplete-expand-only-p nil)
|
|
335
|
|
336 ;;; User Functions:
|
|
337
|
|
338 ;;;###autoload
|
|
339 (defun pcomplete ()
|
|
340 "Support extensible programmable completion.
|
|
341 To use this function, just bind the TAB key to it, or add it to your
|
|
342 completion functions list (it should occur fairly early in the list)."
|
|
343 (interactive)
|
|
344 (if (and (interactive-p)
|
|
345 pcomplete-cycle-completions
|
|
346 pcomplete-current-completions
|
|
347 (memq last-command '(pcomplete
|
|
348 pcomplete-expand-and-complete
|
|
349 pcomplete-reverse)))
|
|
350 (progn
|
|
351 (delete-backward-char pcomplete-last-completion-length)
|
|
352 (if (eq this-command 'pcomplete-reverse)
|
|
353 (progn
|
|
354 (setq pcomplete-current-completions
|
|
355 (cons (car (last pcomplete-current-completions))
|
|
356 pcomplete-current-completions))
|
|
357 (setcdr (last pcomplete-current-completions 2) nil))
|
|
358 (nconc pcomplete-current-completions
|
|
359 (list (car pcomplete-current-completions)))
|
|
360 (setq pcomplete-current-completions
|
|
361 (cdr pcomplete-current-completions)))
|
|
362 (pcomplete-insert-entry pcomplete-last-completion-stub
|
|
363 (car pcomplete-current-completions)
|
|
364 nil pcomplete-last-completion-raw))
|
|
365 (setq pcomplete-current-completions nil
|
|
366 pcomplete-last-completion-raw nil)
|
|
367 (catch 'pcompleted
|
|
368 (let* ((pcomplete-stub)
|
|
369 pcomplete-seen pcomplete-norm-func
|
|
370 pcomplete-args pcomplete-last pcomplete-index
|
|
371 (pcomplete-autolist pcomplete-autolist)
|
|
372 (pcomplete-suffix-list pcomplete-suffix-list)
|
|
373 (completions (pcomplete-completions))
|
|
374 (result (pcomplete-do-complete pcomplete-stub completions)))
|
|
375 (and result
|
|
376 (not (eq (car result) 'listed))
|
|
377 (cdr result)
|
|
378 (pcomplete-insert-entry pcomplete-stub (cdr result)
|
|
379 (memq (car result)
|
|
380 '(sole shortest))
|
|
381 pcomplete-last-completion-raw))))))
|
|
382
|
|
383 ;;;###autoload
|
|
384 (defun pcomplete-reverse ()
|
|
385 "If cycling completion is in use, cycle backwards."
|
|
386 (interactive)
|
|
387 (call-interactively 'pcomplete))
|
|
388
|
|
389 ;;;###autoload
|
|
390 (defun pcomplete-expand-and-complete ()
|
|
391 "Expand the textual value of the current argument.
|
|
392 This will modify the current buffer."
|
|
393 (interactive)
|
|
394 (let ((pcomplete-expand-before-complete t))
|
|
395 (pcomplete)))
|
|
396
|
|
397 ;;;###autoload
|
|
398 (defun pcomplete-continue ()
|
|
399 "Complete without reference to any cycling completions."
|
|
400 (interactive)
|
|
401 (setq pcomplete-current-completions nil
|
|
402 pcomplete-last-completion-raw nil)
|
|
403 (call-interactively 'pcomplete))
|
|
404
|
|
405 ;;;###autoload
|
|
406 (defun pcomplete-expand ()
|
|
407 "Expand the textual value of the current argument.
|
|
408 This will modify the current buffer."
|
|
409 (interactive)
|
|
410 (let ((pcomplete-expand-before-complete t)
|
|
411 (pcomplete-expand-only-p t))
|
|
412 (pcomplete)
|
|
413 (when (and pcomplete-current-completions
|
|
414 (> (length pcomplete-current-completions) 0))
|
|
415 (delete-backward-char pcomplete-last-completion-length)
|
|
416 (while pcomplete-current-completions
|
|
417 (unless (pcomplete-insert-entry
|
|
418 "" (car pcomplete-current-completions) t
|
|
419 pcomplete-last-completion-raw)
|
|
420 (insert-and-inherit " "))
|
|
421 (setq pcomplete-current-completions
|
|
422 (cdr pcomplete-current-completions))))))
|
|
423
|
|
424 ;;;###autoload
|
|
425 (defun pcomplete-help ()
|
|
426 "Display any help information relative to the current argument."
|
|
427 (interactive)
|
|
428 (let ((pcomplete-show-help t))
|
|
429 (pcomplete)))
|
|
430
|
|
431 ;;;###autoload
|
|
432 (defun pcomplete-list ()
|
|
433 "Show the list of possible completions for the current argument."
|
|
434 (interactive)
|
|
435 (when (and pcomplete-cycle-completions
|
|
436 pcomplete-current-completions
|
|
437 (eq last-command 'pcomplete-argument))
|
|
438 (delete-backward-char pcomplete-last-completion-length)
|
|
439 (setq pcomplete-current-completions nil
|
|
440 pcomplete-last-completion-raw nil))
|
|
441 (let ((pcomplete-show-list t))
|
|
442 (pcomplete)))
|
|
443
|
|
444 ;;; Internal Functions:
|
|
445
|
|
446 ;; argument handling
|
|
447
|
|
448 ;; for the sake of the bye-compiler, when compiling other files that
|
|
449 ;; contain completion functions
|
|
450 (defvar pcomplete-args nil)
|
|
451 (defvar pcomplete-begins nil)
|
|
452 (defvar pcomplete-last nil)
|
|
453 (defvar pcomplete-index nil)
|
|
454 (defvar pcomplete-stub nil)
|
|
455 (defvar pcomplete-seen nil)
|
|
456 (defvar pcomplete-norm-func nil)
|
|
457
|
|
458 (defun pcomplete-arg (&optional index offset)
|
|
459 "Return the textual content of the INDEXth argument.
|
|
460 INDEX is based from the current processing position. If INDEX is
|
|
461 positive, values returned are closer to the command argument; if
|
|
462 negative, they are closer to the last argument. If the INDEX is
|
|
463 outside of the argument list, nil is returned. The default value for
|
|
464 INDEX is 0, meaning the current argument being examined.
|
|
465
|
|
466 The special indices `first' and `last' may be used to access those
|
|
467 parts of the list.
|
|
468
|
|
469 The OFFSET argument is added to/taken away from the index that will be
|
|
470 used. This is really only useful with `first' and `last', for
|
|
471 accessing absolute argument positions."
|
|
472 (setq index
|
|
473 (if (eq index 'first)
|
|
474 0
|
|
475 (if (eq index 'last)
|
|
476 pcomplete-last
|
|
477 (- pcomplete-index (or index 0)))))
|
|
478 (if offset
|
|
479 (setq index (+ index offset)))
|
|
480 (nth index pcomplete-args))
|
|
481
|
|
482 (defun pcomplete-begin (&optional index offset)
|
|
483 "Return the beginning position of the INDEXth argument.
|
|
484 See the documentation for `pcomplete-arg'."
|
|
485 (setq index
|
|
486 (if (eq index 'first)
|
|
487 0
|
|
488 (if (eq index 'last)
|
|
489 pcomplete-last
|
|
490 (- pcomplete-index (or index 0)))))
|
|
491 (if offset
|
|
492 (setq index (+ index offset)))
|
|
493 (nth index pcomplete-begins))
|
|
494
|
|
495 (defsubst pcomplete-actual-arg (&optional index offset)
|
|
496 "Return the actual text representation of the last argument.
|
|
497 This different from `pcomplete-arg', which returns the textual value
|
|
498 that the last argument evaluated to. This function returns what the
|
|
499 user actually typed in."
|
|
500 (buffer-substring (pcomplete-begin index offset) (point)))
|
|
501
|
|
502 (defsubst pcomplete-next-arg ()
|
|
503 "Move the various pointers to the next argument."
|
|
504 (setq pcomplete-index (1+ pcomplete-index)
|
|
505 pcomplete-stub (pcomplete-arg))
|
|
506 (if (> pcomplete-index pcomplete-last)
|
|
507 (progn
|
|
508 (message "No completions")
|
|
509 (throw 'pcompleted nil))))
|
|
510
|
|
511 (defun pcomplete-command-name ()
|
|
512 "Return the command name of the first argument."
|
|
513 (file-name-nondirectory (pcomplete-arg 'first)))
|
|
514
|
|
515 (defun pcomplete-match (regexp &optional index offset start)
|
|
516 "Like `string-match', but on the current completion argument."
|
|
517 (let ((arg (pcomplete-arg (or index 1) offset)))
|
|
518 (if arg
|
|
519 (string-match regexp arg start)
|
|
520 (throw 'pcompleted nil))))
|
|
521
|
|
522 (defun pcomplete-match-string (which &optional index offset)
|
|
523 "Like `string-match', but on the current completion argument."
|
|
524 (let ((arg (pcomplete-arg (or index 1) offset)))
|
|
525 (if arg
|
|
526 (match-string which arg)
|
|
527 (throw 'pcompleted nil))))
|
|
528
|
|
529 (defalias 'pcomplete-match-beginning 'match-beginning)
|
|
530 (defalias 'pcomplete-match-end 'match-end)
|
|
531
|
|
532 (defsubst pcomplete--test (pred arg)
|
|
533 "Perform a programmable completion predicate match."
|
|
534 (and pred
|
|
535 (cond ((eq pred t) t)
|
|
536 ((functionp pred)
|
|
537 (funcall pred arg))
|
|
538 ((stringp pred)
|
|
539 (string-match (concat "^" pred "$") arg)))
|
|
540 pred))
|
|
541
|
|
542 (defun pcomplete-test (predicates &optional index offset)
|
|
543 "Predicates to test the current programmable argument with."
|
|
544 (let ((arg (pcomplete-arg (or index 1) offset)))
|
|
545 (unless (null predicates)
|
|
546 (if (not (listp predicates))
|
|
547 (pcomplete--test predicates arg)
|
|
548 (let ((pred predicates)
|
|
549 found)
|
|
550 (while (and pred (not found))
|
|
551 (setq found (pcomplete--test (car pred) arg)
|
|
552 pred (cdr pred)))
|
|
553 found)))))
|
|
554
|
|
555 (defun pcomplete-parse-buffer-arguments ()
|
|
556 "Parse whitespace separated arguments in the current region."
|
|
557 (let ((begin (point-min))
|
|
558 (end (point-max))
|
|
559 begins args)
|
|
560 (save-excursion
|
|
561 (goto-char begin)
|
|
562 (while (< (point) end)
|
|
563 (skip-chars-forward " \t\n")
|
|
564 (setq begins (cons (point) begins))
|
|
565 (skip-chars-forward "^ \t\n")
|
|
566 (setq args (cons (buffer-substring-no-properties
|
|
567 (car begins) (point))
|
|
568 args)))
|
|
569 (cons (reverse args) (reverse begins)))))
|
|
570
|
|
571 ;;;###autoload
|
|
572 (defun pcomplete-comint-setup (completef-sym)
|
|
573 "Setup a comint buffer to use pcomplete.
|
|
574 COMPLETEF-SYM should be the symbol where the
|
|
575 dynamic-complete-functions are kept. For comint mode itself, this is
|
|
576 `comint-dynamic-complete-functions'."
|
|
577 (set (make-local-variable 'pcomplete-parse-arguments-function)
|
|
578 'pcomplete-parse-comint-arguments)
|
|
579 (make-local-variable completef-sym)
|
|
580 (let ((elem (memq 'comint-dynamic-complete-filename
|
|
581 (symbol-value completef-sym))))
|
|
582 (if elem
|
|
583 (setcar elem 'pcomplete)
|
|
584 (nconc (symbol-value completef-sym)
|
|
585 (list 'pcomplete)))))
|
|
586
|
|
587 ;;;###autoload
|
|
588 (defun pcomplete-shell-setup ()
|
|
589 "Setup shell-mode to use pcomplete."
|
|
590 (pcomplete-comint-setup 'shell-dynamic-complete-functions))
|
|
591
|
|
592 (defun pcomplete-parse-comint-arguments ()
|
|
593 "Parse whitespace separated arguments in the current region."
|
|
594 (let ((begin (save-excursion (comint-bol nil) (point)))
|
|
595 (end (point))
|
|
596 begins args)
|
|
597 (save-excursion
|
|
598 (goto-char begin)
|
|
599 (while (< (point) end)
|
|
600 (skip-chars-forward " \t\n")
|
|
601 (setq begins (cons (point) begins))
|
|
602 (let ((skip t))
|
|
603 (while skip
|
|
604 (skip-chars-forward "^ \t\n")
|
|
605 (if (eq (char-before) ?\\)
|
|
606 (skip-chars-forward " \t\n")
|
|
607 (setq skip nil))))
|
|
608 (setq args (cons (buffer-substring-no-properties
|
|
609 (car begins) (point))
|
|
610 args)))
|
|
611 (cons (reverse args) (reverse begins)))))
|
|
612
|
|
613 (defun pcomplete-parse-arguments (&optional expand-p)
|
|
614 "Parse the command line arguments. Most completions need this info."
|
|
615 (let ((results (funcall pcomplete-parse-arguments-function)))
|
|
616 (when results
|
|
617 (setq pcomplete-args (or (car results) (list ""))
|
|
618 pcomplete-begins (or (cdr results) (list (point)))
|
|
619 pcomplete-last (1- (length pcomplete-args))
|
|
620 pcomplete-index 0
|
|
621 pcomplete-stub (pcomplete-arg 'last))
|
|
622 (let ((begin (pcomplete-begin 'last)))
|
|
623 (if (and pcomplete-cycle-completions
|
|
624 (listp pcomplete-stub)
|
|
625 (not pcomplete-expand-only-p))
|
|
626 (let* ((completions pcomplete-stub)
|
|
627 (common-stub (car completions))
|
|
628 (c completions)
|
|
629 (len (length common-stub)))
|
|
630 (while (and c (> len 0))
|
|
631 (while (and (> len 0)
|
|
632 (not (string=
|
|
633 (substring common-stub 0 len)
|
|
634 (substring (car c) 0
|
|
635 (min (length (car c))
|
|
636 len)))))
|
|
637 (setq len (1- len)))
|
|
638 (setq c (cdr c)))
|
|
639 (setq pcomplete-stub (substring common-stub 0 len)
|
|
640 pcomplete-autolist t)
|
|
641 (when (and begin (not pcomplete-show-list))
|
|
642 (delete-region begin (point))
|
|
643 (pcomplete-insert-entry "" pcomplete-stub))
|
|
644 (throw 'pcomplete-completions completions))
|
|
645 (when expand-p
|
|
646 (if (stringp pcomplete-stub)
|
|
647 (when begin
|
|
648 (delete-region begin (point))
|
|
649 (insert-and-inherit pcomplete-stub))
|
|
650 (if (and (listp pcomplete-stub)
|
|
651 pcomplete-expand-only-p)
|
|
652 ;; this is for the benefit of `pcomplete-expand'
|
|
653 (setq pcomplete-last-completion-length (- (point) begin)
|
|
654 pcomplete-current-completions pcomplete-stub)
|
|
655 (error "Cannot expand argument"))))
|
|
656 (if pcomplete-expand-only-p
|
|
657 (throw 'pcompleted t)
|
|
658 pcomplete-args))))))
|
|
659
|
|
660 (defun pcomplete-quote-argument (filename)
|
|
661 "Return FILENAME with magic characters quoted.
|
|
662 Magic characters are those in `pcomplete-arg-quote-list'."
|
|
663 (if (null pcomplete-arg-quote-list)
|
|
664 filename
|
|
665 (let ((len (length filename))
|
|
666 (index 0)
|
|
667 (result "")
|
|
668 replacement char)
|
|
669 (while (< index len)
|
|
670 (setq replacement (run-hook-with-args-until-success
|
|
671 'pcomplete-quote-arg-hook filename index))
|
|
672 (cond
|
|
673 (replacement
|
|
674 (setq result (concat result replacement)))
|
|
675 ((and (setq char (aref filename index))
|
|
676 (memq char pcomplete-arg-quote-list))
|
|
677 (setq result (concat result "\\" (char-to-string char))))
|
|
678 (t
|
|
679 (setq result (concat result (char-to-string char)))))
|
|
680 (setq index (1+ index)))
|
|
681 result)))
|
|
682
|
|
683 ;; file-system completion lists
|
|
684
|
|
685 (defsubst pcomplete-dirs-or-entries (&optional regexp predicate)
|
|
686 "Return either directories, or qualified entries."
|
|
687 (append (let ((pcomplete-stub pcomplete-stub))
|
31326
|
688 (pcomplete-entries
|
|
689 regexp (or predicate
|
|
690 (function
|
|
691 (lambda (path)
|
|
692 (not (file-directory-p path)))))))
|
29876
|
693 (pcomplete-entries nil 'file-directory-p)))
|
|
694
|
|
695 (defun pcomplete-entries (&optional regexp predicate)
|
|
696 "Complete against a list of directory candidates.
|
|
697 This function always uses the last argument as the basis for
|
|
698 completion.
|
|
699 If REGEXP is non-nil, it is a regular expression used to refine the
|
|
700 match (files not matching the REGEXP will be excluded).
|
|
701 If PREDICATE is non-nil, it will also be used to refine the match
|
|
702 \(files for which the PREDICATE returns nil will be excluded).
|
|
703 If PATH is non-nil, it will be used for completion instead of
|
|
704 consulting the last argument."
|
|
705 (let* ((name pcomplete-stub)
|
|
706 (default-directory (expand-file-name
|
|
707 (or (file-name-directory name)
|
|
708 default-directory)))
|
|
709 above-cutoff)
|
|
710 (setq name (file-name-nondirectory name)
|
|
711 pcomplete-stub name)
|
|
712 (let ((completions
|
|
713 (file-name-all-completions name default-directory)))
|
|
714 (if regexp
|
|
715 (setq completions
|
|
716 (pcomplete-pare-list
|
|
717 completions nil
|
|
718 (function
|
|
719 (lambda (file)
|
|
720 (not (string-match regexp file)))))))
|
|
721 (if predicate
|
|
722 (setq completions
|
|
723 (pcomplete-pare-list
|
|
724 completions nil
|
|
725 (function
|
|
726 (lambda (file)
|
|
727 (not (funcall predicate file)))))))
|
|
728 (if (or pcomplete-file-ignore pcomplete-dir-ignore)
|
|
729 (setq completions
|
|
730 (pcomplete-pare-list
|
|
731 completions nil
|
|
732 (function
|
|
733 (lambda (file)
|
|
734 (if (eq (aref file (1- (length file)))
|
|
735 directory-sep-char)
|
|
736 (and pcomplete-dir-ignore
|
|
737 (string-match pcomplete-dir-ignore file))
|
|
738 (and pcomplete-file-ignore
|
|
739 (string-match pcomplete-file-ignore file))))))))
|
|
740 (setq above-cutoff (> (length completions)
|
|
741 pcomplete-cycle-cutoff-length))
|
|
742 (sort completions
|
|
743 (function
|
|
744 (lambda (l r)
|
|
745 ;; for the purposes of comparison, remove the
|
|
746 ;; trailing slash from directory names.
|
|
747 ;; Otherwise, "foo.old/" will come before "foo/",
|
|
748 ;; since . is earlier in the ASCII alphabet than
|
|
749 ;; /
|
|
750 (let ((left (if (eq (aref l (1- (length l)))
|
|
751 directory-sep-char)
|
|
752 (substring l 0 (1- (length l)))
|
|
753 l))
|
|
754 (right (if (eq (aref r (1- (length r)))
|
|
755 directory-sep-char)
|
|
756 (substring r 0 (1- (length r)))
|
|
757 r)))
|
|
758 (if above-cutoff
|
|
759 (string-lessp left right)
|
|
760 (funcall pcomplete-compare-entry-function
|
|
761 left right)))))))))
|
|
762
|
|
763 (defsubst pcomplete-all-entries (&optional regexp predicate)
|
|
764 "Like `pcomplete-entries', but doesn't ignore any entries."
|
|
765 (let (pcomplete-file-ignore
|
|
766 pcomplete-dir-ignore)
|
|
767 (pcomplete-entries regexp predicate)))
|
|
768
|
|
769 (defsubst pcomplete-dirs (&optional regexp)
|
|
770 "Complete amongst a list of directories."
|
|
771 (pcomplete-entries regexp 'file-directory-p))
|
|
772
|
|
773 (defsubst pcomplete-executables (&optional regexp)
|
|
774 "Complete amongst a list of directories and executables."
|
|
775 (pcomplete-entries regexp 'file-executable-p))
|
|
776
|
|
777 ;; generation of completion lists
|
|
778
|
|
779 (defun pcomplete-find-completion-function (command)
|
|
780 "Find the completion function to call for the given COMMAND."
|
|
781 (let ((sym (intern-soft
|
|
782 (concat "pcomplete/" (symbol-name major-mode) "/" command))))
|
|
783 (unless sym
|
|
784 (setq sym (intern-soft (concat "pcomplete/" command))))
|
|
785 (and sym (fboundp sym) sym)))
|
|
786
|
|
787 (defun pcomplete-completions ()
|
|
788 "Return a list of completions for the current argument position."
|
|
789 (catch 'pcomplete-completions
|
|
790 (when (pcomplete-parse-arguments pcomplete-expand-before-complete)
|
|
791 (if (= pcomplete-index pcomplete-last)
|
|
792 (funcall pcomplete-command-completion-function)
|
|
793 (let ((sym (or (pcomplete-find-completion-function
|
|
794 (funcall pcomplete-command-name-function))
|
|
795 pcomplete-default-completion-function)))
|
|
796 (ignore
|
|
797 (pcomplete-next-arg)
|
|
798 (funcall sym)))))))
|
|
799
|
|
800 (defun pcomplete-opt (options &optional prefix no-ganging args-follow)
|
|
801 "Complete a set of OPTIONS, each beginning with PREFIX (?- by default).
|
|
802 PREFIX may be t, in which case no PREFIX character is necessary.
|
|
803 If REQUIRED is non-nil, the options must be present.
|
|
804 If NO-GANGING is non-nil, each option is separate. -xy is not allowed.
|
|
805 If ARGS-FOLLOW is non-nil, then options which arguments which take may
|
|
806 have the argument appear after a ganged set of options. This is how
|
|
807 tar behaves, for example."
|
|
808 (if (and (= pcomplete-index pcomplete-last)
|
|
809 (string= (pcomplete-arg) "-"))
|
|
810 (let ((len (length options))
|
|
811 (index 0)
|
|
812 char choices)
|
|
813 (while (< index len)
|
|
814 (setq char (aref options index))
|
|
815 (if (eq char ?\()
|
|
816 (let ((result (read-from-string options index)))
|
|
817 (setq index (cdr result)))
|
|
818 (unless (memq char '(?/ ?* ?? ?.))
|
|
819 (setq choices (cons (char-to-string char) choices)))
|
|
820 (setq index (1+ index))))
|
|
821 (throw 'pcomplete-completions
|
|
822 (mapcar
|
|
823 (function
|
|
824 (lambda (opt)
|
|
825 (concat "-" opt)))
|
|
826 (pcomplete-uniqify-list choices))))
|
|
827 (let ((arg (pcomplete-arg)))
|
|
828 (when (and (> (length arg) 1)
|
|
829 (stringp arg)
|
|
830 (eq (aref arg 0) (or prefix ?-)))
|
|
831 (pcomplete-next-arg)
|
|
832 (let ((char (aref arg 1))
|
|
833 (len (length options))
|
|
834 (index 0)
|
|
835 opt-char arg-char result)
|
|
836 (while (< (1+ index) len)
|
|
837 (setq opt-char (aref options index)
|
|
838 arg-char (aref options (1+ index)))
|
|
839 (if (eq arg-char ?\()
|
|
840 (setq result
|
|
841 (read-from-string options (1+ index))
|
|
842 index (cdr result)
|
|
843 result (car result))
|
|
844 (setq result nil))
|
|
845 (when (and (eq char opt-char)
|
|
846 (memq arg-char '(?\( ?/ ?* ?? ?.)))
|
|
847 (if (< pcomplete-index pcomplete-last)
|
|
848 (pcomplete-next-arg)
|
|
849 (throw 'pcomplete-completions
|
|
850 (cond ((eq arg-char ?/) (pcomplete-dirs))
|
|
851 ((eq arg-char ?*) (pcomplete-executables))
|
|
852 ((eq arg-char ??) nil)
|
|
853 ((eq arg-char ?.) (pcomplete-entries))
|
|
854 ((eq arg-char ?\() (eval result))))))
|
|
855 (setq index (1+ index))))))))
|
|
856
|
|
857 (defun pcomplete--here (&optional form stub paring form-only)
|
|
858 "Complete aganst the current argument, if at the end.
|
|
859 See the documentation for `pcomplete-here'."
|
|
860 (if (< pcomplete-index pcomplete-last)
|
|
861 (progn
|
|
862 (if (eq paring 0)
|
|
863 (setq pcomplete-seen nil)
|
|
864 (unless (eq paring t)
|
|
865 (let ((arg (pcomplete-arg)))
|
|
866 (unless (not (stringp arg))
|
|
867 (setq pcomplete-seen
|
|
868 (cons (if paring
|
|
869 (funcall paring arg)
|
|
870 (file-truename arg))
|
|
871 pcomplete-seen))))))
|
|
872 (pcomplete-next-arg)
|
|
873 t)
|
|
874 (when pcomplete-show-help
|
|
875 (pcomplete--help)
|
|
876 (throw 'pcompleted t))
|
|
877 (if stub
|
|
878 (setq pcomplete-stub stub))
|
|
879 (if (or (eq paring t) (eq paring 0))
|
|
880 (setq pcomplete-seen nil)
|
|
881 (setq pcomplete-norm-func (or paring 'file-truename)))
|
|
882 (unless form-only
|
|
883 (run-hooks 'pcomplete-try-first-hook))
|
|
884 (throw 'pcomplete-completions (eval form))))
|
|
885
|
|
886 (defmacro pcomplete-here (&optional form stub paring form-only)
|
|
887 "Complete aganst the current argument, if at the end.
|
|
888 If completion is to be done here, evaluate FORM to generate the list
|
|
889 of strings which will be used for completion purposes. If STUB is a
|
|
890 string, use it as the completion stub instead of the default (which is
|
|
891 the entire text of the current argument).
|
|
892
|
|
893 For an example of when you might want to use STUB: if the current
|
|
894 argument text is 'long-path-name/', you don't want the completions
|
|
895 list display to be cluttered by 'long-path-name/' appearing at the
|
|
896 beginning of every alternative. Not only does this make things less
|
|
897 intelligle, but it is also inefficient. Yet, if the completion list
|
|
898 does not begin with this string for every entry, the current argument
|
|
899 won't complete correctly.
|
|
900
|
|
901 The solution is to specify a relative stub. It allows you to
|
|
902 substitute a different argument from the current argument, almost
|
|
903 always for the sake of efficiency.
|
|
904
|
|
905 If PARING is nil, this argument will be pared against previous
|
|
906 arguments using the function `file-truename' to normalize them.
|
|
907 PARING may be a function, in which case that function is for
|
|
908 normalization. If PARING is the value t, the argument dealt with by
|
|
909 this call will not participate in argument paring. If it the integer
|
|
910 0, all previous arguments that have been seen will be cleared.
|
|
911
|
|
912 If FORM-ONLY is non-nil, only the result of FORM will be used to
|
|
913 generate the completions list. This means that the hook
|
|
914 `pcomplete-try-first-hook' will not be run."
|
|
915 `(pcomplete--here (quote ,form) ,stub ,paring ,form-only))
|
|
916
|
|
917 (defmacro pcomplete-here* (&optional form stub form-only)
|
|
918 "An alternate form which does not participate in argument paring."
|
|
919 `(pcomplete-here ,form ,stub t ,form-only))
|
|
920
|
|
921 ;; display support
|
|
922
|
|
923 (defun pcomplete-restore-windows ()
|
|
924 "If the only window change was due to Completions, restore things."
|
|
925 (if pcomplete-last-window-config
|
|
926 (let* ((cbuf (get-buffer "*Completions*"))
|
|
927 (cwin (and cbuf (get-buffer-window cbuf))))
|
|
928 (when (and cwin (window-live-p cwin))
|
|
929 (bury-buffer cbuf)
|
|
930 (set-window-configuration pcomplete-last-window-config))))
|
|
931 (setq pcomplete-last-window-config nil
|
|
932 pcomplete-window-restore-timer nil))
|
|
933
|
|
934 ;; Abstractions so that the code below will work for both Emacs 20 and
|
|
935 ;; XEmacs 21
|
|
936
|
|
937 (unless (fboundp 'event-matches-key-specifier-p)
|
|
938 (defalias 'event-matches-key-specifier-p 'eq))
|
|
939
|
|
940 (unless (fboundp 'read-event)
|
|
941 (defsubst read-event (&optional prompt)
|
|
942 (aref (read-key-sequence prompt) 0)))
|
|
943
|
|
944 (unless (fboundp 'event-basic-type)
|
|
945 (defalias 'event-basic-type 'event-key))
|
|
946
|
|
947 (defun pcomplete-show-completions (completions)
|
|
948 "List in help buffer sorted COMPLETIONS.
|
|
949 Typing SPC flushes the help buffer."
|
|
950 (let* ((curbuf (current-buffer)))
|
|
951 (when pcomplete-window-restore-timer
|
|
952 (cancel-timer pcomplete-window-restore-timer)
|
|
953 (setq pcomplete-window-restore-timer nil))
|
|
954 (unless pcomplete-last-window-config
|
|
955 (setq pcomplete-last-window-config (current-window-configuration)))
|
|
956 (with-output-to-temp-buffer "*Completions*"
|
|
957 (display-completion-list completions))
|
|
958 (message "Hit space to flush")
|
|
959 (let (event)
|
|
960 (prog1
|
|
961 (catch 'done
|
|
962 (while (with-current-buffer (get-buffer "*Completions*")
|
|
963 (setq event (read-event)))
|
|
964 (cond
|
|
965 ((event-matches-key-specifier-p event ? )
|
|
966 (set-window-configuration pcomplete-last-window-config)
|
|
967 (setq pcomplete-last-window-config nil)
|
|
968 (throw 'done nil))
|
|
969 ((event-matches-key-specifier-p event 'tab)
|
|
970 (save-selected-window
|
|
971 (select-window (get-buffer-window "*Completions*"))
|
|
972 (if (pos-visible-in-window-p (point-max))
|
|
973 (goto-char (point-min))
|
|
974 (scroll-up)))
|
|
975 (message ""))
|
|
976 (t
|
|
977 (setq unread-command-events (list event))
|
|
978 (throw 'done nil)))))
|
|
979 (if (and pcomplete-last-window-config
|
|
980 pcomplete-restore-window-delay)
|
|
981 (setq pcomplete-window-restore-timer
|
|
982 (run-with-timer pcomplete-restore-window-delay nil
|
|
983 'pcomplete-restore-windows)))))))
|
|
984
|
|
985 ;; insert completion at point
|
|
986
|
|
987 (defun pcomplete-insert-entry (stub entry &optional addsuffix raw-p)
|
|
988 "Insert a completion entry at point.
|
|
989 Returns non-nil if a space was appended at the end."
|
|
990 (let ((here (point)))
|
|
991 (if (not pcomplete-ignore-case)
|
|
992 (insert-and-inherit (if raw-p
|
|
993 (substring entry (length stub))
|
|
994 (pcomplete-quote-argument
|
|
995 (substring entry (length stub)))))
|
|
996 ;; the stub is not quoted at this time, so to determine the
|
|
997 ;; length of what should be in the buffer, we must quote it
|
|
998 (delete-backward-char (length (pcomplete-quote-argument stub)))
|
|
999 ;; if there is already a backslash present to handle the first
|
|
1000 ;; character, don't bother quoting it
|
|
1001 (when (eq (char-before) ?\\)
|
|
1002 (insert-and-inherit (substring entry 0 1))
|
|
1003 (setq entry (substring entry 1)))
|
|
1004 (insert-and-inherit (if raw-p
|
|
1005 entry
|
|
1006 (pcomplete-quote-argument entry))))
|
|
1007 (let (space-added)
|
|
1008 (when (and (not (memq (char-before) pcomplete-suffix-list))
|
|
1009 addsuffix)
|
|
1010 (insert-and-inherit " ")
|
|
1011 (setq space-added t))
|
|
1012 (setq pcomplete-last-completion-length (- (point) here)
|
|
1013 pcomplete-last-completion-stub stub)
|
|
1014 space-added)))
|
|
1015
|
|
1016 ;; selection of completions
|
|
1017
|
|
1018 (defun pcomplete-do-complete (stub completions)
|
|
1019 "Dynamically complete at point using STUB and COMPLETIONS.
|
|
1020 This is basically just a wrapper for `pcomplete-stub' which does some
|
|
1021 extra checking, and munging of the COMPLETIONS list."
|
|
1022 (unless (stringp stub)
|
|
1023 (message "Cannot complete argument")
|
|
1024 (throw 'pcompleted nil))
|
|
1025 (if (null completions)
|
|
1026 (ignore
|
|
1027 (if (and stub (> (length stub) 0))
|
|
1028 (message "No completions of %s" stub)
|
|
1029 (message "No completions")))
|
|
1030 ;; pare it down, if applicable
|
31241
|
1031 (if (and pcomplete-use-paring pcomplete-seen)
|
29876
|
1032 (let* ((arg (pcomplete-arg))
|
|
1033 (prefix
|
|
1034 (file-name-as-directory
|
|
1035 (funcall pcomplete-norm-func
|
|
1036 (substring arg 0 (- (length arg)
|
|
1037 (length pcomplete-stub)))))))
|
|
1038 (setq pcomplete-seen
|
|
1039 (mapcar 'directory-file-name pcomplete-seen))
|
|
1040 (let ((p pcomplete-seen))
|
|
1041 (while p
|
|
1042 (add-to-list 'pcomplete-seen
|
|
1043 (funcall pcomplete-norm-func (car p)))
|
|
1044 (setq p (cdr p))))
|
|
1045 (setq completions
|
|
1046 (mapcar
|
|
1047 (function
|
|
1048 (lambda (elem)
|
|
1049 (file-relative-name elem prefix)))
|
|
1050 (pcomplete-pare-list
|
|
1051 (mapcar
|
|
1052 (function
|
|
1053 (lambda (elem)
|
|
1054 (expand-file-name elem prefix)))
|
|
1055 completions)
|
|
1056 pcomplete-seen
|
|
1057 (function
|
|
1058 (lambda (elem)
|
|
1059 (member (directory-file-name
|
|
1060 (funcall pcomplete-norm-func elem))
|
|
1061 pcomplete-seen))))))))
|
|
1062 ;; OK, we've got a list of completions.
|
|
1063 (if pcomplete-show-list
|
|
1064 (pcomplete-show-completions completions)
|
|
1065 (pcomplete-stub stub completions))))
|
|
1066
|
|
1067 (defun pcomplete-stub (stub candidates &optional cycle-p)
|
|
1068 "Dynamically complete STUB from CANDIDATES list.
|
|
1069 This function inserts completion characters at point by completing
|
|
1070 STUB from the strings in CANDIDATES. A completions listing may be
|
|
1071 shown in a help buffer if completion is ambiguous.
|
|
1072
|
|
1073 Returns nil if no completion was inserted.
|
|
1074 Returns `sole' if completed with the only completion match.
|
|
1075 Returns `shortest' if completed with the shortest of the matches.
|
|
1076 Returns `partial' if completed as far as possible with the matches.
|
|
1077 Returns `listed' if a completion listing was shown.
|
|
1078
|
|
1079 See also `pcomplete-filename'."
|
|
1080 (let* ((completion-ignore-case pcomplete-ignore-case)
|
|
1081 (candidates (mapcar 'list candidates))
|
|
1082 (completions (all-completions stub candidates)))
|
|
1083 (let (result entry)
|
|
1084 (cond
|
|
1085 ((null completions)
|
|
1086 (if (and stub (> (length stub) 0))
|
|
1087 (message "No completions of %s" stub)
|
|
1088 (message "No completions")))
|
|
1089 ((= 1 (length completions))
|
|
1090 (setq entry (car completions))
|
|
1091 (if (string-equal entry stub)
|
|
1092 (message "Sole completion"))
|
|
1093 (setq result 'sole))
|
|
1094 ((and pcomplete-cycle-completions
|
|
1095 (or cycle-p
|
|
1096 (not pcomplete-cycle-cutoff-length)
|
|
1097 (<= (length completions)
|
|
1098 pcomplete-cycle-cutoff-length)))
|
|
1099 (setq entry (car completions)
|
|
1100 pcomplete-current-completions completions))
|
|
1101 (t ; There's no unique completion; use longest substring
|
|
1102 (setq entry (try-completion stub candidates))
|
|
1103 (cond ((and pcomplete-recexact
|
|
1104 (string-equal stub entry)
|
|
1105 (member entry completions))
|
|
1106 ;; It's not unique, but user wants shortest match.
|
|
1107 (message "Completed shortest")
|
|
1108 (setq result 'shortest))
|
|
1109 ((or pcomplete-autolist
|
|
1110 (string-equal stub entry))
|
|
1111 ;; It's not unique, list possible completions.
|
|
1112 (pcomplete-show-completions completions)
|
|
1113 (setq result 'listed))
|
|
1114 (t
|
|
1115 (message "Partially completed")
|
|
1116 (setq result 'partial)))))
|
|
1117 (cons result entry))))
|
|
1118
|
|
1119 ;; context sensitive help
|
|
1120
|
|
1121 (defun pcomplete--help ()
|
|
1122 "Produce context-sensitive help for the current argument.
|
|
1123 If specific documentation can't be given, be generic.
|
|
1124 INFODOC specifies the Info node to goto. DOCUMENTATION is a sexp
|
|
1125 which will produce documentation for the argument (it is responsible
|
|
1126 for displaying in its own buffer)."
|
|
1127 (if (and pcomplete-help
|
|
1128 (or (and (stringp pcomplete-help)
|
|
1129 (fboundp 'Info-goto-node))
|
|
1130 (listp pcomplete-help)))
|
|
1131 (if (listp pcomplete-help)
|
|
1132 (message (eval pcomplete-help))
|
|
1133 (save-window-excursion (info))
|
|
1134 (switch-to-buffer-other-window "*info*")
|
|
1135 (funcall (symbol-function 'Info-goto-node) pcomplete-help))
|
|
1136 (if pcomplete-man-function
|
|
1137 (let ((cmd (funcall pcomplete-command-name-function)))
|
|
1138 (if (and cmd (> (length cmd) 0))
|
|
1139 (funcall pcomplete-man-function cmd)))
|
|
1140 (message "No context-sensitive help available"))))
|
|
1141
|
|
1142 ;; general utilities
|
|
1143
|
|
1144 (defsubst pcomplete-time-less-p (t1 t2)
|
|
1145 "Say whether time T1 is less than time T2."
|
|
1146 (or (< (car t1) (car t2))
|
|
1147 (and (= (car t1) (car t2))
|
|
1148 (< (nth 1 t1) (nth 1 t2)))))
|
|
1149
|
|
1150 (defun pcomplete-pare-list (l r &optional pred)
|
|
1151 "Destructively remove from list L all elements matching any in list R.
|
|
1152 Test is done using `equal'.
|
|
1153 If PRED is non-nil, it is a function used for further removal.
|
|
1154 Returns the resultant list."
|
|
1155 (while (and l (or (and r (member (car l) r))
|
|
1156 (and pred
|
|
1157 (funcall pred (car l)))))
|
|
1158 (setq l (cdr l)))
|
|
1159 (let ((m l))
|
|
1160 (while m
|
|
1161 (while (and (cdr m)
|
|
1162 (or (and r (member (cadr m) r))
|
|
1163 (and pred
|
|
1164 (funcall pred (cadr m)))))
|
|
1165 (setcdr m (cddr m)))
|
|
1166 (setq m (cdr m))))
|
|
1167 l)
|
|
1168
|
|
1169 (defun pcomplete-uniqify-list (l)
|
|
1170 "Sort and remove multiples in L."
|
|
1171 (setq l (sort l 'string-lessp))
|
|
1172 (let ((m l))
|
|
1173 (while m
|
|
1174 (while (and (cdr m)
|
|
1175 (string= (car m)
|
|
1176 (cadr m)))
|
|
1177 (setcdr m (cddr m)))
|
|
1178 (setq m (cdr m))))
|
|
1179 l)
|
|
1180
|
|
1181 (defun pcomplete-process-result (cmd &rest args)
|
|
1182 "Call CMD using `call-process' and return the simplest result."
|
|
1183 (with-temp-buffer
|
|
1184 (apply 'call-process cmd nil t nil args)
|
|
1185 (skip-chars-backward "\n")
|
|
1186 (buffer-substring (point-min) (point))))
|
|
1187
|
|
1188 ;; create a set of aliases which allow completion functions to be not
|
|
1189 ;; quite so verbose
|
|
1190
|
|
1191 ;; jww (1999-10-20): are these a good idea?
|
|
1192 ; (defalias 'pc-here 'pcomplete-here)
|
|
1193 ; (defalias 'pc-test 'pcomplete-test)
|
|
1194 ; (defalias 'pc-opt 'pcomplete-opt)
|
|
1195 ; (defalias 'pc-match 'pcomplete-match)
|
|
1196 ; (defalias 'pc-match-string 'pcomplete-match-string)
|
|
1197 ; (defalias 'pc-match-beginning 'pcomplete-match-beginning)
|
|
1198 ; (defalias 'pc-match-end 'pcomplete-match-end)
|
|
1199
|
|
1200 ;;; pcomplete.el ends here
|