pcomplete.el 50.8 KB
Newer Older
1
;;; pcomplete.el --- programmable completion -*- lexical-binding: t -*-
Gerd Moellmann's avatar
Gerd Moellmann committed
2

Paul Eggert's avatar
Paul Eggert committed
3
;; Copyright (C) 1999-2018 Free Software Foundation, Inc.
Gerd Moellmann's avatar
Gerd Moellmann committed
4 5

;; Author: John Wiegley <johnw@gnu.org>
6
;; Keywords: processes abbrev
Gerd Moellmann's avatar
Gerd Moellmann committed
7 8 9

;; This file is part of GNU Emacs.

10
;; GNU Emacs is free software: you can redistribute it and/or modify
Gerd Moellmann's avatar
Gerd Moellmann committed
11
;; it under the terms of the GNU General Public License as published by
12 13
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
Gerd Moellmann's avatar
Gerd Moellmann committed
14 15 16 17 18 19 20

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
21
;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
Gerd Moellmann's avatar
Gerd Moellmann committed
22 23 24 25 26 27 28 29 30

;;; Commentary:

;; This module provides a programmable completion facility using
;; "completion functions".  Each completion function is responsible
;; for producing a list of possible completions relevant to the current
;; argument position.
;;
;; To use pcomplete with shell-mode, for example, you will need the
31
;; following in your init file:
Gerd Moellmann's avatar
Gerd Moellmann committed
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
;;
;;   (add-hook 'shell-mode-hook 'pcomplete-shell-setup)
;;
;; Most of the code below simply provides support mechanisms for
;; writing completion functions.  Completion functions themselves are
;; very easy to write.  They have few requirements beyond those of
;; regular Lisp functions.
;;
;; Consider the following example, which will complete against
;; filenames for the first two arguments, and directories for all
;; remaining arguments:
;;
;;   (defun pcomplete/my-command ()
;;     (pcomplete-here (pcomplete-entries))
;;     (pcomplete-here (pcomplete-entries))
;;     (while (pcomplete-here (pcomplete-dirs))))
;;
;; Here are the requirements for completion functions:
;;
;; @ They must be called "pcomplete/MAJOR-MODE/NAME", or
;;   "pcomplete/NAME".  This is how they are looked up, using the NAME
;;   specified in the command argument (the argument in first
;;   position).
;;
;; @ They must be callable with no arguments.
;;
;; @ Their return value is ignored.  If they actually return normally,
;;   it means no completions were available.
;;
;; @ In order to provide completions, they must throw the tag
62 63 64
;;   `pcomplete-completions'.  The value must be a completion table
;;   (i.e. a table that can be passed to try-completion and friends)
;;   for the final argument.
Gerd Moellmann's avatar
Gerd Moellmann committed
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
;;
;; @ To simplify completion function logic, the tag `pcompleted' may
;;   be thrown with a value of nil in order to abort the function.  It
;;   means that there were no completions available.
;;
;; When a completion function is called, the variable `pcomplete-args'
;; is in scope, and contains all of the arguments specified on the
;; command line.  The variable `pcomplete-last' is the index of the
;; last argument in that list.
;;
;; The variable `pcomplete-index' is used by the completion code to
;; know which argument the completion function is currently examining.
;; It always begins at 1, meaning the first argument after the command
;; name.
;;
;; To facilitate writing completion logic, a special macro,
;; `pcomplete-here', has been provided which does several things:
;;
;;  1. It will throw `pcompleted' (with a value of nil) whenever
;;     `pcomplete-index' exceeds `pcomplete-last'.
;;
;;  2. It will increment `pcomplete-index' if the final argument has
;;     not been reached yet.
;;
;;  3. It will evaluate the form passed to it, and throw the result
;;     using the `pcomplete-completions' tag, if it is called when
;;     `pcomplete-index' is pointing to the final argument.
;;
;; Sometimes a completion function will want to vary the possible
;; completions for an argument based on the previous one.  To
;; facilitate tests like this, the function `pcomplete-test' and
;; `pcomplete-match' are provided.  Called with one argument, they
;; test the value of the previous command argument.  Otherwise, a
;; relative index may be given as an optional second argument, where 0
;; refers to the current argument, 1 the previous, 2 the one before
;; that, etc.  The symbols `first' and `last' specify absolute
;; offsets.
;;
;; Here is an example which will only complete against directories for
;; the second argument if the first argument is also a directory:
;;
;;   (defun pcomplete/example ()
;;      (pcomplete-here (pcomplete-entries))
;;      (if (pcomplete-test 'file-directory-p)
;;          (pcomplete-here (pcomplete-dirs))
;;        (pcomplete-here (pcomplete-entries))))
;;
;; For generating completion lists based on directory contents, see
;; the functions `pcomplete-entries', `pcomplete-dirs',
;; `pcomplete-executables' and `pcomplete-all-entries'.
;;
;; Consult the documentation for `pcomplete-here' for information
;; about its other arguments.

;;; Code:

121
(require 'comint)
Gerd Moellmann's avatar
Gerd Moellmann committed
122 123 124

(defgroup pcomplete nil
  "Programmable completion."
125
  :version "21.1"
Gerd Moellmann's avatar
Gerd Moellmann committed
126 127 128 129 130
  :group 'processes)

;;; User Variables:

(defcustom pcomplete-file-ignore nil
Lute Kamstra's avatar
Lute Kamstra committed
131
  "A regexp of filenames to be disregarded during file completion."
John Wiegley's avatar
John Wiegley committed
132
  :type '(choice regexp (const :tag "None" nil))
Gerd Moellmann's avatar
Gerd Moellmann committed
133 134 135
  :group 'pcomplete)

(defcustom pcomplete-dir-ignore nil
Lute Kamstra's avatar
Lute Kamstra committed
136
  "A regexp of names to be disregarded during directory completion."
John Wiegley's avatar
John Wiegley committed
137
  :type '(choice regexp (const :tag "None" nil))
Gerd Moellmann's avatar
Gerd Moellmann committed
138 139
  :group 'pcomplete)

Juanma Barranquero's avatar
Juanma Barranquero committed
140
(defcustom pcomplete-ignore-case (memq system-type '(ms-dos windows-nt cygwin))
141 142
  ;; FIXME: the doc mentions file-name completion, but the code
  ;; seems to apply it to all completions.
Lute Kamstra's avatar
Lute Kamstra committed
143
  "If non-nil, ignore case when doing filename completion."
Gerd Moellmann's avatar
Gerd Moellmann committed
144 145 146 147
  :type 'boolean
  :group 'pcomplete)

(defcustom pcomplete-autolist nil
Lute Kamstra's avatar
Lute Kamstra committed
148
  "If non-nil, automatically list possibilities on partial completion.
Gerd Moellmann's avatar
Gerd Moellmann committed
149 150 151 152
This mirrors the optional behavior of tcsh."
  :type 'boolean
  :group 'pcomplete)

153
(defcustom pcomplete-suffix-list (list ?/ ?:)
Lute Kamstra's avatar
Lute Kamstra committed
154
  "A list of characters which constitute a proper suffix."
Gerd Moellmann's avatar
Gerd Moellmann committed
155 156
  :type '(repeat character)
  :group 'pcomplete)
157
(make-obsolete-variable 'pcomplete-suffix-list nil "24.1")
Gerd Moellmann's avatar
Gerd Moellmann committed
158 159

(defcustom pcomplete-recexact nil
Lute Kamstra's avatar
Lute Kamstra committed
160
  "If non-nil, use shortest completion if characters cannot be added.
Gerd Moellmann's avatar
Gerd Moellmann committed
161 162 163 164 165 166
This mirrors the optional behavior of tcsh.

A non-nil value is useful if `pcomplete-autolist' is non-nil too."
  :type 'boolean
  :group 'pcomplete)

167
(define-obsolete-variable-alias
168
  'pcomplete-arg-quote-list 'comint-file-name-quote-list "24.3")
Gerd Moellmann's avatar
Gerd Moellmann committed
169 170

(defcustom pcomplete-man-function 'man
Lute Kamstra's avatar
Lute Kamstra committed
171
  "A function to that will be called to display a manual page.
Gerd Moellmann's avatar
Gerd Moellmann committed
172 173 174 175 176
It will be passed the name of the command to document."
  :type 'function
  :group 'pcomplete)

(defcustom pcomplete-compare-entry-function 'string-lessp
Lute Kamstra's avatar
Lute Kamstra committed
177
  "This function is used to order file entries for completion.
Gerd Moellmann's avatar
Gerd Moellmann committed
178 179 180 181 182 183 184
The behavior of most all shells is to sort alphabetically."
  :type '(radio (function-item string-lessp)
		(function-item file-newer-than-file-p)
		(function :tag "Other"))
  :group 'pcomplete)

(defcustom pcomplete-help nil
Lute Kamstra's avatar
Lute Kamstra committed
185
  "A string or function (or nil) used for context-sensitive help.
Gerd Moellmann's avatar
Gerd Moellmann committed
186 187 188 189 190 191 192 193 194
If a string, it should name an Info node that will be jumped to.
If non-nil, it must a sexp that will be evaluated, and whose
result will be shown in the minibuffer.
If nil, the function `pcomplete-man-function' will be called with the
current command argument."
  :type '(choice string sexp (const :tag "Use man page" nil))
  :group 'pcomplete)

(defcustom pcomplete-expand-before-complete nil
Lute Kamstra's avatar
Lute Kamstra committed
195
  "If non-nil, expand the current argument before completing it.
196
This means that typing something such as `$HOME/bi' followed by
Gerd Moellmann's avatar
Gerd Moellmann committed
197 198 199 200 201 202 203 204 205 206
\\[pcomplete-argument] will cause the variable reference to be
resolved first, and the resultant value that will be completed against
to be inserted in the buffer.  Note that exactly what gets expanded
and how is entirely up to the behavior of the
`pcomplete-parse-arguments-function'."
  :type 'boolean
  :group 'pcomplete)

(defcustom pcomplete-parse-arguments-function
  'pcomplete-parse-buffer-arguments
Lute Kamstra's avatar
Lute Kamstra committed
207
  "A function to call to parse the current line's arguments.
Gerd Moellmann's avatar
Gerd Moellmann committed
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
It should be called with no parameters, and with point at the position
of the argument that is to be completed.

It must either return nil, or a cons cell of the form:

  ((ARG...) (BEG-POS...))

The two lists must be identical in length.  The first gives the final
value of each command line argument (which need not match the textual
representation of that argument), and BEG-POS gives the beginning
position of each argument, as it is seen by the user.  The establishes
a relationship between the fully resolved value of the argument, and
the textual representation of the argument."
  :type 'function
  :group 'pcomplete)

(defcustom pcomplete-cycle-completions t
Lute Kamstra's avatar
Lute Kamstra committed
225
  "If non-nil, hitting the TAB key cycles through the completion list.
Gerd Moellmann's avatar
Gerd Moellmann committed
226 227 228 229 230 231 232 233 234 235 236
Typical Emacs behavior is to complete as much as possible, then pause
waiting for further input.  Then if TAB is hit again, show a list of
possible completions.  When `pcomplete-cycle-completions' is non-nil,
it acts more like zsh or 4nt, showing the first maximal match first,
followed by any further matches on each subsequent pressing of the TAB
key.  \\[pcomplete-list] is the key to press if the user wants to see
the list of possible completions."
  :type 'boolean
  :group 'pcomplete)

(defcustom pcomplete-cycle-cutoff-length 5
Lute Kamstra's avatar
Lute Kamstra committed
237
  "If the number of completions is greater than this, don't cycle.
Gerd Moellmann's avatar
Gerd Moellmann committed
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
This variable is a compromise between the traditional Emacs style of
completion, and the \"cycling\" style.  Basically, if there are more
than this number of completions possible, don't automatically pick the
first one and then expect the user to press TAB to cycle through them.
Typically, when there are a large number of completion possibilities,
the user wants to see them in a list buffer so that they can know what
options are available.  But if the list is small, it means the user
has already entered enough input to disambiguate most of the
possibilities, and therefore they are probably most interested in
cycling through the candidates.  Set this value to nil if you want
cycling to always be enabled."
  :type '(choice integer (const :tag "Always cycle" nil))
  :group 'pcomplete)

(defcustom pcomplete-restore-window-delay 1
Lute Kamstra's avatar
Lute Kamstra committed
253
  "The number of seconds to wait before restoring completion windows.
Gerd Moellmann's avatar
Gerd Moellmann committed
254 255 256 257 258 259 260 261 262 263 264
Once the completion window has been displayed, if the user then goes
on to type something else, that completion window will be removed from
the display (actually, the original window configuration before it was
displayed will be restored), after this many seconds of idle time.  If
set to nil, completion windows will be left on second until the user
removes them manually.  If set to 0, they will disappear immediately
after the user enters a key other than TAB."
  :type '(choice integer (const :tag "Never restore" nil))
  :group 'pcomplete)

(defcustom pcomplete-try-first-hook nil
Lute Kamstra's avatar
Lute Kamstra committed
265
  "A list of functions which are called before completing an argument.
Gerd Moellmann's avatar
Gerd Moellmann committed
266 267 268 269 270
This can be used, for example, for completing things which might apply
to all arguments, such as variable names after a $."
  :type 'hook
  :group 'pcomplete)

271 272 273 274
(defsubst pcomplete-executables (&optional regexp)
  "Complete amongst a list of directories and executables."
  (pcomplete-entries regexp 'file-executable-p))

Gerd Moellmann's avatar
Gerd Moellmann committed
275 276 277 278
(defcustom pcomplete-command-completion-function
  (function
   (lambda ()
     (pcomplete-here (pcomplete-executables))))
Lute Kamstra's avatar
Lute Kamstra committed
279
  "Function called for completing the initial command argument."
Gerd Moellmann's avatar
Gerd Moellmann committed
280 281 282 283
  :type 'function
  :group 'pcomplete)

(defcustom pcomplete-command-name-function 'pcomplete-command-name
Lute Kamstra's avatar
Lute Kamstra committed
284
  "Function called for determining the current command name."
Gerd Moellmann's avatar
Gerd Moellmann committed
285 286 287 288 289 290 291
  :type 'function
  :group 'pcomplete)

(defcustom pcomplete-default-completion-function
  (function
   (lambda ()
     (while (pcomplete-here (pcomplete-entries)))))
Lute Kamstra's avatar
Lute Kamstra committed
292
  "Function called when no completion rule can be found.
Gerd Moellmann's avatar
Gerd Moellmann committed
293 294 295 296
This function is used to generate completions for every argument."
  :type 'function
  :group 'pcomplete)

John Wiegley's avatar
John Wiegley committed
297
(defcustom pcomplete-use-paring t
Lute Kamstra's avatar
Lute Kamstra committed
298
  "If t, pare alternatives that have already been used.
John Wiegley's avatar
John Wiegley committed
299 300 301 302 303 304
If nil, you will always see the completion set of possible options, no
matter which of those options have already been used in previous
command arguments."
  :type 'boolean
  :group 'pcomplete)

305
(defcustom pcomplete-termination-string " "
Lute Kamstra's avatar
Lute Kamstra committed
306
  "A string that is inserted after any completion or expansion.
307 308 309 310 311 312 313 314
This is usually a space character, useful when completing lists of
words separated by spaces.  However, if your list uses a different
separator character, or if the completion occurs in a word that is
already terminated by a character, this variable should be locally
modified to be an empty string, or the desired separation string."
  :type 'string
  :group 'pcomplete)

Gerd Moellmann's avatar
Gerd Moellmann committed
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337
;;; Internal Variables:

;; for cycling completion support
(defvar pcomplete-current-completions nil)
(defvar pcomplete-last-completion-length)
(defvar pcomplete-last-completion-stub)
(defvar pcomplete-last-completion-raw)
(defvar pcomplete-last-window-config nil)
(defvar pcomplete-window-restore-timer nil)

(make-variable-buffer-local 'pcomplete-current-completions)
(make-variable-buffer-local 'pcomplete-last-completion-length)
(make-variable-buffer-local 'pcomplete-last-completion-stub)
(make-variable-buffer-local 'pcomplete-last-completion-raw)
(make-variable-buffer-local 'pcomplete-last-window-config)
(make-variable-buffer-local 'pcomplete-window-restore-timer)

;; used for altering pcomplete's behavior.  These global variables
;; should always be nil.
(defvar pcomplete-show-help nil)
(defvar pcomplete-show-list nil)
(defvar pcomplete-expand-only-p nil)

338 339 340 341 342 343 344 345 346 347
;; for the sake of the bye-compiler, when compiling other files that
;; contain completion functions
(defvar pcomplete-args nil)
(defvar pcomplete-begins nil)
(defvar pcomplete-last nil)
(defvar pcomplete-index nil)
(defvar pcomplete-stub nil)
(defvar pcomplete-seen nil)
(defvar pcomplete-norm-func nil)

Gerd Moellmann's avatar
Gerd Moellmann committed
348 349
;;; User Functions:

350 351 352 353 354 355 356 357
;;; Alternative front-end using the standard completion facilities.

;; The way pcomplete-parse-arguments, pcomplete-stub, and
;; pcomplete-quote-argument work only works because of some deep
;; hypothesis about the way the completion work.  Basically, it makes
;; it pretty much impossible to have completion other than
;; prefix-completion.
;;
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
;; pcomplete--common-suffix and completion-table-subvert try to work around
;; this difficulty with heuristics, but it's really a hack.

(defvar pcomplete-unquote-argument-function #'comint--unquote-argument)

(defsubst pcomplete-unquote-argument (s)
  (funcall pcomplete-unquote-argument-function s))

(defvar pcomplete-requote-argument-function #'comint--requote-argument)

(defun pcomplete--common-suffix (s1 s2)
  ;; Since S2 is expected to be the "unquoted/expanded" version of S1,
  ;; there shouldn't be any case difference, even if the completion is
  ;; case-insensitive.
  (let ((case-fold-search nil))
    (string-match
     ;; \x3FFF7F is just an arbitrary char among the ones Emacs accepts
     ;; that hopefully will never appear in normal text.
     "\\(?:.\\|\n\\)*?\\(\\(?:.\\|\n\\)*\\)\x3FFF7F\\(?:.\\|\n\\)*\\1\\'"
     (concat s1 "\x3FFF7F" s2))
    (- (match-end 1) (match-beginning 1))))

380
(defun pcomplete-completions-at-point ()
381 382
  "Provide standard completion using pcomplete's completion tables.
Same as `pcomplete' but using the standard completion UI."
383 384
  ;; FIXME: it only completes the text before point, whereas the
  ;; standard UI may also consider text after point.
385 386 387
  ;; FIXME: the `pcomplete' UI may be used internally during
  ;; pcomplete-completions and then throw to `pcompleted', thus
  ;; imposing the pcomplete UI over the standard UI.
388 389 390 391 392 393 394 395 396 397 398 399
  (catch 'pcompleted
    (let* ((pcomplete-stub)
           pcomplete-seen pcomplete-norm-func
           pcomplete-args pcomplete-last pcomplete-index
           (pcomplete-autolist pcomplete-autolist)
           (pcomplete-suffix-list pcomplete-suffix-list)
           ;; Apparently the vars above are global vars modified by
           ;; side-effects, whereas pcomplete-completions is the core
           ;; function that finds the chunk of text to complete
           ;; (returned indirectly in pcomplete-stub) and the set of
           ;; possible completions.
           (completions (pcomplete-completions))
400 401 402 403 404
           ;; Usually there's some close connection between pcomplete-stub
           ;; and the text before point.  But depending on what
           ;; pcomplete-parse-arguments-function does, that connection
           ;; might not be that close.  E.g. in eshell,
           ;; pcomplete-parse-arguments-function expands envvars.
405
           ;;
406 407 408 409
           ;; Since we use minibuffer-complete, which doesn't know
           ;; pcomplete-stub and works from the buffer's text instead,
           ;; we need to trick minibuffer-complete, into using
           ;; pcomplete-stub without its knowledge.  To that end, we
410
           ;; use completion-table-subvert to construct a completion
411 412 413 414
           ;; table which expects strings using a prefix from the
           ;; buffer's text but internally uses the corresponding
           ;; prefix from pcomplete-stub.
           (beg (max (- (point) (length pcomplete-stub))
415
                     (pcomplete-begin)))
416 417
           (buftext (pcomplete-unquote-argument
                     (buffer-substring beg (point)))))
418 419
      (when completions
        (let ((table
420 421 422 423 424 425 426
               (completion-table-with-quoting
                (if (equal pcomplete-stub buftext)
                    completions
                  ;; This may not always be strictly right, but given the lack
                  ;; of any other info, it's about as good as it gets, and in
                  ;; practice it should work just fine (fingers crossed).
                  (let ((suf-len (pcomplete--common-suffix
427
                                  pcomplete-stub buftext)))
428 429 430 431 432 433 434
                    (completion-table-subvert
                     completions
                     (substring buftext 0 (- (length buftext) suf-len))
                     (substring pcomplete-stub 0
                                (- (length pcomplete-stub) suf-len)))))
                pcomplete-unquote-argument-function
                pcomplete-requote-argument-function))
435 436 437
              (pred
               ;; Pare it down, if applicable.
               (when (and pcomplete-use-paring pcomplete-seen)
438 439
                 ;; Capture the dynbound values for later use.
                 (let ((norm-func pcomplete-norm-func)
440 441 442 443 444
                       (seen
			(mapcar (lambda (f)
				  (funcall pcomplete-norm-func
					   (directory-file-name f)))
				pcomplete-seen)))
445 446 447 448
                   (lambda (f)
                     (not (member
                           (funcall norm-func (directory-file-name f))
                           seen)))))))
449
          (when pcomplete-ignore-case
450
            (setq table (completion-table-case-fold table)))
451 452 453
          (list beg (point) table
                :predicate pred
                :exit-function
454 455 456
		;; If completion is finished, add a terminating space.
		;; We used to also do this if STATUS is `sole', but
		;; that does not work right when completion cycling.
457
                (unless (zerop (length pcomplete-termination-string))
458 459
                  (lambda (_s status)
                    (when (eq status 'finished)
460 461 462 463
                      (if (looking-at
                           (regexp-quote pcomplete-termination-string))
                          (goto-char (match-end 0))
                        (insert pcomplete-termination-string)))))))))))
464 465 466 467 468

 ;; I don't think such commands are usable before first setting up buffer-local
 ;; variables to parse args, so there's no point autoloading it.
 ;; ;;;###autoload
(defun pcomplete-std-complete ()
469
  (let ((data (pcomplete-completions-at-point)))
470 471
    (completion-in-region (nth 0 data) (nth 1 data) (nth 2 data)
                          (plist-get :predicate (nthcdr 3 data)))))
472

473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
;;; Pcomplete's native UI.

;;;###autoload
(defun pcomplete (&optional interactively)
  "Support extensible programmable completion.
To use this function, just bind the TAB key to it, or add it to your
completion functions list (it should occur fairly early in the list)."
  (interactive "p")
  (if (and interactively
	   pcomplete-cycle-completions
	   pcomplete-current-completions
	   (memq last-command '(pcomplete
				pcomplete-expand-and-complete
				pcomplete-reverse)))
      (progn
488
	(delete-char (- pcomplete-last-completion-length))
489 490
	(if (eq this-command 'pcomplete-reverse)
	    (progn
491 492
              (push (car (last pcomplete-current-completions))
                    pcomplete-current-completions)
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	      (setcdr (last pcomplete-current-completions 2) nil))
	  (nconc pcomplete-current-completions
		 (list (car pcomplete-current-completions)))
	  (setq pcomplete-current-completions
		(cdr pcomplete-current-completions)))
	(pcomplete-insert-entry pcomplete-last-completion-stub
                                (car pcomplete-current-completions)
				nil pcomplete-last-completion-raw))
    (setq pcomplete-current-completions nil
	  pcomplete-last-completion-raw nil)
    (catch 'pcompleted
      (let* ((pcomplete-stub)
	     pcomplete-seen pcomplete-norm-func
	     pcomplete-args pcomplete-last pcomplete-index
	     (pcomplete-autolist pcomplete-autolist)
	     (pcomplete-suffix-list pcomplete-suffix-list)
	     (completions (pcomplete-completions))
	     (result (pcomplete-do-complete pcomplete-stub completions)))
	(and result
	     (not (eq (car result) 'listed))
	     (cdr result)
	     (pcomplete-insert-entry pcomplete-stub (cdr result)
				     (memq (car result)
					   '(sole shortest))
				     pcomplete-last-completion-raw))))))

Gerd Moellmann's avatar
Gerd Moellmann committed
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
;;;###autoload
(defun pcomplete-reverse ()
  "If cycling completion is in use, cycle backwards."
  (interactive)
  (call-interactively 'pcomplete))

;;;###autoload
(defun pcomplete-expand-and-complete ()
  "Expand the textual value of the current argument.
This will modify the current buffer."
  (interactive)
  (let ((pcomplete-expand-before-complete t))
    (pcomplete)))

;;;###autoload
(defun pcomplete-continue ()
  "Complete without reference to any cycling completions."
  (interactive)
  (setq pcomplete-current-completions nil
	pcomplete-last-completion-raw nil)
  (call-interactively 'pcomplete))

;;;###autoload
(defun pcomplete-expand ()
  "Expand the textual value of the current argument.
This will modify the current buffer."
  (interactive)
  (let ((pcomplete-expand-before-complete t)
	(pcomplete-expand-only-p t))
    (pcomplete)
    (when (and pcomplete-current-completions
550
	       (> (length pcomplete-current-completions) 0)) ;??
551
      (delete-char (- pcomplete-last-completion-length))
Gerd Moellmann's avatar
Gerd Moellmann committed
552 553 554
      (while pcomplete-current-completions
	(unless (pcomplete-insert-entry
		 "" (car pcomplete-current-completions) t
555
                 pcomplete-last-completion-raw)
556
	  (insert-and-inherit pcomplete-termination-string))
Gerd Moellmann's avatar
Gerd Moellmann committed
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
	(setq pcomplete-current-completions
	      (cdr pcomplete-current-completions))))))

;;;###autoload
(defun pcomplete-help ()
  "Display any help information relative to the current argument."
  (interactive)
  (let ((pcomplete-show-help t))
    (pcomplete)))

;;;###autoload
(defun pcomplete-list ()
  "Show the list of possible completions for the current argument."
  (interactive)
  (when (and pcomplete-cycle-completions
	     pcomplete-current-completions
	     (eq last-command 'pcomplete-argument))
574
    (delete-char (- pcomplete-last-completion-length))
Gerd Moellmann's avatar
Gerd Moellmann committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
    (setq pcomplete-current-completions nil
	  pcomplete-last-completion-raw nil))
  (let ((pcomplete-show-list t))
    (pcomplete)))

;;; Internal Functions:

;; argument handling
(defun pcomplete-arg (&optional index offset)
  "Return the textual content of the INDEXth argument.
INDEX is based from the current processing position.  If INDEX is
positive, values returned are closer to the command argument; if
negative, they are closer to the last argument.  If the INDEX is
outside of the argument list, nil is returned.  The default value for
INDEX is 0, meaning the current argument being examined.

The special indices `first' and `last' may be used to access those
parts of the list.

The OFFSET argument is added to/taken away from the index that will be
used.  This is really only useful with `first' and `last', for
accessing absolute argument positions."
  (setq index
	(if (eq index 'first)
	    0
	  (if (eq index 'last)
	      pcomplete-last
	    (- pcomplete-index (or index 0)))))
  (if offset
      (setq index (+ index offset)))
  (nth index pcomplete-args))

(defun pcomplete-begin (&optional index offset)
  "Return the beginning position of the INDEXth argument.
See the documentation for `pcomplete-arg'."
  (setq index
	(if (eq index 'first)
	    0
	  (if (eq index 'last)
	      pcomplete-last
	    (- pcomplete-index (or index 0)))))
  (if offset
      (setq index (+ index offset)))
  (nth index pcomplete-begins))

(defsubst pcomplete-actual-arg (&optional index offset)
  "Return the actual text representation of the last argument.
622
This is different from `pcomplete-arg', which returns the textual value
Gerd Moellmann's avatar
Gerd Moellmann committed
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647
that the last argument evaluated to.  This function returns what the
user actually typed in."
  (buffer-substring (pcomplete-begin index offset) (point)))

(defsubst pcomplete-next-arg ()
  "Move the various pointers to the next argument."
  (setq pcomplete-index (1+ pcomplete-index)
	pcomplete-stub (pcomplete-arg))
  (if (> pcomplete-index pcomplete-last)
      (progn
	(message "No completions")
	(throw 'pcompleted nil))))

(defun pcomplete-command-name ()
  "Return the command name of the first argument."
  (file-name-nondirectory (pcomplete-arg 'first)))

(defun pcomplete-match (regexp &optional index offset start)
  "Like `string-match', but on the current completion argument."
  (let ((arg (pcomplete-arg (or index 1) offset)))
    (if arg
	(string-match regexp arg start)
      (throw 'pcompleted nil))))

(defun pcomplete-match-string (which &optional index offset)
648
  "Like `match-string', but on the current completion argument."
Gerd Moellmann's avatar
Gerd Moellmann committed
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
  (let ((arg (pcomplete-arg (or index 1) offset)))
    (if arg
	(match-string which arg)
      (throw 'pcompleted nil))))

(defalias 'pcomplete-match-beginning 'match-beginning)
(defalias 'pcomplete-match-end 'match-end)

(defsubst pcomplete--test (pred arg)
  "Perform a programmable completion predicate match."
  (and pred
       (cond ((eq pred t) t)
	     ((functionp pred)
	      (funcall pred arg))
	     ((stringp pred)
	      (string-match (concat "^" pred "$") arg)))
       pred))

(defun pcomplete-test (predicates &optional index offset)
  "Predicates to test the current programmable argument with."
  (let ((arg (pcomplete-arg (or index 1) offset)))
    (unless (null predicates)
      (if (not (listp predicates))
	  (pcomplete--test predicates arg)
	(let ((pred predicates)
	      found)
	  (while (and pred (not found))
	    (setq found (pcomplete--test (car pred) arg)
		  pred (cdr pred)))
	  found)))))

(defun pcomplete-parse-buffer-arguments ()
  "Parse whitespace separated arguments in the current region."
  (let ((begin (point-min))
	(end (point-max))
	begins args)
    (save-excursion
      (goto-char begin)
      (while (< (point) end)
	(skip-chars-forward " \t\n")
689
	(push (point) begins)
Gerd Moellmann's avatar
Gerd Moellmann committed
690
	(skip-chars-forward "^ \t\n")
691 692 693 694
	(push (buffer-substring-no-properties
               (car begins) (point))
              args))
      (cons (nreverse args) (nreverse begins)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
695 696 697 698 699

;;;###autoload
(defun pcomplete-comint-setup (completef-sym)
  "Setup a comint buffer to use pcomplete.
COMPLETEF-SYM should be the symbol where the
700 701
dynamic-complete-functions are kept.  For comint mode itself,
this is `comint-dynamic-complete-functions'."
Gerd Moellmann's avatar
Gerd Moellmann committed
702 703
  (set (make-local-variable 'pcomplete-parse-arguments-function)
       'pcomplete-parse-comint-arguments)
704 705
  (add-hook 'completion-at-point-functions
            'pcomplete-completions-at-point nil 'local)
706 707
  (set (make-local-variable completef-sym)
       (copy-sequence (symbol-value completef-sym)))
708
  (let* ((funs (symbol-value completef-sym))
709 710 711
	 (elem (or (memq 'comint-filename-completion funs)
                   (memq 'shell-filename-completion funs)
                   (memq 'shell-dynamic-complete-filename funs)
712
		   (memq 'comint-dynamic-complete-filename funs))))
Gerd Moellmann's avatar
Gerd Moellmann committed
713 714
    (if elem
	(setcar elem 'pcomplete)
715
      (add-to-list completef-sym 'pcomplete))))
Gerd Moellmann's avatar
Gerd Moellmann committed
716 717 718

;;;###autoload
(defun pcomplete-shell-setup ()
719
  "Setup `shell-mode' to use pcomplete."
720
  ;; FIXME: insufficient
721
  (pcomplete-comint-setup 'comint-dynamic-complete-functions))
Gerd Moellmann's avatar
Gerd Moellmann committed
722

723 724
(declare-function comint-bol "comint" (&optional arg))

Gerd Moellmann's avatar
Gerd Moellmann committed
725 726
(defun pcomplete-parse-comint-arguments ()
  "Parse whitespace separated arguments in the current region."
727
  (declare (obsolete comint-parse-pcomplete-arguments "24.1"))
Gerd Moellmann's avatar
Gerd Moellmann committed
728 729 730 731 732 733 734
  (let ((begin (save-excursion (comint-bol nil) (point)))
	(end (point))
	begins args)
    (save-excursion
      (goto-char begin)
      (while (< (point) end)
	(skip-chars-forward " \t\n")
735
	(push (point) begins)
736 737 738 739 740 741 742 743
        (while
            (progn
              (skip-chars-forward "^ \t\n\\")
              (when (eq (char-after) ?\\)
                (forward-char 1)
                (unless (eolp)
                  (forward-char 1)
                  t))))
744 745 746
	(push (buffer-substring-no-properties (car begins) (point))
              args))
      (cons (nreverse args) (nreverse begins)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
747 748 749 750 751 752 753 754 755 756 757

(defun pcomplete-parse-arguments (&optional expand-p)
  "Parse the command line arguments.  Most completions need this info."
  (let ((results (funcall pcomplete-parse-arguments-function)))
    (when results
      (setq pcomplete-args (or (car results) (list ""))
	    pcomplete-begins (or (cdr results) (list (point)))
	    pcomplete-last (1- (length pcomplete-args))
	    pcomplete-index 0
	    pcomplete-stub (pcomplete-arg 'last))
      (let ((begin (pcomplete-begin 'last)))
758
	(if (and (listp pcomplete-stub) ;??
Gerd Moellmann's avatar
Gerd Moellmann committed
759
		 (not pcomplete-expand-only-p))
760
	    (let* ((completions pcomplete-stub) ;??
Gerd Moellmann's avatar
Gerd Moellmann committed
761 762 763 764 765 766 767 768 769 770 771 772 773 774
		   (common-stub (car completions))
		   (c completions)
		   (len (length common-stub)))
	      (while (and c (> len 0))
		(while (and (> len 0)
			    (not (string=
				  (substring common-stub 0 len)
				  (substring (car c) 0
					     (min (length (car c))
						  len)))))
		  (setq len (1- len)))
		(setq c (cdr c)))
	      (setq pcomplete-stub (substring common-stub 0 len)
		    pcomplete-autolist t)
775
	      (when (and begin (> len 0) (not pcomplete-show-list))
Gerd Moellmann's avatar
Gerd Moellmann committed
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
		(delete-region begin (point))
		(pcomplete-insert-entry "" pcomplete-stub))
	      (throw 'pcomplete-completions completions))
	  (when expand-p
	    (if (stringp pcomplete-stub)
		(when begin
		  (delete-region begin (point))
		  (insert-and-inherit pcomplete-stub))
	      (if (and (listp pcomplete-stub)
		       pcomplete-expand-only-p)
		  ;; this is for the benefit of `pcomplete-expand'
		  (setq pcomplete-last-completion-length (- (point) begin)
			pcomplete-current-completions pcomplete-stub)
		(error "Cannot expand argument"))))
	  (if pcomplete-expand-only-p
	      (throw 'pcompleted t)
	    pcomplete-args))))))

794
(define-obsolete-function-alias
795
  'pcomplete-quote-argument #'comint-quote-filename "24.3")
Gerd Moellmann's avatar
Gerd Moellmann committed
796 797 798 799 800

;; file-system completion lists

(defsubst pcomplete-dirs-or-entries (&optional regexp predicate)
  "Return either directories, or qualified entries."
801 802
  (pcomplete-entries
   nil
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
   (lambda (f)
     (or (file-directory-p f)
         (and (or (null regexp) (string-match regexp f))
              (or (null predicate) (funcall predicate f)))))))

(defun pcomplete--entries (&optional regexp predicate)
  "Like `pcomplete-entries' but without env-var handling."
  (let* ((ign-pred
          (when (or pcomplete-file-ignore pcomplete-dir-ignore)
            ;; Capture the dynbound value for later use.
            (let ((file-ignore pcomplete-file-ignore)
                  (dir-ignore pcomplete-dir-ignore))
              (lambda (file)
                (not
                 (if (eq (aref file (1- (length file))) ?/)
                     (and dir-ignore (string-match dir-ignore file))
                   (and file-ignore (string-match file-ignore file))))))))
         (reg-pred (if regexp (lambda (file) (string-match regexp file))))
         (pred (cond
                ((null (or ign-pred reg-pred))  predicate)
                ((null (or ign-pred predicate)) reg-pred)
                ((null (or reg-pred predicate)) ign-pred)
                (t (lambda (f)
                     (and (or (null reg-pred)  (funcall reg-pred f))
                          (or (null ign-pred)  (funcall ign-pred f))
                          (or (null predicate) (funcall predicate f))))))))
    (lambda (s p a)
      (if (and (eq a 'metadata) pcomplete-compare-entry-function)
          `(metadata (cycle-sort-function
                      . ,(lambda (comps)
                           (sort comps pcomplete-compare-entry-function)))
                     ,@(cdr (completion-file-name-table s p a)))
835 836
        (let ((completion-ignored-extensions nil)
	      (completion-ignore-case pcomplete-ignore-case))
837
          (completion-table-with-predicate
838
           #'comint-completion-file-name-table pred 'strict s p a))))))
839 840 841

(defconst pcomplete--env-regexp
  "\\(?:\\`\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(\\$\\(?:{\\([^}]+\\)}\\|\\(?2:[[:alnum:]_]+\\)\\)\\)")
Gerd Moellmann's avatar
Gerd Moellmann committed
842 843 844 845 846 847 848

(defun pcomplete-entries (&optional regexp predicate)
  "Complete against a list of directory candidates.
If REGEXP is non-nil, it is a regular expression used to refine the
match (files not matching the REGEXP will be excluded).
If PREDICATE is non-nil, it will also be used to refine the match
\(files for which the PREDICATE returns nil will be excluded).
849
If no directory information can be extracted from the completed
850
component, `default-directory' is used as the basis for completion."
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
  ;; FIXME: The old code did env-var expansion here, so we reproduce this
  ;; behavior for now, but really env-var handling should be performed globally
  ;; rather than here since it also applies to non-file arguments.
  (let ((table (pcomplete--entries regexp predicate)))
    (lambda (string pred action)
      (let ((strings nil)
            (orig-length (length string)))
        ;; Perform env-var expansion.
        (while (string-match pcomplete--env-regexp string)
          (push (substring string 0 (match-beginning 1)) strings)
          (push (getenv (match-string 2 string)) strings)
          (setq string (substring string (match-end 1))))
        (if (not (and strings
                      (or (eq action t)
                          (eq (car-safe action) 'boundaries))))
            (let ((newstring
                   (mapconcat 'identity (nreverse (cons string strings)) "")))
              ;; FIXME: We could also try to return unexpanded envvars.
              (complete-with-action action table newstring pred))
          (let* ((envpos (apply #'+ (mapcar #' length strings)))
                 (newstring
                  (mapconcat 'identity (nreverse (cons string strings)) ""))
                 (bounds (completion-boundaries newstring table pred
                                                (or (cdr-safe action) ""))))
            (if (>= (car bounds) envpos)
                ;; The env-var is "out of bounds".
                (if (eq action t)
                    (complete-with-action action table newstring pred)
Stefan Monnier's avatar
Stefan Monnier committed
879 880 881
                  `(boundaries
                    ,(+ (car bounds) (- orig-length (length newstring)))
                    . ,(cdr bounds)))
882 883 884 885 886 887 888 889
              ;; The env-var is in the file bounds.
              (if (eq action t)
                  (let ((comps (complete-with-action
                                action table newstring pred))
                        (len (- envpos (car bounds))))
                    ;; Strip the part of each completion that's actually
                    ;; coming from the env-var.
                    (mapcar (lambda (s) (substring s len)) comps))
Stefan Monnier's avatar
Stefan Monnier committed
890 891 892
                `(boundaries
                  ,(+ envpos (- orig-length (length newstring)))
                  . ,(cdr bounds))))))))))
Gerd Moellmann's avatar
Gerd Moellmann committed
893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926

(defsubst pcomplete-all-entries (&optional regexp predicate)
  "Like `pcomplete-entries', but doesn't ignore any entries."
  (let (pcomplete-file-ignore
	pcomplete-dir-ignore)
    (pcomplete-entries regexp predicate)))

(defsubst pcomplete-dirs (&optional regexp)
  "Complete amongst a list of directories."
  (pcomplete-entries regexp 'file-directory-p))

;; generation of completion lists

(defun pcomplete-find-completion-function (command)
  "Find the completion function to call for the given COMMAND."
  (let ((sym (intern-soft
	      (concat "pcomplete/" (symbol-name major-mode) "/" command))))
    (unless sym
      (setq sym (intern-soft (concat "pcomplete/" command))))
    (and sym (fboundp sym) sym)))

(defun pcomplete-completions ()
  "Return a list of completions for the current argument position."
  (catch 'pcomplete-completions
    (when (pcomplete-parse-arguments pcomplete-expand-before-complete)
      (if (= pcomplete-index pcomplete-last)
	  (funcall pcomplete-command-completion-function)
	(let ((sym (or (pcomplete-find-completion-function
			(funcall pcomplete-command-name-function))
		       pcomplete-default-completion-function)))
	  (ignore
	   (pcomplete-next-arg)
	   (funcall sym)))))))

927
(defun pcomplete-opt (options &optional prefix _no-ganging _args-follow)
Gerd Moellmann's avatar
Gerd Moellmann committed
928 929
  "Complete a set of OPTIONS, each beginning with PREFIX (?- by default).
PREFIX may be t, in which case no PREFIX character is necessary.
930 931 932
If NO-GANGING is non-nil, each option is separate (-xy is not allowed).
If ARGS-FOLLOW is non-nil, then options which take arguments may have
the argument appear after a ganged set of options.  This is how tar
933 934
behaves, for example.
Arguments NO-GANGING and ARGS-FOLLOW are currently ignored."
Gerd Moellmann's avatar
Gerd Moellmann committed
935 936 937 938 939 940 941 942 943 944 945
  (if (and (= pcomplete-index pcomplete-last)
	   (string= (pcomplete-arg) "-"))
      (let ((len (length options))
	    (index 0)
	    char choices)
	(while (< index len)
	  (setq char (aref options index))
	  (if (eq char ?\()
	      (let ((result (read-from-string options index)))
		(setq index (cdr result)))
	    (unless (memq char '(?/ ?* ?? ?.))
946
	      (push (char-to-string char) choices))
Gerd Moellmann's avatar
Gerd Moellmann committed
947 948 949 950 951 952
	    (setq index (1+ index))))
	(throw 'pcomplete-completions
	       (mapcar
		(function
		 (lambda (opt)
		   (concat "-" opt)))
Paul Eggert's avatar
Paul Eggert committed
953
		(pcomplete-uniquify-list choices))))
Gerd Moellmann's avatar
Gerd Moellmann committed
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
    (let ((arg (pcomplete-arg)))
      (when (and (> (length arg) 1)
		 (stringp arg)
		 (eq (aref arg 0) (or prefix ?-)))
	(pcomplete-next-arg)
	(let ((char (aref arg 1))
	      (len (length options))
	      (index 0)
	      opt-char arg-char result)
	  (while (< (1+ index) len)
	    (setq opt-char (aref options index)
		  arg-char (aref options (1+ index)))
	    (if (eq arg-char ?\()
		(setq result
		      (read-from-string options (1+ index))
		      index (cdr result)
		      result (car result))
	      (setq result nil))
	    (when (and (eq char opt-char)
		       (memq arg-char '(?\( ?/ ?* ?? ?.)))
	      (if (< pcomplete-index pcomplete-last)
		  (pcomplete-next-arg)
		(throw 'pcomplete-completions
		       (cond ((eq arg-char ?/) (pcomplete-dirs))
			     ((eq arg-char ?*) (pcomplete-executables))
			     ((eq arg-char ??) nil)
			     ((eq arg-char ?.) (pcomplete-entries))
			     ((eq arg-char ?\() (eval result))))))
	    (setq index (1+ index))))))))

(defun pcomplete--here (&optional form stub paring form-only)
985
  "Complete against the current argument, if at the end.
Gerd Moellmann's avatar
Gerd Moellmann committed
986 987 988 989 990 991 992
See the documentation for `pcomplete-here'."
  (if (< pcomplete-index pcomplete-last)
      (progn
	(if (eq paring 0)
	    (setq pcomplete-seen nil)
	  (unless (eq paring t)
	    (let ((arg (pcomplete-arg)))
993
	      (when (stringp arg)
994 995 996 997
                (push (if paring
                          (funcall paring arg)
                        (file-truename arg))
                      pcomplete-seen)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
	(pcomplete-next-arg)
	t)
    (when pcomplete-show-help
      (pcomplete--help)
      (throw 'pcompleted t))
    (if stub
	(setq pcomplete-stub stub))
    (if (or (eq paring t) (eq paring 0))
	(setq pcomplete-seen nil)
      (setq pcomplete-norm-func (or paring 'file-truename)))
    (unless form-only
      (run-hooks 'pcomplete-try-first-hook))
1010 1011 1012 1013 1014 1015
    (throw 'pcomplete-completions
           (if (functionp form)
               (funcall form)
             ;; Old calling convention, might still be used by files
             ;; byte-compiled with the older code.
             (eval form)))))
Gerd Moellmann's avatar
Gerd Moellmann committed
1016 1017

(defmacro pcomplete-here (&optional form stub paring form-only)
1018
  "Complete against the current argument, if at the end.
1019 1020
If completion is to be done here, evaluate FORM to generate the completion
table which will be used for completion purposes.  If STUB is a
Gerd Moellmann's avatar
Gerd Moellmann committed
1021 1022 1023 1024
string, use it as the completion stub instead of the default (which is
the entire text of the current argument).

For an example of when you might want to use STUB: if the current
1025 1026
argument text is `long-path-name/', you don't want the completions
list display to be cluttered by `long-path-name/' appearing at the
Gerd Moellmann's avatar
Gerd Moellmann committed
1027
beginning of every alternative.  Not only does this make things less
1028
intelligible, but it is also inefficient.  Yet, if the completion list
Gerd Moellmann's avatar
Gerd Moellmann committed
1029 1030 1031 1032 1033 1034 1035 1036 1037
does not begin with this string for every entry, the current argument
won't complete correctly.

The solution is to specify a relative stub.  It allows you to
substitute a different argument from the current argument, almost
always for the sake of efficiency.

If PARING is nil, this argument will be pared against previous
arguments using the function `file-truename' to normalize them.
1038 1039 1040 1041 1042
PARING may be a function, in which case that function is used for
normalization.  If PARING is t, the argument dealt with by this
call will not participate in argument paring.  If it is the
integer 0, all previous arguments that have been seen will be
cleared.
Gerd Moellmann's avatar
Gerd Moellmann committed
1043 1044 1045 1046

If FORM-ONLY is non-nil, only the result of FORM will be used to
generate the completions list.  This means that the hook
`pcomplete-try-first-hook' will not be run."
1047 1048 1049
  (declare (debug t))
  `(pcomplete--here (lambda () ,form) ,stub ,paring ,form-only))

Gerd Moellmann's avatar
Gerd Moellmann committed
1050 1051 1052

(defmacro pcomplete-here* (&optional form stub form-only)
  "An alternate form which does not participate in argument paring."
1053
  (declare (debug t))
1054
  `(pcomplete-here ,form ,stub t ,form-only))
Gerd Moellmann's avatar
Gerd Moellmann committed
1055 1056 1057 1058 1059 1060 1061 1062

;; display support

(defun pcomplete-restore-windows ()
  "If the only window change was due to Completions, restore things."
  (if pcomplete-last-window-config
      (let* ((cbuf (get-buffer "*Completions*"))
	     (cwin (and cbuf (get-buffer-window cbuf))))
1063
	(when (window-live-p cwin)
Gerd Moellmann's avatar
Gerd Moellmann committed
1064 1065 1066 1067 1068 1069 1070 1071
	  (bury-buffer cbuf)
	  (set-window-configuration pcomplete-last-window-config))))
  (setq pcomplete-last-window-config nil
	pcomplete-window-restore-timer nil))

;; Abstractions so that the code below will work for both Emacs 20 and
;; XEmacs 21

1072 1073 1074 1075
(defalias 'pcomplete-event-matches-key-specifier-p
  (if (featurep 'xemacs)
      'event-matches-key-specifier-p
  'eq))
Gerd Moellmann's avatar
Gerd Moellmann committed
1076

1077 1078 1079
(defun pcomplete-read-event (&optional prompt)
  (if (fboundp 'read-event)
      (read-event prompt)
Gerd Moellmann's avatar
Gerd Moellmann committed
1080 1081 1082 1083 1084
    (aref (read-key-sequence prompt) 0)))

(defun pcomplete-show-completions (completions)
  "List in help buffer sorted COMPLETIONS.
Typing SPC flushes the help buffer."
1085 1086 1087 1088 1089 1090 1091
  (when pcomplete-window-restore-timer
    (cancel-timer pcomplete-window-restore-timer)
    (setq pcomplete-window-restore-timer nil))
  (unless pcomplete-last-window-config
    (setq pcomplete-last-window-config (current-window-configuration)))
  (with-output-to-temp-buffer "*Completions*"
    (display-completion-list completions))
1092
  (minibuffer-message "Hit space to flush")
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
  (let (event)
    (prog1
        (catch 'done
          (while (with-current-buffer (get-buffer "*Completions*")
                   (setq event (pcomplete-read-event)))
            (cond
             ((pcomplete-event-matches-key-specifier-p event ?\s)
              (set-window-configuration pcomplete-last-window-config)
              (setq pcomplete-last-window-config nil)
              (throw 'done nil))
             ((or (pcomplete-event-matches-key-specifier-p event 'tab)
                  ;; Needed on a terminal
                  (pcomplete-event-matches-key-specifier-p event 9))
              (let ((win (or (get-buffer-window "*Completions*" 0)
                             (display-buffer "*Completions*"
                                             'not-this-window))))
                (with-selected-window win
                  (if (pos-visible-in-window-p (point-max))
                      (goto-char (point-min))
                    (scroll-up))))
              (message ""))
             (t
1115
              (push event unread-command-events)
1116 1117 1118 1119 1120 1121
              (throw 'done nil)))))
      (if (and pcomplete-last-window-config
               pcomplete-restore-window-delay)
          (setq pcomplete-window-restore-timer
                (run-with-timer pcomplete-restore-window-delay nil
                                'pcomplete-restore-windows))))))
Gerd Moellmann's avatar
Gerd Moellmann committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131

;; insert completion at point

(defun pcomplete-insert-entry (stub entry &optional addsuffix raw-p)
  "Insert a completion entry at point.
Returns non-nil if a space was appended at the end."
  (let ((here (point)))
    (if (not pcomplete-ignore-case)
	(insert-and-inherit (if raw-p
				(substring entry (length stub))
1132
			      (comint-quote-filename
Gerd Moellmann's avatar
Gerd Moellmann committed
1133 1134 1135
			       (substring entry (length stub)))))
      ;; the stub is not quoted at this time, so to determine the
      ;; length of what should be in the buffer, we must quote it
1136 1137 1138
      ;; FIXME: Here we presume that quoting `stub' gives us the exact
      ;; text in the buffer before point, which is not guaranteed;
      ;; e.g. it is not the case in eshell when completing ${FOO}tm[TAB].
1139
      (delete-char (- (length (comint-quote-filename stub))))
Gerd Moellmann's avatar
Gerd Moellmann committed
1140 1141 1142 1143 1144 1145 1146
      ;; if there is already a backslash present to handle the first
      ;; character, don't bother quoting it
      (when (eq (char-before) ?\\)
	(insert-and-inherit (substring entry 0 1))
	(setq entry (substring entry 1)))
      (insert-and-inherit (if raw-p
			      entry
1147
			    (comint-quote-filename entry))))
Gerd Moellmann's avatar
Gerd Moellmann committed
1148 1149 1150
    (let (space-added)
      (when (and (not (memq (char-before) pcomplete-suffix-list))
		 addsuffix)
1151
	(insert-and-inherit pcomplete-termination-string)
Gerd Moellmann's avatar
Gerd Moellmann committed
1152 1153 1154 1155 1156
	(setq space-added t))
      (setq pcomplete-last-completion-length (- (point) here)
	    pcomplete-last-completion-stub stub)
      space-added)))

1157
;; Selection of completions.
Gerd Moellmann's avatar
Gerd Moellmann committed
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171

(defun pcomplete-do-complete (stub completions)
  "Dynamically complete at point using STUB and COMPLETIONS.
This is basically just a wrapper for `pcomplete-stub' which does some
extra checking, and munging of the COMPLETIONS list."
  (unless (stringp stub)
    (message "Cannot complete argument")
    (throw 'pcompleted nil))
  (if (null completions)
      (ignore
       (if (and stub (> (length stub) 0))
	   (message "No completions of %s" stub)
	 (message "No completions")))
    ;; pare it down, if applicable
1172 1173 1174 1175 1176 1177 1178 1179 1180
    (when (and pcomplete-use-paring pcomplete-seen)
      (setq pcomplete-seen
            (mapcar 'directory-file-name pcomplete-seen))
      (dolist (p pcomplete-seen)
        (add-to-list 'pcomplete-seen
                     (funcall pcomplete-norm-func p)))
      (setq completions
            (apply-partially 'completion-table-with-predicate
                             completions
1181 1182 1183 1184 1185 1186
                             (when pcomplete-seen
                               (lambda (f)
                                 (not (member
                                       (funcall pcomplete-norm-func
                                                (directory-file-name f))
                                       pcomplete-seen))))
1187
                             'strict)))
Gerd Moellmann's avatar
Gerd Moellmann committed
1188 1189
    ;; OK, we've got a list of completions.
    (if pcomplete-show-list
1190 1191
        ;; FIXME: pay attention to boundaries.
	(pcomplete-show-completions (all-completions stub completions))
Gerd Moellmann's avatar
Gerd Moellmann committed
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
      (pcomplete-stub stub completions))))

(defun pcomplete-stub (stub candidates &optional cycle-p)
  "Dynamically complete STUB from CANDIDATES list.
This function inserts completion characters at point by completing
STUB from the strings in CANDIDATES.  A completions listing may be
shown in a help buffer if completion is ambiguous.

Returns nil if no completion was inserted.
Returns `sole' if completed with the only completion match.
Returns `shortest' if completed with the shortest of the matches.
Returns `partial' if completed as far as possible with the matches.
Returns `listed' if a completion listing was shown.

See also `pcomplete-filename'."
  (let* ((completion-ignore-case pcomplete-ignore-case)
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
	 (completions (all-completions stub candidates))
         (entry (try-completion stub candidates))
         result)
    (cond
     ((null entry)
      (if (and stub (> (length stub) 0))
          (message "No completions of %s" stub)
        (message "No completions")))
     ((eq entry t)
      (setq entry stub)
      (message "Sole completion")
      (setq result 'sole))
     ((= 1 (length completions))
      (setq result 'sole))
     ((and pcomplete-cycle-completions
           (or cycle-p
               (not pcomplete-cycle-cutoff-length)
               (<= (length completions)
                   pcomplete-cycle-cutoff-length)))
      (let ((bound (car (completion-boundaries stub candidates nil ""))))
        (unless (zerop bound)
          (setq completions (mapcar (lambda (c) (concat (substring stub 0 bound) c))
                                    completions)))
        (setq entry (car completions)
              pcomplete-current-completions completions)))
     ((and pcomplete-recexact
           (string-equal stub entry)
           (member entry completions))
      ;; It's not unique, but user wants shortest match.
      (message "Completed shortest")
      (setq result 'shortest))
     ((or pcomplete-autolist
          (string-equal stub entry))
      ;; It's not unique, list possible completions.
      ;; FIXME: pay attention to boundaries.
      (pcomplete-show-completions completions)
      (setq result 'listed))
     (t
      (message "Partially completed")
      (setq result 'partial)))
    (cons result entry)))
Gerd Moellmann's avatar
Gerd Moellmann committed
1249 1250 1251 1252 1253

;; context sensitive help

(defun pcomplete--help ()
  "Produce context-sensitive help for the current argument.
1254
If specific documentation can't be given, be generic."
Gerd Moellmann's avatar
Gerd Moellmann committed
1255 1256 1257 1258 1259
  (if (and pcomplete-help
	   (or (and (stringp pcomplete-help)
		    (fboundp 'Info-goto-node))
	       (listp pcomplete-help)))
      (if (listp pcomplete-help)
Deepak Goel's avatar
Deepak Goel committed
1260
	  (message "%s" (eval pcomplete-help))
Gerd Moellmann's avatar
Gerd Moellmann committed
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	(save-window-excursion (info))
	(switch-to-buffer-other-window "*info*")
	(funcall (symbol-function 'Info-goto-node) pcomplete-help))
    (if pcomplete-man-function
	(let ((cmd (funcall pcomplete-command-name-function)))
	  (if (and cmd (> (length cmd) 0))
	      (funcall pcomplete-man-function cmd)))
      (message "No context-sensitive help available"))))

;; general utilities

Paul Eggert's avatar
Paul Eggert committed
1272
(defun pcomplete-uniquify-list (l)
Gerd Moellmann's avatar
Gerd Moellmann committed
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
  "Sort and remove multiples in L."
  (setq l (sort l 'string-lessp))
  (let ((m l))
    (while m
      (while (and (cdr m)
		  (string= (car m)
			   (cadr m)))
	(setcdr m (cddr m)))
      (setq m (cdr m))))
  l)
Paul Eggert's avatar
Paul Eggert committed
1283 1284 1285
(define-obsolete-function-alias
  'pcomplete-uniqify-list
  'pcomplete-uniquify-list "27.1")
Gerd Moellmann's avatar
Gerd Moellmann committed
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296

(defun pcomplete-process-result (cmd &rest args)
  "Call CMD using `call-process' and return the simplest result."
  (with-temp-buffer
    (apply 'call-process cmd nil t nil args)
    (skip-chars-backward "\n")
    (buffer-substring (point-min) (point))))

;; create a set of aliases which allow completion functions to be not
;; quite so verbose

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
;;; jww (1999-10-20): are these a good idea?
;; (defalias 'pc-here 'pcomplete-here)
;; (defalias 'pc-test 'pcomplete-test)
;; (defalias 'pc-opt 'pcomplete-opt)
;; (defalias 'pc-match 'pcomplete-match)
;; (defalias 'pc-match-string 'pcomplete-match-string)
;; (defalias 'pc-match-beginning 'pcomplete-match-beginning)
;; (defalias 'pc-match-end 'pcomplete-match-end)

(provide 'pcomplete)
Gerd Moellmann's avatar
Gerd Moellmann committed
1307 1308

;;; pcomplete.el ends here