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