1 ;;; filecache.el --- find files using a pre-loaded cache
3 ;; Copyright (C) 1996, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 ;; 2008, 2009 Free Software Foundation, Inc.
6 ;; Author: Peter Breton <pbreton@cs.umb.edu>
7 ;; Created: Sun Nov 10 1996
8 ;; Keywords: convenience
10 ;; This file is part of GNU Emacs.
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 3 of the License, or
15 ;; (at your option) any later version.
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.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;; The file-cache package is an attempt to make it easy to locate files
28 ;; by name, without having to remember exactly where they are located.
29 ;; This is very handy when working with source trees. You can also add
30 ;; frequently used files to the cache to create a hotlist effect.
31 ;; The cache can be used with any interactive command which takes a
32 ;; filename as an argument.
34 ;; It is worth noting that this package works best when most of the files
35 ;; in the cache have unique names, or (if they have the same name) exist in
36 ;; only a few directories. The worst case is many files all with
37 ;; the same name and in different directories, for example a big source tree
38 ;; with a Makefile in each directory. In such a case, you should probably
39 ;; use an alternate strategy to find the files.
41 ;; ADDING FILES TO THE CACHE:
43 ;; Use the following functions to add items to the file cache:
45 ;; * `file-cache-add-file': Adds a single file to the cache
47 ;; * `file-cache-add-file-list': Adds a list of files to the cache
49 ;; The following functions use the regular expressions in
50 ;; `file-cache-delete-regexps' to eliminate unwanted files:
52 ;; * `file-cache-add-directory': Adds the files in a directory to the
53 ;; cache. You can also specify a regular expression to match the files
54 ;; which should be added.
56 ;; * `file-cache-add-directory-list': Same as above, but acts on a list
57 ;; of directories. You can use `load-path', `exec-path' and the like.
59 ;; * `file-cache-add-directory-using-find': Uses the `find' command to
60 ;; add a directory tree to the cache.
62 ;; * `file-cache-add-directory-using-locate': Uses the `locate' command to
63 ;; add files matching a pattern to the cache.
65 ;; * `file-cache-add-directory-recursively': Uses the find-lisp package to
66 ;; add all files matching a pattern to the cache.
68 ;; Use the function `file-cache-clear-cache' to remove all items from the
69 ;; cache. There are a number of `file-cache-delete' functions provided
70 ;; as well, but in general it is probably better to not worry too much
71 ;; about extra files in the cache.
73 ;; The most convenient way to initialize the cache is with an
74 ;; `eval-after-load' function, as noted in the ADDING FILES
75 ;; AUTOMATICALLY section.
77 ;; FINDING FILES USING THE CACHE:
79 ;; You can use the file-cache with any function that expects a filename as
80 ;; an argument. For example:
82 ;; 1) Invoke a function which expects a filename as an argument:
85 ;; 2) Begin typing a file name.
87 ;; 3) Invoke `file-cache-minibuffer-complete' (bound by default to
88 ;; C-TAB) to complete on the filename using the cache.
90 ;; 4) When you have found a unique completion, the minibuffer contents
91 ;; will change to the full name of that file.
93 ;; If there are a number of directories which contain the completion,
94 ;; invoking `file-cache-minibuffer-complete' repeatedly will cycle through
97 ;; 5) You can then edit the minibuffer contents, or press RETURN.
99 ;; It is much easier to simply try it than trying to explain it :)
101 ;;; ADDING FILES AUTOMATICALLY
103 ;; For maximum utility, you should probably define an `eval-after-load'
104 ;; form which loads your favorite files:
109 ;; (message "Loading file cache...")
110 ;; (file-cache-add-directory-using-find "~/projects")
111 ;; (file-cache-add-directory-list load-path)
112 ;; (file-cache-add-directory "~/")
113 ;; (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
116 ;; If you clear and reload the cache frequently, it is probably easiest
117 ;; to put your initializations in a function:
121 ;; '(my-file-cache-initialize))
123 ;; (defun my-file-cache-initialize ()
125 ;; (message "Loading file cache...")
126 ;; (file-cache-add-directory-using-find "~/projects")
127 ;; (file-cache-add-directory-list load-path)
128 ;; (file-cache-add-directory "~/")
129 ;; (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
132 ;; Of course, you can still add files to the cache afterwards, via
137 ;; This package is a distant relative of Noah Friedman's fff utilities.
138 ;; Our goal is pretty similar, but the implementation strategies are
144 (require 'find-lisp
))
146 (defgroup file-cache nil
147 "Find files using a pre-loaded cache."
150 :prefix
"file-cache-")
152 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
153 ;; Customization Variables
154 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
156 ;; User-modifiable variables
157 (defcustom file-cache-filter-regexps
158 (list "~$" "\\.o$" "\\.exe$" "\\.a$" "\\.elc$" ",v$" "\\.output$"
159 "\\.$" "#$" "\\.class$")
160 "List of regular expressions used as filters by the file cache.
161 File names which match these expressions will not be added to the cache.
162 Note that the functions `file-cache-add-file' and `file-cache-add-file-list'
163 do not use this variable."
164 :type
'(repeat regexp
)
167 (defcustom file-cache-find-command
"find"
168 "External program used by `file-cache-add-directory-using-find'."
172 (defcustom file-cache-find-command-posix-flag
'not-defined
173 "Set to t, if `file-cache-find-command' handles wildcards POSIX style.
174 This variable is automatically set to nil or non-nil
175 if it has the initial value `not-defined' whenever you first
176 call the `file-cache-add-directory-using-find'.
178 Under Windows operating system where Cygwin is available, this value
180 :type
'(choice (const :tag
"Yes" t
)
181 (const :tag
"No" nil
)
182 (const :tag
"Unknown" not-defined
))
185 (defcustom file-cache-locate-command
"locate"
186 "External program used by `file-cache-add-directory-using-locate'."
190 ;; Minibuffer messages
191 (defcustom file-cache-no-match-message
" [File Cache: No match]"
192 "Message to display when there is no completion."
196 (defcustom file-cache-sole-match-message
" [File Cache: sole completion]"
197 "Message to display when there is only one completion."
201 (defcustom file-cache-non-unique-message
202 " [File Cache: complete but not unique]"
203 "Message to display when there is a non-unique completion."
207 (defcustom file-cache-completion-ignore-case
208 (if (memq system-type
(list 'ms-dos
'windows-nt
'cygwin
))
210 completion-ignore-case
)
211 "If non-nil, file-cache completion should ignore case.
212 Defaults to the value of `completion-ignore-case'."
217 (defcustom file-cache-case-fold-search
218 (if (memq system-type
(list 'ms-dos
'windows-nt
'cygwin
))
221 "If non-nil, file-cache completion should ignore case.
222 Defaults to the value of `case-fold-search'."
227 (defcustom file-cache-ignore-case
228 (memq system-type
(list 'ms-dos
'windows-nt
'cygwin
))
229 "Non-nil means ignore case when checking completions in the file cache.
230 Defaults to nil on DOS and Windows, and t on other systems."
235 (defvar file-cache-multiple-directory-message nil
)
237 ;; Internal variables
238 ;; This should be named *Completions* because that's what the function
239 ;; switch-to-completions in simple.el expects
240 (defcustom file-cache-completions-buffer
"*Completions*"
241 "Buffer to display completions when using the file cache."
245 (defcustom file-cache-buffer
"*File Cache*"
246 "Buffer to hold the cache of file names."
250 (defcustom file-cache-buffer-default-regexp
"^.+$"
251 "Regexp to match files in `file-cache-buffer'."
255 (defvar file-cache-last-completion nil
)
257 (defvar file-cache-alist nil
258 "Internal data structure to hold cache of file names.
259 It is a list of entries of the form (FILENAME DIRNAME1 DIRNAME2 ...)
260 where FILENAME is a file name component and the entry represents N
261 files of names DIRNAME1/FILENAME, DIRNAME2/FILENAME, ...")
263 (defvar file-cache-completions-keymap
264 (let ((map (make-sparse-keymap)))
265 (set-keymap-parent map completion-list-mode-map
)
266 (define-key map
[mouse-2
] 'file-cache-choose-completion
)
267 (define-key map
"\C-m" 'file-cache-choose-completion
)
269 "Keymap for file cache completions buffer.")
271 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
272 ;; Functions to add files to the cache
273 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
276 (defun file-cache-add-directory (directory &optional regexp
)
277 "Add DIRECTORY to the file cache.
278 If the optional REGEXP argument is non-nil, only files which match it will
279 be added to the cache."
280 (interactive "DAdd files from directory: ")
281 ;; Not an error, because otherwise we can't use load-paths that
282 ;; contain non-existent directories.
283 (if (not (file-accessible-directory-p directory
))
284 (message "Directory %s does not exist" directory
)
285 (let* ((dir (expand-file-name directory
))
286 (dir-files (directory-files dir t regexp
))
288 ;; Filter out files we don't want to see
291 (if (file-directory-p file
)
292 (setq dir-files
(delq file dir-files
))
295 (if (string-match regexp file
)
296 (setq dir-files
(delq file dir-files
))))
297 file-cache-filter-regexps
)))
299 (file-cache-add-file-list dir-files
))))
302 (defun file-cache-add-directory-list (directory-list &optional regexp
)
303 "Add DIRECTORY-LIST (a list of directory names) to the file cache.
304 If the optional REGEXP argument is non-nil, only files which match it
305 will be added to the cache. Note that the REGEXP is applied to the files
306 in each directory, not to the directory list itself."
307 (interactive "XAdd files from directory list: ")
309 '(lambda (dir) (file-cache-add-directory dir regexp
))
312 (defun file-cache-add-file-list (file-list)
313 "Add FILE-LIST (a list of files names) to the file cache."
314 (interactive "XFile List: ")
315 (mapcar 'file-cache-add-file file-list
))
317 ;; Workhorse function
320 (defun file-cache-add-file (file)
321 "Add FILE to the file cache."
322 (interactive "fAdd File: ")
323 (if (not (file-exists-p file
))
324 (message "Filecache: file %s does not exist" file
)
325 (let* ((file-name (file-name-nondirectory file
))
326 (dir-name (file-name-directory file
))
327 (the-entry (assoc-string
328 file-name file-cache-alist
329 file-cache-ignore-case
))
331 ;; Does the entry exist already?
333 (if (or (and (stringp (cdr the-entry
))
334 (string= dir-name
(cdr the-entry
)))
335 (and (listp (cdr the-entry
))
336 (member dir-name
(cdr the-entry
))))
338 (setcdr the-entry
(cons dir-name
(cdr the-entry
))))
339 ;; If not, add it to the cache
340 (push (list file-name dir-name
) file-cache-alist
)))))
343 (defun file-cache-add-directory-using-find (directory)
344 "Use the `find' command to add files to the file cache.
345 Find is run in DIRECTORY."
346 (interactive "DAdd files under directory: ")
347 (let ((dir (expand-file-name directory
)))
348 (when (memq system-type
'(windows-nt cygwin
))
349 (if (eq file-cache-find-command-posix-flag
'not-defined
)
350 (setq file-cache-find-command-posix-flag
351 (executable-command-find-posix-p file-cache-find-command
))))
352 (set-buffer (get-buffer-create file-cache-buffer
))
354 (call-process file-cache-find-command nil
355 (get-buffer file-cache-buffer
) nil
357 (if (memq system-type
'(windows-nt cygwin
))
358 (if file-cache-find-command-posix-flag
363 (file-cache-add-from-file-cache-buffer)))
366 (defun file-cache-add-directory-using-locate (string)
367 "Use the `locate' command to add files to the file cache.
368 STRING is passed as an argument to the locate command."
369 (interactive "sAdd files using locate string: ")
370 (set-buffer (get-buffer-create file-cache-buffer
))
372 (call-process file-cache-locate-command nil
373 (get-buffer file-cache-buffer
) nil
375 (file-cache-add-from-file-cache-buffer))
378 (defun file-cache-add-directory-recursively (dir &optional regexp
)
379 "Adds DIR and any subdirectories to the file-cache.
380 This function does not use any external programs
381 If the optional REGEXP argument is non-nil, only files which match it
382 will be added to the cache. Note that the REGEXP is applied to the files
383 in each directory, not to the directory list itself."
384 (interactive "DAdd directory: ")
389 (or (file-directory-p file
)
394 (and (string-match regexp file
)
397 file-cache-filter-regexps
)
399 (file-cache-add-file file
))))
400 (find-lisp-find-files dir
(if regexp regexp
"^"))))
402 (defun file-cache-add-from-file-cache-buffer (&optional regexp
)
403 "Add any entries found in the file cache buffer.
404 Each entry matches the regular expression `file-cache-buffer-default-regexp'
405 or the optional REGEXP argument."
406 (set-buffer file-cache-buffer
)
408 (function (lambda (elt)
409 (goto-char (point-min))
410 (delete-matching-lines elt
)))
411 file-cache-filter-regexps
)
412 (goto-char (point-min))
413 (let ((full-filename))
414 (while (re-search-forward
415 (or regexp file-cache-buffer-default-regexp
)
417 (setq full-filename
(buffer-substring-no-properties
418 (match-beginning 0) (match-end 0)))
419 (file-cache-add-file full-filename
))))
421 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
422 ;; Functions to delete from the cache
423 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
425 (defun file-cache-clear-cache ()
426 "Clear the file cache."
428 (setq file-cache-alist nil
))
430 ;; This clears *all* files with the given name
431 (defun file-cache-delete-file (file)
432 "Delete FILE from the file cache."
434 (list (completing-read "Delete file from cache: " file-cache-alist
)))
435 (setq file-cache-alist
436 (delq (assoc-string file file-cache-alist file-cache-ignore-case
)
439 (defun file-cache-delete-file-list (file-list)
440 "Delete FILE-LIST (a list of files) from the file cache."
441 (interactive "XFile List: ")
442 (mapcar 'file-cache-delete-file file-list
))
444 (defun file-cache-delete-file-regexp (regexp)
445 "Delete files matching REGEXP from the file cache."
446 (interactive "sRegexp: ")
449 (and (string-match regexp
(car elt
))
450 (push (car elt
) delete-list
)))
452 (file-cache-delete-file-list delete-list
)
453 (message "Filecache: deleted %d files from file cache"
454 (length delete-list
))))
456 (defun file-cache-delete-directory (directory)
457 "Delete DIRECTORY from the file cache."
458 (interactive "DDelete directory from file cache: ")
459 (let ((dir (expand-file-name directory
))
463 (if (file-cache-do-delete-directory dir entry
)
464 (setq result
(1+ result
))))
467 (error "Filecache: no entries containing %s found in cache" directory
)
468 (message "Filecache: deleted %d entries" result
))))
470 (defun file-cache-do-delete-directory (dir entry
)
471 (let ((directory-list (cdr entry
))
472 (directory (file-cache-canonical-directory dir
))
474 (and (member directory directory-list
)
475 (if (equal 1 (length directory-list
))
476 (setq file-cache-alist
477 (delq entry file-cache-alist
))
478 (setcdr entry
(delete directory directory-list
)))
482 (defun file-cache-delete-directory-list (directory-list)
483 "Delete DIRECTORY-LIST (a list of directories) from the file cache."
484 (interactive "XDirectory List: ")
485 (mapcar 'file-cache-delete-directory directory-list
))
487 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
489 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
491 ;; Returns the name of a directory for a file in the cache
492 (defun file-cache-directory-name (file)
493 (let* ((directory-list (cdr (assoc-string
494 file file-cache-alist
495 file-cache-ignore-case
)))
496 (len (length directory-list
))
500 (if (not (listp directory-list
))
501 (error "Filecache: unknown type in file-cache-alist for key %s" file
))
505 (setq directory
(elt directory-list
0)))
508 (error "Filecache: no directory found for key %s" file
))
511 (let* ((minibuffer-dir (file-name-directory (minibuffer-contents)))
512 (dir-list (member minibuffer-dir directory-list
))
515 ;; If the directory is in the list, return the next element
516 ;; Otherwise, return the first element
518 (or (elt directory-list
519 (setq num
(1+ (- len
(length dir-list
)))))
520 (elt directory-list
(setq num
0)))
521 (elt directory-list
(setq num
0))))
525 ;; If there were multiple directories, set up a minibuffer message
526 (setq file-cache-multiple-directory-message
527 (and num
(format " [%d of %d]" (1+ num
) len
)))
530 ;; Returns the name of a file in the cache
531 (defun file-cache-file-name (file)
532 (let ((directory (file-cache-directory-name file
)))
533 (concat directory file
)))
535 ;; Return a canonical directory for comparison purposes.
536 ;; Such a directory ends with a forward slash.
537 (defun file-cache-canonical-directory (dir)
538 (let ((directory dir
))
539 (if (not (char-equal ?
/ (string-to-char (substring directory -
1))))
540 (concat directory
"/")
543 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
544 ;; Minibuffer functions
545 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
547 ;; The prefix argument works around a bug in the minibuffer completion.
548 ;; The completion function doesn't distinguish between the states:
550 ;; "Multiple completions of name" (eg, Makefile, Makefile.in)
551 ;; "Name available in multiple directories" (/tmp/Makefile, ~me/Makefile)
553 ;; The default is to do the former; a prefix arg forces the latter.
556 (defun file-cache-minibuffer-complete (arg)
557 "Complete a filename in the minibuffer using a preloaded cache.
558 Filecache does two kinds of substitution: it completes on names in
559 the cache, and, once it has found a unique name, it cycles through
560 the directories that the name is available in. With a prefix argument,
561 the name is considered already unique; only the second substitution
562 \(directories) is done."
566 (completion-ignore-case file-cache-completion-ignore-case
)
567 (case-fold-search file-cache-case-fold-search
)
568 (string (file-name-nondirectory (minibuffer-contents)))
569 (completion-string (try-completion string file-cache-alist
))
575 ;; If it's the only match, replace the original contents
576 ((or arg
(eq completion-string t
))
577 (setq file-cache-string
(file-cache-file-name string
))
578 (if (string= file-cache-string
(minibuffer-contents))
579 (file-cache-temp-minibuffer-message file-cache-sole-match-message
)
580 (delete-minibuffer-contents)
581 (insert file-cache-string
)
582 (if file-cache-multiple-directory-message
583 (file-cache-temp-minibuffer-message
584 file-cache-multiple-directory-message
))
587 ;; If it's the longest match, insert it
588 ((stringp completion-string
)
589 ;; If we've already inserted a unique string, see if the user
590 ;; wants to use that one
591 (if (and (string= string completion-string
)
592 (assoc-string string file-cache-alist
593 file-cache-ignore-case
))
594 (if (and (eq last-command this-command
)
595 (string= file-cache-last-completion completion-string
))
597 (delete-minibuffer-contents)
598 (insert (file-cache-file-name completion-string
))
599 (setq file-cache-last-completion nil
)
601 (file-cache-temp-minibuffer-message file-cache-non-unique-message
)
602 (setq file-cache-last-completion string
)
604 (setq file-cache-last-completion string
)
605 (setq completion-list
(all-completions string file-cache-alist
)
606 len
(length completion-list
))
609 (goto-char (point-max))
611 (substring completion-string
(length string
)))
612 ;; Add our own setup function to the Completions Buffer
613 (let ((completion-setup-hook
614 (append completion-setup-hook
615 (list 'file-cache-completion-setup-function
))))
616 (with-output-to-temp-buffer file-cache-completions-buffer
617 (display-completion-list completion-list string
))))
618 (setq file-cache-string
(file-cache-file-name completion-string
))
619 (if (string= file-cache-string
(minibuffer-contents))
620 (file-cache-temp-minibuffer-message
621 file-cache-sole-match-message
)
622 (delete-minibuffer-contents)
623 (insert file-cache-string
)
624 (if file-cache-multiple-directory-message
625 (file-cache-temp-minibuffer-message
626 file-cache-multiple-directory-message
)))
630 ((eq completion-string nil
)
631 (file-cache-temp-minibuffer-message file-cache-no-match-message
))
635 ;; Lifted from "complete.el"
636 (defun file-cache-temp-minibuffer-message (msg)
637 "A Lisp version of `temp_minibuffer_message' from minibuf.c."
638 (let ((savemax (point-max)))
640 (goto-char (point-max))
642 (let ((inhibit-quit t
))
644 (delete-region savemax
(point-max))
647 unread-command-events
(list 7))))))
649 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
650 ;; Completion functions
651 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
653 (defun file-cache-completion-setup-function ()
654 (with-current-buffer standard-output
;; i.e. file-cache-completions-buffer
655 (use-local-map file-cache-completions-keymap
)))
657 (defun file-cache-choose-completion (&optional event
)
658 "Choose a completion in the `*Completions*' buffer."
659 (interactive (list last-nonmenu-event
))
660 (let ((completion-no-auto-exit t
))
661 (choose-completion event
)
662 (select-window (active-minibuffer-window))
663 (file-cache-minibuffer-complete nil
)))
665 (define-obsolete-function-alias 'file-cache-mouse-choose-completion
666 'file-cache-choose-completion
"23.2")
668 (defun file-cache-complete ()
669 "Complete the word at point, using the filecache."
673 (skip-syntax-backward "^\"")
675 (completion-in-region start
(point) file-cache-alist
)))
677 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
678 ;; Show parts of the cache
679 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
681 (defun file-cache-files-matching-internal (regexp)
682 "Output a list of files whose names (not including directories)
687 (lambda(cache-element)
688 (and (string-match regexp
689 (elt cache-element
0))
691 (nconc results
(list (elt cache-element
0)))
692 (setq results
(list (elt cache-element
0)))))))
696 (defun file-cache-files-matching (regexp)
697 "Output a list of files whose names (not including directories)
699 (interactive "sFind files matching regexp: ")
701 (file-cache-files-matching-internal regexp
))
704 (setq buf
(get-buffer-create
705 "*File Cache Files Matching*")))
712 (goto-char (point-min))
713 (display-buffer buf
)))
715 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
716 ;; Debugging functions
717 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
719 (defun file-cache-debug-read-from-minibuffer (file)
720 "Debugging function."
722 (list (completing-read "File Cache: " file-cache-alist
)))
723 (message "%s" (assoc-string file file-cache-alist
724 file-cache-ignore-case
))
727 (defun file-cache-display ()
728 "Display the file cache."
730 (let ((buf "*File Cache Contents*"))
732 (get-buffer-create buf
)
737 (insert (nth 1 item
) (nth 0 item
) "\n")))
742 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
744 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
748 ;; arch-tag: 433d3ca4-4af2-47ce-b2cf-1f727460f538
749 ;;; filecache.el ends here