(calendar-chinese-all-holidays-flag): New.
[emacs.git] / lisp / filecache.el
blob7e1d39a9ad3f538a5115db38c413fe80ddc1c3da
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 ;;
7 ;; Copyright (C) 1996, 2000, 2001, 2002, 2003, 2004,
8 ;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
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, or (at your option)
15 ;; 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; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 ;; Boston, MA 02110-1301, USA.
27 ;;; Commentary:
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.
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.
43 ;; ADDING FILES TO THE CACHE:
45 ;; Use the following functions to add items to the file cache:
47 ;; * `file-cache-add-file': Adds a single file to the cache
49 ;; * `file-cache-add-file-list': Adds a list of files to the cache
51 ;; The following functions use the regular expressions in
52 ;; `file-cache-delete-regexps' to eliminate unwanted files:
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.
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.
61 ;; * `file-cache-add-directory-using-find': Uses the `find' command to
62 ;; add a directory tree to the cache.
64 ;; * `file-cache-add-directory-using-locate': Uses the `locate' command to
65 ;; add files matching a pattern to the cache.
67 ;; * `file-cache-add-directory-recursively': Uses the find-lisp package to
68 ;; add all files matching a pattern to the cache.
70 ;; Use the function `file-cache-clear-cache' to remove all items from the
71 ;; cache. There are a number of `file-cache-delete' functions provided
72 ;; as well, but in general it is probably better to not worry too much
73 ;; about extra files in the cache.
75 ;; The most convenient way to initialize the cache is with an
76 ;; `eval-after-load' function, as noted in the ADDING FILES
77 ;; AUTOMATICALLY section.
79 ;; FINDING FILES USING THE CACHE:
81 ;; You can use the file-cache with any function that expects a filename as
82 ;; an argument. For example:
84 ;; 1) Invoke a function which expects a filename as an argument:
85 ;; M-x find-file
87 ;; 2) Begin typing a file name.
89 ;; 3) Invoke `file-cache-minibuffer-complete' (bound by default to
90 ;; C-TAB) to complete on the filename using the cache.
92 ;; 4) When you have found a unique completion, the minibuffer contents
93 ;; will change to the full name of that file.
95 ;; If there are a number of directories which contain the completion,
96 ;; invoking `file-cache-minibuffer-complete' repeatedly will cycle through
97 ;; them.
99 ;; 5) You can then edit the minibuffer contents, or press RETURN.
101 ;; It is much easier to simply try it than trying to explain it :)
103 ;;; ADDING FILES AUTOMATICALLY
105 ;; For maximum utility, you should probably define an `eval-after-load'
106 ;; form which loads your favorite files:
108 ;; (eval-after-load
109 ;; "filecache"
110 ;; '(progn
111 ;; (message "Loading file cache...")
112 ;; (file-cache-add-directory-using-find "~/projects")
113 ;; (file-cache-add-directory-list load-path)
114 ;; (file-cache-add-directory "~/")
115 ;; (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
116 ;; ))
118 ;; If you clear and reload the cache frequently, it is probably easiest
119 ;; to put your initializations in a function:
121 ;; (eval-after-load
122 ;; "filecache"
123 ;; '(my-file-cache-initialize))
125 ;; (defun my-file-cache-initialize ()
126 ;; (interactive)
127 ;; (message "Loading file cache...")
128 ;; (file-cache-add-directory-using-find "~/projects")
129 ;; (file-cache-add-directory-list load-path)
130 ;; (file-cache-add-directory "~/")
131 ;; (file-cache-add-file-list (list "~/foo/bar" "~/baz/bar"))
132 ;; ))
134 ;; Of course, you can still add files to the cache afterwards, via
135 ;; Lisp functions.
137 ;; RELATED WORK:
139 ;; This package is a distant relative of Noah Friedman's fff utilities.
140 ;; Our goal is pretty similar, but the implementation strategies are
141 ;; different.
143 ;;; Code:
145 (eval-when-compile
146 (require 'find-lisp))
148 (defgroup file-cache nil
149 "Find files using a pre-loaded cache."
150 :group 'files
151 :group 'convenience
152 :prefix "file-cache-")
154 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
155 ;; Customization Variables
156 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
158 ;; User-modifiable variables
159 (defcustom file-cache-filter-regexps
160 (list "~$" "\\.o$" "\\.exe$" "\\.a$" "\\.elc$" ",v$" "\\.output$"
161 "\\.$" "#$" "\\.class$")
162 "*List of regular expressions used as filters by the file cache.
163 File names which match these expressions will not be added to the cache.
164 Note that the functions `file-cache-add-file' and `file-cache-add-file-list'
165 do not use this variable."
166 :type '(repeat regexp)
167 :group 'file-cache)
169 (defcustom file-cache-find-command "find"
170 "*External program used by `file-cache-add-directory-using-find'."
171 :type 'string
172 :group 'file-cache)
174 (defcustom file-cache-find-command-posix-flag 'not-defined
175 "*Set to t, if `file-cache-find-command' handles wildcards POSIX style.
176 This variable is automatically set to nil or non-nil
177 if it has the initial value `not-defined' whenever you first
178 call the `file-cache-add-directory-using-find'.
180 Under Windows operating system where Cygwin is available, this value
181 should be t."
182 :type '(choice (const :tag "Yes" t)
183 (const :tag "No" nil)
184 (const :tag "Unknown" not-defined))
185 :group 'file-cache)
187 (defcustom file-cache-locate-command "locate"
188 "*External program used by `file-cache-add-directory-using-locate'."
189 :type 'string
190 :group 'file-cache)
192 ;; Minibuffer messages
193 (defcustom file-cache-no-match-message " [File Cache: No match]"
194 "Message to display when there is no completion."
195 :type 'string
196 :group 'file-cache)
198 (defcustom file-cache-sole-match-message " [File Cache: sole completion]"
199 "Message to display when there is only one completion."
200 :type 'string
201 :group 'file-cache)
203 (defcustom file-cache-non-unique-message
204 " [File Cache: complete but not unique]"
205 "Message to display when there is a non-unique completion."
206 :type 'string
207 :group 'file-cache)
209 (defcustom file-cache-completion-ignore-case
210 (if (memq system-type (list 'ms-dos 'windows-nt 'cygwin))
212 completion-ignore-case)
213 "If non-nil, file-cache completion should ignore case.
214 Defaults to the value of `completion-ignore-case'."
215 :type 'sexp
216 :group 'file-cache
219 (defcustom file-cache-case-fold-search
220 (if (memq system-type (list 'ms-dos 'windows-nt 'cygwin))
222 case-fold-search)
223 "If non-nil, file-cache completion should ignore case.
224 Defaults to the value of `case-fold-search'."
225 :type 'sexp
226 :group 'file-cache
229 (defcustom file-cache-ignore-case
230 (memq system-type (list 'ms-dos 'windows-nt 'cygwin))
231 "Non-nil means ignore case when checking completions in the file cache.
232 Defaults to nil on DOS and Windows, and t on other systems."
233 :type 'sexp
234 :group 'file-cache
237 (defvar file-cache-multiple-directory-message nil)
239 ;; Internal variables
240 ;; This should be named *Completions* because that's what the function
241 ;; switch-to-completions in simple.el expects
242 (defcustom file-cache-completions-buffer "*Completions*"
243 "Buffer to display completions when using the file cache."
244 :type 'string
245 :group 'file-cache)
247 (defcustom file-cache-buffer "*File Cache*"
248 "Buffer to hold the cache of file names."
249 :type 'string
250 :group 'file-cache)
252 (defcustom file-cache-buffer-default-regexp "^.+$"
253 "Regexp to match files in `file-cache-buffer'."
254 :type 'regexp
255 :group 'file-cache)
257 (defvar file-cache-last-completion nil)
259 (defvar file-cache-alist nil
260 "Internal data structure to hold cache of file names.")
262 (defvar file-cache-completions-keymap
263 (let ((map (make-sparse-keymap)))
264 (set-keymap-parent map completion-list-mode-map)
265 (define-key map [mouse-2] 'file-cache-mouse-choose-completion)
266 (define-key map "\C-m" 'file-cache-choose-completion)
267 map)
268 "Keymap for file cache completions buffer.")
270 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
271 ;; Functions to add files to the cache
272 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
274 ;;;###autoload
275 (defun file-cache-add-directory (directory &optional regexp)
276 "Add DIRECTORY to the file cache.
277 If the optional REGEXP argument is non-nil, only files which match it will
278 be added to the cache."
279 (interactive "DAdd files from directory: ")
280 ;; Not an error, because otherwise we can't use load-paths that
281 ;; contain non-existent directories.
282 (if (not (file-accessible-directory-p directory))
283 (message "Directory %s does not exist" directory)
284 (let* ((dir (expand-file-name directory))
285 (dir-files (directory-files dir t regexp))
287 ;; Filter out files we don't want to see
288 (mapc
289 '(lambda (file)
290 (if (file-directory-p file)
291 (setq dir-files (delq file dir-files))
292 (mapc
293 '(lambda (regexp)
294 (if (string-match regexp file)
295 (setq dir-files (delq file dir-files))))
296 file-cache-filter-regexps)))
297 dir-files)
298 (file-cache-add-file-list dir-files))))
300 ;;;###autoload
301 (defun file-cache-add-directory-list (directory-list &optional regexp)
302 "Add DIRECTORY-LIST (a list of directory names) to the file cache.
303 If the optional REGEXP argument is non-nil, only files which match it
304 will be added to the cache. Note that the REGEXP is applied to the files
305 in each directory, not to the directory list itself."
306 (interactive "XAdd files from directory list: ")
307 (mapcar
308 '(lambda (dir) (file-cache-add-directory dir regexp))
309 directory-list))
311 (defun file-cache-add-file-list (file-list)
312 "Add FILE-LIST (a list of files names) to the file cache."
313 (interactive "XFile List: ")
314 (mapcar 'file-cache-add-file file-list))
316 ;; Workhorse function
318 ;;;###autoload
319 (defun file-cache-add-file (file)
320 "Add FILE to the file cache."
321 (interactive "fAdd File: ")
322 (if (not (file-exists-p file))
323 (message "Filecache: file %s does not exist" file)
324 (let* ((file-name (file-name-nondirectory file))
325 (dir-name (file-name-directory file))
326 (the-entry (assoc-string
327 file-name file-cache-alist
328 file-cache-ignore-case))
330 ;; Does the entry exist already?
331 (if the-entry
332 (if (or (and (stringp (cdr the-entry))
333 (string= dir-name (cdr the-entry)))
334 (and (listp (cdr the-entry))
335 (member dir-name (cdr the-entry))))
337 (setcdr the-entry (append (list dir-name) (cdr the-entry)))
339 ;; If not, add it to the cache
340 (setq file-cache-alist
341 (cons (cons file-name (list dir-name))
342 file-cache-alist)))
345 ;;;###autoload
346 (defun file-cache-add-directory-using-find (directory)
347 "Use the `find' command to add files to the file cache.
348 Find is run in DIRECTORY."
349 (interactive "DAdd files under directory: ")
350 (let ((dir (expand-file-name directory)))
351 (when (memq system-type '(windows-nt cygwin))
352 (if (eq file-cache-find-command-posix-flag 'not-defined)
353 (setq file-cache-find-command-posix-flag
354 (executable-command-find-posix-p file-cache-find-command))))
355 (set-buffer (get-buffer-create file-cache-buffer))
356 (erase-buffer)
357 (call-process file-cache-find-command nil
358 (get-buffer file-cache-buffer) nil
359 dir "-name"
360 (if (memq system-type '(windows-nt cygwin))
361 (if file-cache-find-command-posix-flag
362 "\\*"
363 "'*'")
364 "*")
365 "-print")
366 (file-cache-add-from-file-cache-buffer)))
368 ;;;###autoload
369 (defun file-cache-add-directory-using-locate (string)
370 "Use the `locate' command to add files to the file cache.
371 STRING is passed as an argument to the locate command."
372 (interactive "sAdd files using locate string: ")
373 (set-buffer (get-buffer-create file-cache-buffer))
374 (erase-buffer)
375 (call-process file-cache-locate-command nil
376 (get-buffer file-cache-buffer) nil
377 string)
378 (file-cache-add-from-file-cache-buffer))
380 ;;;###autoload
381 (defun file-cache-add-directory-recursively (dir &optional regexp)
382 "Adds DIR and any subdirectories to the file-cache.
383 This function does not use any external programs
384 If the optional REGEXP argument is non-nil, only files which match it
385 will be added to the cache. Note that the REGEXP is applied to the files
386 in each directory, not to the directory list itself."
387 (interactive "DAdd directory: ")
388 (require 'find-lisp)
389 (mapcar
390 (function
391 (lambda(file)
392 (or (file-directory-p file)
393 (let (filtered)
394 (mapc
395 (function
396 (lambda(regexp)
397 (and (string-match regexp file)
398 (setq filtered t))
400 file-cache-filter-regexps)
401 filtered)
402 (file-cache-add-file file))))
403 (find-lisp-find-files dir (if regexp regexp "^"))))
405 (defun file-cache-add-from-file-cache-buffer (&optional regexp)
406 "Add any entries found in the file cache buffer.
407 Each entry matches the regular expression `file-cache-buffer-default-regexp'
408 or the optional REGEXP argument."
409 (set-buffer file-cache-buffer)
410 (mapc
411 (function (lambda (elt)
412 (goto-char (point-min))
413 (delete-matching-lines elt)))
414 file-cache-filter-regexps)
415 (goto-char (point-min))
416 (let ((full-filename))
417 (while (re-search-forward
418 (or regexp file-cache-buffer-default-regexp)
419 (point-max) t)
420 (setq full-filename (buffer-substring-no-properties
421 (match-beginning 0) (match-end 0)))
422 (file-cache-add-file full-filename))))
424 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
425 ;; Functions to delete from the cache
426 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
428 (defun file-cache-clear-cache ()
429 "Clear the file cache."
430 (interactive)
431 (setq file-cache-alist nil))
433 ;; This clears *all* files with the given name
434 (defun file-cache-delete-file (file)
435 "Delete FILE from the file cache."
436 (interactive
437 (list (completing-read "Delete file from cache: " file-cache-alist)))
438 (setq file-cache-alist
439 (delq (assoc-string file file-cache-alist file-cache-ignore-case)
440 file-cache-alist)))
442 (defun file-cache-delete-file-list (file-list)
443 "Delete FILE-LIST (a list of files) from the file cache."
444 (interactive "XFile List: ")
445 (mapcar 'file-cache-delete-file file-list))
447 (defun file-cache-delete-file-regexp (regexp)
448 "Delete files matching REGEXP from the file cache."
449 (interactive "sRegexp: ")
450 (let ((delete-list))
451 (mapc '(lambda (elt)
452 (and (string-match regexp (car elt))
453 (setq delete-list (cons (car elt) delete-list))))
454 file-cache-alist)
455 (file-cache-delete-file-list delete-list)
456 (message "Filecache: deleted %d files from file cache"
457 (length delete-list))))
459 (defun file-cache-delete-directory (directory)
460 "Delete DIRECTORY from the file cache."
461 (interactive "DDelete directory from file cache: ")
462 (let ((dir (expand-file-name directory))
463 (result 0))
464 (mapc
465 '(lambda (entry)
466 (if (file-cache-do-delete-directory dir entry)
467 (setq result (1+ result))))
468 file-cache-alist)
469 (if (zerop result)
470 (error "Filecache: no entries containing %s found in cache" directory)
471 (message "Filecache: deleted %d entries" result))))
473 (defun file-cache-do-delete-directory (dir entry)
474 (let ((directory-list (cdr entry))
475 (directory (file-cache-canonical-directory dir))
477 (and (member directory directory-list)
478 (if (equal 1 (length directory-list))
479 (setq file-cache-alist
480 (delq entry file-cache-alist))
481 (setcdr entry (delete directory directory-list)))
485 (defun file-cache-delete-directory-list (directory-list)
486 "Delete DIRECTORY-LIST (a list of directories) from the file cache."
487 (interactive "XDirectory List: ")
488 (mapcar 'file-cache-delete-directory directory-list))
490 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
491 ;; Utility functions
492 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
494 ;; Returns the name of a directory for a file in the cache
495 (defun file-cache-directory-name (file)
496 (let* ((directory-list (cdr (assoc-string
497 file file-cache-alist
498 file-cache-ignore-case)))
499 (len (length directory-list))
500 (directory)
501 (num)
503 (if (not (listp directory-list))
504 (error "Filecache: unknown type in file-cache-alist for key %s" file))
505 (cond
506 ;; Single element
507 ((eq 1 len)
508 (setq directory (elt directory-list 0)))
509 ;; No elements
510 ((eq 0 len)
511 (error "Filecache: no directory found for key %s" file))
512 ;; Multiple elements
514 (let* ((minibuffer-dir (file-name-directory (minibuffer-contents)))
515 (dir-list (member minibuffer-dir directory-list))
517 (setq directory
518 ;; If the directory is in the list, return the next element
519 ;; Otherwise, return the first element
520 (if dir-list
521 (or (elt directory-list
522 (setq num (1+ (- len (length dir-list)))))
523 (elt directory-list (setq num 0)))
524 (elt directory-list (setq num 0))))
528 ;; If there were multiple directories, set up a minibuffer message
529 (setq file-cache-multiple-directory-message
530 (and num (format " [%d of %d]" (1+ num) len)))
531 directory))
533 ;; Returns the name of a file in the cache
534 (defun file-cache-file-name (file)
535 (let ((directory (file-cache-directory-name file)))
536 (concat directory file)))
538 ;; Return a canonical directory for comparison purposes.
539 ;; Such a directory ends with a forward slash.
540 (defun file-cache-canonical-directory (dir)
541 (let ((directory dir))
542 (if (not (char-equal ?/ (string-to-char (substring directory -1))))
543 (concat directory "/")
544 directory)))
546 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
547 ;; Minibuffer functions
548 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
550 ;; The prefix argument works around a bug in the minibuffer completion.
551 ;; The completion function doesn't distinguish between the states:
553 ;; "Multiple completions of name" (eg, Makefile, Makefile.in)
554 ;; "Name available in multiple directories" (/tmp/Makefile, ~me/Makefile)
556 ;; The default is to do the former; a prefix arg forces the latter.
558 ;;;###autoload
559 (defun file-cache-minibuffer-complete (arg)
560 "Complete a filename in the minibuffer using a preloaded cache.
561 Filecache does two kinds of substitution: it completes on names in
562 the cache, and, once it has found a unique name, it cycles through
563 the directories that the name is available in. With a prefix argument,
564 the name is considered already unique; only the second substitution
565 \(directories) is done."
566 (interactive "P")
567 (let*
569 (completion-ignore-case file-cache-completion-ignore-case)
570 (case-fold-search file-cache-case-fold-search)
571 (string (file-name-nondirectory (minibuffer-contents)))
572 (completion-string (try-completion string file-cache-alist))
573 (completion-list)
574 (len)
575 (file-cache-string)
577 (cond
578 ;; If it's the only match, replace the original contents
579 ((or arg (eq completion-string t))
580 (setq file-cache-string (file-cache-file-name string))
581 (if (string= file-cache-string (minibuffer-contents))
582 (file-cache-temp-minibuffer-message file-cache-sole-match-message)
583 (delete-minibuffer-contents)
584 (insert file-cache-string)
585 (if file-cache-multiple-directory-message
586 (file-cache-temp-minibuffer-message
587 file-cache-multiple-directory-message))
590 ;; If it's the longest match, insert it
591 ((stringp completion-string)
592 ;; If we've already inserted a unique string, see if the user
593 ;; wants to use that one
594 (if (and (string= string completion-string)
595 (assoc-string string file-cache-alist
596 file-cache-ignore-case))
597 (if (and (eq last-command this-command)
598 (string= file-cache-last-completion completion-string))
599 (progn
600 (delete-minibuffer-contents)
601 (insert (file-cache-file-name completion-string))
602 (setq file-cache-last-completion nil)
604 (file-cache-temp-minibuffer-message file-cache-non-unique-message)
605 (setq file-cache-last-completion string)
607 (setq file-cache-last-completion string)
608 (setq completion-list (all-completions string file-cache-alist)
609 len (length completion-list))
610 (if (> len 1)
611 (progn
612 (goto-char (point-max))
613 (insert
614 (substring completion-string (length string)))
615 ;; Add our own setup function to the Completions Buffer
616 (let ((completion-setup-hook
617 (append completion-setup-hook
618 (list 'file-cache-completion-setup-function))))
619 (with-output-to-temp-buffer file-cache-completions-buffer
620 (display-completion-list completion-list string))))
621 (setq file-cache-string (file-cache-file-name completion-string))
622 (if (string= file-cache-string (minibuffer-contents))
623 (file-cache-temp-minibuffer-message
624 file-cache-sole-match-message)
625 (delete-minibuffer-contents)
626 (insert file-cache-string)
627 (if file-cache-multiple-directory-message
628 (file-cache-temp-minibuffer-message
629 file-cache-multiple-directory-message)))
632 ;; No match
633 ((eq completion-string nil)
634 (file-cache-temp-minibuffer-message file-cache-no-match-message))
638 ;; Lifted from "complete.el"
639 (defun file-cache-temp-minibuffer-message (msg)
640 "A Lisp version of `temp_minibuffer_message' from minibuf.c."
641 (let ((savemax (point-max)))
642 (save-excursion
643 (goto-char (point-max))
644 (insert msg))
645 (let ((inhibit-quit t))
646 (sit-for 2)
647 (delete-region savemax (point-max))
648 (if quit-flag
649 (setq quit-flag nil
650 unread-command-events (list 7))))))
652 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
653 ;; Completion functions
654 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
656 (defun file-cache-completion-setup-function ()
657 (with-current-buffer standard-output ;; i.e. file-cache-completions-buffer
658 (use-local-map file-cache-completions-keymap)))
660 (defun file-cache-choose-completion ()
661 "Choose a completion in the `*Completions*' buffer."
662 (interactive)
663 (let ((completion-no-auto-exit t))
664 (choose-completion)
665 (select-window (active-minibuffer-window))
666 (file-cache-minibuffer-complete nil)
670 (defun file-cache-mouse-choose-completion (event)
671 "Choose a completion with the mouse."
672 (interactive "e")
673 (let ((completion-no-auto-exit t))
674 (mouse-choose-completion event)
675 (select-window (active-minibuffer-window))
676 (file-cache-minibuffer-complete nil)
680 (defun file-cache-complete ()
681 "Complete the word at point, using the filecache."
682 (interactive)
683 (let (start pattern completion all)
684 (save-excursion
685 (skip-syntax-backward "^\"")
686 (setq start (point)))
687 (setq pattern (buffer-substring-no-properties start (point)))
688 (setq completion (try-completion pattern file-cache-alist))
689 (setq all (all-completions pattern file-cache-alist nil))
690 (cond ((eq completion t))
691 ((null completion)
692 (message "Can't find completion for \"%s\"" pattern)
693 (ding))
694 ((not (string= pattern completion))
695 (delete-region start (point))
696 (insert completion)
699 (with-output-to-temp-buffer "*Completions*"
700 (display-completion-list all pattern))
704 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
705 ;; Show parts of the cache
706 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
708 (defun file-cache-files-matching-internal (regexp)
709 "Output a list of files whose names (not including directories)
710 match REGEXP."
711 (let ((results))
712 (mapc
713 (function
714 (lambda(cache-element)
715 (and (string-match regexp
716 (elt cache-element 0))
717 (if results
718 (nconc results (list (elt cache-element 0)))
719 (setq results (list (elt cache-element 0)))))))
720 file-cache-alist)
721 results))
723 (defun file-cache-files-matching (regexp)
724 "Output a list of files whose names (not including directories)
725 match REGEXP."
726 (interactive "sFind files matching regexp: ")
727 (let ((results
728 (file-cache-files-matching-internal regexp))
729 buf)
730 (set-buffer
731 (setq buf (get-buffer-create
732 "*File Cache Files Matching*")))
733 (erase-buffer)
734 (insert
735 (mapconcat
736 'identity
737 results
738 "\n"))
739 (goto-char (point-min))
740 (display-buffer buf)))
742 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
743 ;; Debugging functions
744 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
746 (defun file-cache-debug-read-from-minibuffer (file)
747 "Debugging function."
748 (interactive
749 (list (completing-read "File Cache: " file-cache-alist)))
750 (message "%s" (assoc-string file file-cache-alist
751 file-cache-ignore-case))
754 (defun file-cache-display ()
755 "Display the file cache."
756 (interactive)
757 (let ((buf "*File Cache Contents*"))
758 (with-current-buffer
759 (get-buffer-create buf)
760 (erase-buffer)
761 (mapc
762 (function
763 (lambda(item)
764 (insert (nth 1 item) (nth 0 item) "\n")))
765 file-cache-alist)
766 (pop-to-buffer buf)
769 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
770 ;; Keybindings
771 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
773 (provide 'filecache)
775 ;; arch-tag: 433d3ca4-4af2-47ce-b2cf-1f727460f538
776 ;;; filecache.el ends here