lisp/filecache.el

   1 ;;; filecache.el --- Find files using a pre-loaded cache
   2 ;;
   3 ;; Author:  Peter Breton <pbreton@cs.umb.edu>
   4 ;; Created: Sun Nov 10 1996
   5 ;; Keywords: convenience
   6 ;; Time-stamp: <2000-08-28 16:18:03 pbreton>
   7 ;;
   8 ;; Copyright (C) 1996 Free Software Foundation, Inc.
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software; you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 2, or (at your option)
  15 ;; any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25 ;; Boston, MA 02111-1307, USA.
  26
  27 ;;; Commentary:
  28 ;;
  29 ;; The file-cache package is an attempt to make it easy to locate files
  30 ;; by name, without having to remember exactly where they are located.
  31 ;; This is very handy when working with source trees. You can also add
  32 ;; frequently used files to the cache to create a hotlist effect.
  33 ;; The cache can be used with any interactive command which takes a
  34 ;; filename as an argument.
  35 ;;
  36 ;; It is worth noting that this package works best when most of the files
  37 ;; in the cache have unique names, or (if they have the same name) exist in
  38 ;; only a few directories. The worst case is many files all with
  39 ;; the same name and in different directories, for example a big source tree
  40 ;; with a Makefile in each directory. In such a case, you should probably
  41 ;; use an alternate strategy to find the files.
  42 ;;
  43 ;; ADDING FILES TO THE CACHE:
  44 ;;
  45 ;; Use the following functions to add items to the file cache:
  46 ;;
  47 ;;   * `file-cache-add-file': Adds a single file to the cache
  48 ;;
  49 ;;   * `file-cache-add-file-list': Adds a list of files to the cache
  50 ;;
  51 ;; The following functions use the regular expressions in
  52 ;; `file-cache-delete-regexps' to eliminate unwanted files:
  53 ;;
  54 ;;   * `file-cache-add-directory': Adds the files in a directory to the
  55 ;;     cache. You can also specify a regular expression to match the files
  56 ;;     which should be added.
  57 ;;
  58 ;;   * `file-cache-add-directory-list': Same as above, but acts on a list
  59 ;;     of directories. You can use `load-path', `exec-path' and the like.
  60 ;;
  61 ;;   * `file-cache-add-directory-using-find': Uses the `find' command to
  62 ;;     add a directory tree to the cache.
  63 ;;
  64 ;;   * `file-cache-add-directory-using-locate': Uses the `locate' command to
  65 ;;     add files matching a pattern to the cache.
  66 ;;
  67 ;; Use the function `file-cache-clear-cache' to remove all items from the
  68 ;; cache. There are a number of `file-cache-delete' functions provided
  69 ;; as well, but in general it is probably better to not worry too much
  70 ;; about extra files in the cache.
  71 ;;
  72 ;; The most convenient way to initialize the cache is with an
  73 ;; `eval-after-load' function, as noted in the ADDING FILES
  74 ;; AUTOMATICALLY section.
  75 ;;
  76 ;; FINDING FILES USING THE CACHE:
  77 ;;
  78 ;; You can use the file-cache with any function that expects a filename as
  79 ;; an argument. For example:
  80 ;;
  81 ;; 1) Invoke a function which expects a filename as an argument:
  82 ;;    M-x find-file
  83 ;;
  84 ;; 2) Begin typing a file name.
  85 ;;
  86 ;; 3) Invoke `file-cache-minibuffer-complete' (bound by default to
  87 ;; C-TAB) to complete on the filename using the cache.
  88 ;;
  89 ;; 4) When you have found a unique completion, the minibuffer contents
  90 ;; will change to the full name of that file.
  91 ;;
  92 ;; If there are a number of directories which contain the completion,
  93 ;; invoking `file-cache-minibuffer-complete' repeatedly will cycle through
  94 ;; them.
  95 ;;
  96 ;; 5) You can then edit the minibuffer contents, or press RETURN.
  97 ;;
  98 ;; It is much easier to simply try it than trying to explain it :)
  99 ;;
 100 ;;; ADDING FILES AUTOMATICALLY
 101 ;;
 102 ;; For maximum utility, you should probably define an `eval-after-load'
 103 ;; form which loads your favorite files:
 104 ;;
 105 ;;      (eval-after-load
 106 ;;       "filecache"
 107 ;;       '(progn
 108 ;;          (message "Loading file cache...")
 109 ;;          (file-cache-add-directory-using-find "~/projects")
 110 ;;          (file-cache-add-directory-list load-path)
 111 ;;          (file-cache-add-directory "~/")
 112 ;;          (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
 113 ;;         ))
 114 ;;
 115 ;; If you clear and reload the cache frequently, it is probably easiest
 116 ;; to put your initializations in a function:
 117 ;;
 118 ;;   (eval-after-load
 119 ;;     "filecache"
 120 ;;      '(my-file-cache-initialize))
 121 ;;
 122 ;;   (defun my-file-cache-initialize ()
 123 ;;      (interactive)
 124 ;;      (message "Loading file cache...")
 125 ;;      (file-cache-add-directory-using-find "~/projects")
 126 ;;      (file-cache-add-directory-list load-path)
 127 ;;      (file-cache-add-directory "~/")
 128 ;;      (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
 129 ;;   ))
 130 ;;
 131 ;; Of course, you can still add files to the cache afterwards, via
 132 ;; Lisp functions.
 133 ;;
 134 ;; RELATED WORK:
 135 ;;
 136 ;; This package is a distant relative of Noah Friedman's fff utilities.
 137 ;; Our goal is pretty similar, but the implementation strategies are
 138 ;; different.
 139
 140 ;;; Code:
 141
 142 (defgroup file-cache nil
 143   "Find files using a pre-loaded cache."
 144   :group 'files
 145   :group 'convenience
 146   :prefix "file-cache-")
 147
 148 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 149 ;; Customization Variables
 150 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 151
 152 ;; User-modifiable variables
 153 (defcustom file-cache-filter-regexps
 154   (list "~$" "\\.o$" "\\.exe$" "\\.a$" "\\.elc$" ",v$" "\\.output$"
 155         "\\.$" "#$" "\\.class$")
 156   "*List of regular expressions used as filters by the file cache.
 157 File names which match these expressions will not be added to the cache.
 158 Note that the functions `file-cache-add-file' and `file-cache-add-file-list'
 159 do not use this variable."
 160   :type '(repeat regexp)
 161   :group 'file-cache)
 162
 163 (defcustom file-cache-find-command "find"
 164   "*External program used by `file-cache-add-directory-using-find'."
 165   :type 'string
 166   :group 'file-cache)
 167
 168 (defcustom file-cache-locate-command "locate"
 169   "*External program used by `file-cache-add-directory-using-locate'."
 170   :type 'string
 171   :group 'file-cache)
 172
 173 ;; Minibuffer messages
 174 (defcustom file-cache-no-match-message " [File Cache: No match]"
 175   "Message to display when there is no completion."
 176   :type 'string
 177   :group 'file-cache)
 178
 179 (defcustom file-cache-sole-match-message " [File Cache: sole completion]"
 180   "Message to display when there is only one completion."
 181   :type 'string
 182   :group 'file-cache)
 183
 184 (defcustom file-cache-non-unique-message
 185   " [File Cache: complete but not unique]"
 186   "Message to display when there is a non-unique completion."
 187   :type 'string
 188   :group 'file-cache)
 189
 190 (defcustom file-cache-completion-ignore-case
 191    (if (memq system-type (list 'ms-dos 'windows-nt))
 192       t
 193      completion-ignore-case)
 194   "If non-nil, file-cache completion should ignore case.
 195 Defaults to the value of `completion-ignore-case'."
 196   :type 'sexp
 197   :group 'file-cache
 198   )
 199
 200 (defcustom file-cache-case-fold-search
 201   (if (memq system-type (list 'ms-dos 'windows-nt))
 202       t
 203     case-fold-search)
 204   "If non-nil, file-cache completion should ignore case.
 205 Defaults to the value of `case-fold-search'."
 206   :type 'sexp
 207   :group 'file-cache
 208   )
 209
 210 (defcustom file-cache-assoc-function
 211   (if (memq system-type (list 'ms-dos 'windows-nt))
 212       'assoc-ignore-case
 213     'assoc)
 214   "Function to use to check completions in the file cache.
 215 Defaults to `assoc-ignore-case' on DOS and Windows, and `assoc' on
 216 other systems."
 217   :type 'sexp
 218   :group 'file-cache
 219   )
 220
 221 (defvar file-cache-multiple-directory-message nil)
 222
 223 ;; Internal variables
 224 ;; This should be named *Completions* because that's what the function
 225 ;; switch-to-completions in simple.el expects
 226 (defcustom file-cache-completions-buffer "*Completions*"
 227   "Buffer to display completions when using the file cache."
 228   :type 'string
 229   :group 'file-cache)
 230
 231 (defcustom file-cache-buffer "*File Cache*"
 232   "Buffer to hold the cache of file names."
 233   :type 'string
 234   :group 'file-cache)
 235
 236 (defcustom file-cache-buffer-default-regexp "^.+$"
 237   "Regexp to match files in `file-cache-buffer'."
 238   :type 'regexp
 239   :group 'file-cache)
 240
 241 (defvar file-cache-last-completion nil)
 242
 243 (defvar file-cache-alist nil
 244   "Internal data structure to hold cache of file names.")
 245
 246 (defvar file-cache-completions-keymap nil
 247   "Keymap for file cache completions buffer.")
 248
 249 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 250 ;; Functions to add files to the cache
 251 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 252
 253 (defun file-cache-add-directory (directory &optional regexp)
 254   "Add DIRECTORY to the file cache.
 255 If the optional REGEXP argument is non-nil, only files which match it will
 256 be added to the cache."
 257   (interactive "DAdd files from directory: ")
 258   ;; Not an error, because otherwise we can't use load-paths that
 259   ;; contain non-existent directories.
 260   (if (not (file-accessible-directory-p directory))
 261       (message "Directory %s does not exist" directory)
 262     (let* ((dir       (expand-file-name directory))
 263            (dir-files (directory-files dir t regexp))
 264            )
 265       ;; Filter out files we don't want to see
 266       (mapcar
 267        '(lambda (file)
 268         (mapcar
 269          '(lambda (regexp)
 270             (if (string-match regexp file)
 271                 (setq dir-files (delq file dir-files))))
 272          file-cache-filter-regexps))
 273        dir-files)
 274       (file-cache-add-file-list dir-files))))
 275
 276 (defun file-cache-add-directory-list (directory-list &optional regexp)
 277   "Add DIRECTORY-LIST (a list of directory names) to the file cache.
 278 If the optional REGEXP argument is non-nil, only files which match it
 279 will be added to the cache. Note that the REGEXP is applied to the files
 280 in each directory, not to the directory list itself."
 281   (interactive "XAdd files from directory list: ")
 282   (mapcar
 283    '(lambda (dir) (file-cache-add-directory dir regexp))
 284    directory-list))
 285
 286 (defun file-cache-add-file-list  (file-list)
 287   "Add FILE-LIST (a list of files names) to the file cache."
 288   (interactive "XFile List: ")
 289   (mapcar 'file-cache-add-file file-list))
 290
 291 ;; Workhorse function
 292 (defun file-cache-add-file (file)
 293   "Add FILE to the file cache."
 294   (interactive "fAdd File: ")
 295   (if (not (file-exists-p file))
 296       (message "File %s does not exist" file)
 297     (let* ((file-name (file-name-nondirectory file))
 298            (dir-name  (file-name-directory    file))
 299            (the-entry (funcall file-cache-assoc-function
 300                                file-name file-cache-alist))
 301            )
 302       ;; Does the entry exist already?
 303       (if the-entry
 304           (if (or (and (stringp (cdr the-entry))
 305                        (string= dir-name (cdr the-entry)))
 306                   (and (listp (cdr the-entry))
 307                        (member dir-name (cdr the-entry))))
 308               nil
 309             (setcdr the-entry (append (list dir-name) (cdr the-entry)))
 310             )
 311         ;; If not, add it to the cache
 312         (setq file-cache-alist
 313               (cons (cons file-name (list dir-name))
 314                     file-cache-alist)))
 315       )))
 316
 317 (defun file-cache-add-directory-using-find (directory)
 318   "Use the `find' command to add files to the file cache.
 319 Find is run in DIRECTORY."
 320   (interactive "DAdd files under directory: ")
 321   (let ((dir (expand-file-name directory)))
 322     (set-buffer (get-buffer-create file-cache-buffer))
 323     (erase-buffer)
 324     (call-process file-cache-find-command nil
 325                   (get-buffer file-cache-buffer) nil
 326                   dir "-name"
 327                   (if (memq system-type
 328                             (list 'windows-nt 'ms-dos)) "'*'" "*")
 329                   "-print")
 330     (file-cache-add-from-file-cache-buffer)))
 331
 332 (defun file-cache-add-directory-using-locate (string)
 333   "Use the `locate' command to add files to the file cache.
 334 STRING is passed as an argument to the locate command."
 335   (interactive "sAdd files using locate string: ")
 336   (set-buffer (get-buffer-create file-cache-buffer))
 337   (erase-buffer)
 338   (call-process file-cache-locate-command nil
 339                 (get-buffer file-cache-buffer) nil
 340                 string)
 341   (file-cache-add-from-file-cache-buffer))
 342
 343 (defun file-cache-add-from-file-cache-buffer (&optional regexp)
 344   "Add any entries found in the file cache buffer.
 345 Each entry matches the regular expression `file-cache-buffer-default-regexp'
 346 or the optional REGEXP argument."
 347   (set-buffer file-cache-buffer)
 348   (mapcar
 349    (function (lambda (elt)
 350                (goto-char (point-min))
 351                (delete-matching-lines elt)))
 352    file-cache-filter-regexps)
 353   (goto-char (point-min))
 354   (let ((full-filename))
 355     (while (re-search-forward
 356             (or regexp file-cache-buffer-default-regexp)
 357             (point-max) t)
 358       (setq full-filename (buffer-substring-no-properties
 359                       (match-beginning 0) (match-end 0)))
 360       (file-cache-add-file full-filename))))
 361
 362 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 363 ;; Functions to delete from the cache
 364 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 365
 366 (defun file-cache-clear-cache ()
 367   "Clear the file cache."
 368   (interactive)
 369   (setq file-cache-alist nil))
 370
 371 ;; This clears *all* files with the given name
 372 (defun file-cache-delete-file (file)
 373   "Delete FILE from the file cache."
 374   (interactive
 375    (list (completing-read "Delete file from cache: " file-cache-alist)))
 376   (setq file-cache-alist
 377         (delq (funcall file-cache-assoc-function file file-cache-alist)
 378               file-cache-alist)))
 379
 380 (defun file-cache-delete-file-list (file-list)
 381   "Delete FILE-LIST (a list of files) from the file cache."
 382   (interactive "XFile List: ")
 383   (mapcar 'file-cache-delete-file file-list))
 384
 385 (defun file-cache-delete-file-regexp (regexp)
 386   "Delete files matching REGEXP from the file cache."
 387   (interactive "sRegexp: ")
 388   (let ((delete-list))
 389     (mapcar '(lambda (elt)
 390                (and (string-match regexp (car elt))
 391                     (setq delete-list (cons (car elt) delete-list))))
 392             file-cache-alist)
 393     (file-cache-delete-file-list delete-list)
 394     (message "Deleted %d files from file cache" (length delete-list))))
 395
 396 (defun file-cache-delete-directory (directory)
 397   "Delete DIRECTORY from the file cache."
 398   (interactive "DDelete directory from file cache: ")
 399   (let ((dir (expand-file-name directory))
 400         (result 0))
 401     (mapcar
 402      '(lambda (entry)
 403         (if (file-cache-do-delete-directory dir entry)
 404             (setq result (1+ result))))
 405      file-cache-alist)
 406     (if (zerop result)
 407         (error "No entries containing %s found in cache" directory)
 408       (message "Deleted %d entries" result))))
 409
 410 (defun file-cache-do-delete-directory (dir entry)
 411   (let ((directory-list (cdr entry))
 412         (directory (file-cache-canonical-directory dir))
 413         )
 414     (and (member directory directory-list)
 415          (if (equal 1 (length directory-list))
 416              (setq file-cache-alist
 417                    (delq entry file-cache-alist))
 418            (setcdr entry (delete directory directory-list)))
 419          )
 420     ))
 421
 422 (defun file-cache-delete-directory-list (directory-list)
 423   "Delete DIRECTORY-LIST (a list of directories) from the file cache."
 424   (interactive "XDirectory List: ")
 425   (mapcar 'file-cache-delete-directory directory-list))
 426
 427 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 428 ;; Utility functions
 429 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 430
 431 ;; Returns the name of a directory for a file in the cache
 432 (defun file-cache-directory-name  (file)
 433   (let* ((directory-list (cdr (funcall file-cache-assoc-function
 434                                        file file-cache-alist)))
 435          (len            (length directory-list))
 436          (directory)
 437          (num)
 438          )
 439     (if (not (listp directory-list))
 440         (error "Unknown type in file-cache-alist for key %s" file))
 441     (cond
 442      ;; Single element
 443      ((eq 1 len)
 444       (setq directory (elt directory-list 0)))
 445      ;; No elements
 446      ((eq 0 len)
 447       (error "No directory found for key %s" file))
 448      ;; Multiple elements
 449      (t
 450       (let* ((minibuffer-dir (file-name-directory (buffer-string)))
 451              (dir-list       (member minibuffer-dir directory-list))
 452              )
 453         (setq directory
 454               ;; If the directory is in the list, return the next element
 455               ;; Otherwise, return the first element
 456               (if dir-list
 457                   (or (elt directory-list
 458                            (setq num (1+ (- len (length dir-list)))))
 459                       (elt directory-list (setq num 0)))
 460                 (elt directory-list (setq num 0))))
 461         )
 462       )
 463      )
 464     ;; If there were multiple directories, set up a minibuffer message
 465     (setq file-cache-multiple-directory-message
 466           (and num (format " [%d of %d]" (1+ num) len)))
 467     directory))
 468
 469 ;; Returns the name of a file in the cache
 470 (defun file-cache-file-name  (file)
 471   (let ((directory (file-cache-directory-name file)))
 472     (concat directory file)))
 473
 474 ;; Return a canonical directory for comparison purposes.
 475 ;; Such a directory ends with a forward slash.
 476 (defun file-cache-canonical-directory (dir)
 477   (let ((directory dir))
 478     (if (not (char-equal ?/ (string-to-char (substring directory -1))))
 479         (concat directory "/")
 480       directory)))
 481
 482 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 483 ;; Minibuffer functions
 484 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 485
 486 ;; The prefix argument works around a bug in the minibuffer completion.
 487 ;; The completion function doesn't distinguish between the states:
 488 ;;
 489 ;;   "Multiple completions of name" (eg, Makefile, Makefile.in)
 490 ;;   "Name available in multiple directories" (/tmp/Makefile, ~me/Makefile)
 491 ;;
 492 ;; The default is to do the former; a prefix arg forces the latter.
 493
 494 ;;;###autoload
 495 (defun file-cache-minibuffer-complete (arg)
 496   "Complete a filename in the minibuffer using a preloaded cache.
 497 Filecache does two kinds of substitution: it completes on names in
 498 the cache, and, once it has found a unique name, it cycles through
 499 the directories that the name is available in.  With a prefix argument,
 500 the name is considered already unique; only the second substitution
 501 \(directories) is done."
 502   (interactive "P")
 503   (let*
 504       (
 505        (completion-ignore-case file-cache-completion-ignore-case)
 506        (case-fold-search       file-cache-case-fold-search)
 507        (string                 (file-name-nondirectory (buffer-string)))
 508        (completion-string      (try-completion string file-cache-alist))
 509        (completion-list)
 510        (len)
 511        (file-cache-string)
 512        )
 513     (cond
 514      ;; If it's the only match, replace the original contents
 515      ((or arg (eq completion-string t))
 516       (setq file-cache-string (file-cache-file-name string))
 517       (if (string= file-cache-string (buffer-string))
 518           (file-cache-temp-minibuffer-message file-cache-sole-match-message)
 519         (erase-buffer)
 520         (insert-string file-cache-string)
 521         (if file-cache-multiple-directory-message
 522             (file-cache-temp-minibuffer-message
 523              file-cache-multiple-directory-message))
 524       ))
 525
 526      ;; If it's the longest match, insert it
 527      ((stringp completion-string)
 528       ;; If we've already inserted a unique string, see if the user
 529       ;; wants to use that one
 530       (if (and (string= string completion-string)
 531                (funcall file-cache-assoc-function string file-cache-alist))
 532           (if (and (eq last-command this-command)
 533                    (string= file-cache-last-completion completion-string))
 534               (progn
 535                 (erase-buffer)
 536                 (insert-string (file-cache-file-name completion-string))
 537                 (setq file-cache-last-completion nil)
 538                 )
 539             (file-cache-temp-minibuffer-message file-cache-non-unique-message)
 540             (setq file-cache-last-completion string)
 541             )
 542         (setq file-cache-last-completion string)
 543         (setq completion-list (all-completions string file-cache-alist)
 544               len             (length completion-list))
 545         (if (> len 1)
 546             (progn
 547               (goto-char (point-max))
 548               (insert-string
 549                (substring completion-string (length string)))
 550               ;; Add our own setup function to the Completions Buffer
 551               (let ((completion-setup-hook
 552                    (reverse
 553                     (append (list 'file-cache-completion-setup-function)
 554                             completion-setup-hook)))
 555                     )
 556                 (with-output-to-temp-buffer file-cache-completions-buffer
 557                   (display-completion-list completion-list))
 558                 )
 559               )
 560           (setq file-cache-string (file-cache-file-name completion-string))
 561           (if (string= file-cache-string (buffer-string))
 562               (file-cache-temp-minibuffer-message
 563                file-cache-sole-match-message)
 564             (erase-buffer)
 565             (insert-string file-cache-string)
 566             (if file-cache-multiple-directory-message
 567                 (file-cache-temp-minibuffer-message
 568                  file-cache-multiple-directory-message)))
 569           )))
 570
 571      ;; No match
 572      ((eq completion-string nil)
 573       (file-cache-temp-minibuffer-message file-cache-no-match-message))
 574      )
 575 ))
 576
 577 ;; Lifted from "complete.el"
 578 (defun file-cache-temp-minibuffer-message (msg)
 579   "A Lisp version of `temp_minibuffer_message' from minibuf.c."
 580   (let ((savemax (point-max)))
 581     (save-excursion
 582       (goto-char (point-max))
 583       (insert msg))
 584     (let ((inhibit-quit t))
 585       (sit-for 2)
 586       (delete-region savemax (point-max))
 587       (if quit-flag
 588           (setq quit-flag nil
 589                 unread-command-events (list 7))))))
 590
 591 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 592 ;; Completion functions
 593 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 594
 595 (defun file-cache-completion-setup-function  ()
 596   (set-buffer file-cache-completions-buffer)
 597
 598   (if file-cache-completions-keymap
 599       nil
 600     (setq file-cache-completions-keymap
 601           (copy-keymap completion-list-mode-map))
 602     (define-key file-cache-completions-keymap [mouse-2]
 603       'file-cache-mouse-choose-completion)
 604     (define-key file-cache-completions-keymap "\C-m"
 605       'file-cache-choose-completion))
 606
 607     (use-local-map file-cache-completions-keymap)
 608     )
 609
 610 (defun file-cache-choose-completion  ()
 611   "Choose a completion in the `*Completions*' buffer."
 612   (interactive)
 613   (let ((completion-no-auto-exit t))
 614     (choose-completion)
 615     (select-window (active-minibuffer-window))
 616     (file-cache-minibuffer-complete nil)
 617     )
 618   )
 619
 620 (defun file-cache-mouse-choose-completion  (event)
 621   "Choose a completion with the mouse."
 622   (interactive "e")
 623   (let ((completion-no-auto-exit t))
 624     (mouse-choose-completion event)
 625     (select-window (active-minibuffer-window))
 626     (file-cache-minibuffer-complete nil)
 627     )
 628   )
 629
 630 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 631 ;; Show parts of the cache
 632 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 633
 634 (defun file-cache-files-matching-internal (regexp)
 635   "Output a list of files whose names (not including directories)
 636 match REGEXP."
 637   (let ((results))
 638     (mapcar
 639      (function
 640       (lambda(cache-element)
 641         (and (string-match regexp
 642                            (elt cache-element 0))
 643              (if results
 644                  (nconc results (list (elt cache-element 0)))
 645                (setq results (list (elt cache-element 0)))))))
 646      file-cache-alist)
 647     results))
 648
 649 (defun file-cache-files-matching (regexp)
 650   "Output a list of files whose names (not including directories)
 651 match REGEXP."
 652   (interactive "sFind files matching regexp: ")
 653   (let ((results
 654          (file-cache-files-matching-internal regexp))
 655         buf)
 656     (set-buffer
 657      (setq buf (get-buffer-create
 658                 "*File Cache Files Matching*")))
 659     (erase-buffer)
 660     (insert
 661      (mapconcat
 662       'identity
 663       results
 664       "\n"))
 665     (goto-char (point-min))
 666     (display-buffer buf)))
 667
 668 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 669 ;; Debugging functions
 670 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 671
 672 (defun file-cache-debug-read-from-minibuffer (file)
 673   "Debugging function."
 674   (interactive
 675    (list (completing-read "File Cache: " file-cache-alist)))
 676   (message "%s" (funcall file-cache-assoc-function file file-cache-alist))
 677   )
 678
 679 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 680 ;; Keybindings
 681 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 682
 683 ;;;###autoload (define-key minibuffer-local-completion-map [C-tab] 'file-cache-minibuffer-complete)
 684 ;;;###autoload (define-key minibuffer-local-map [C-tab] 'file-cache-minibuffer-complete)
 685 ;;;###autoload (define-key minibuffer-local-must-match-map [C-tab] 'file-cache-minibuffer-complete)
 686
 687 (provide 'filecache)
 688
 689 ;;; filecache.el ends here