lisp/pcomplete.el

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