Fix buffer-list rename&refresh after after killing a buffer in ido.
[emacs.git] / lisp / find-file.el
blob80a77182772cb937292ed77b3bcdcf2d7f19e964
1 ;;; find-file.el --- find a file corresponding to this one given a pattern
3 ;; Author: Henry Guillaume <henri@tibco.com, henry@c032.aone.net.au>
4 ;; Maintainer: FSF
5 ;; Keywords: c, matching, tools
7 ;; Copyright (C) 1994, 1995, 2001, 2002, 2003, 2004,
8 ;; 2005, 2006, 2007, 2008, 2009, 2010 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 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/>.
25 ;;; Commentary:
27 ;; PURPOSE:
28 ;; This package features a function called ff-find-other-file, which performs
29 ;; the following function:
31 ;; When in a .c file, find the first corresponding .h file in a set
32 ;; of directories and display it, and vice-versa from the .h file.
34 ;; Many people maintain their include file in a directory separate to their
35 ;; src directory, and very often you may be editing a file and have a need to
36 ;; visit the "other file". This package searches through a set of directories
37 ;; to find that file.
39 ;; THE "OTHER FILE", or "corresponding file", generally has the same basename,
40 ;; and just has a different extension as described by the ff-other-file-alist
41 ;; variable:
43 ;; '(("\\.cc$" (".hh" ".h"))
44 ;; ("\\.hh$" (".cc" ".C" ".CC" ".cxx" ".cpp")))
46 ;; If the current file has a .cc extension, ff-find-other-file will attempt
47 ;; to look for a .hh file, and then a .h file in some directory as described
48 ;; below. The mechanism here is to replace the matched part of the original
49 ;; filename with each of the corresponding extensions in turn.
51 ;; Alternatively, there are situations where the filename of the other file
52 ;; cannot be determined easily with regexps. For example, a .c file may
53 ;; have two corresponding .h files, for its public and private parts, or
54 ;; the filename for the .c file contains part of the pathname of the .h
55 ;; file, as between src/fooZap.cc and include/FOO/zap.hh. In that case, the
56 ;; format above can be changed to include a function to be called when the
57 ;; current file matches the regexp:
59 ;; '(("\\.cc$" cc--function)
60 ;; ("\\.hh$" hh-function))
62 ;; These functions must return a list consisting of the possible names of the
63 ;; corresponding file, with or without path. There is no real need for more
64 ;; than one function, and one could imagine the following value for cc-other-
65 ;; file-alist:
67 ;; (setq cc-other-file-alist
68 ;; '(("\\.cc$" ff-cc-hh-converter)
69 ;; ("\\.hh$" ff-cc-hh-converter)
70 ;; ("\\.c$" (".h"))
71 ;; ("\\.h$" (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))))
73 ;; ff-cc-hh-converter is included at the end of this file as a reference.
75 ;; SEARCHING is carried out in a set of directories specified by the
76 ;; ff-search-directories variable:
78 ;; ("." "../../src" "../include/*" "/usr/local/*/src/*" "$PROJECT/src")
80 ;; This means that the corresponding file will be searched for first in
81 ;; the current directory, then in ../../src, then in one of the directories
82 ;; under ../include, and so on. The star is _not_ a general wildcard
83 ;; character: it just indicates that the subdirectories of this directory
84 ;; must each be searched in turn. Environment variables will be expanded in
85 ;; the ff-search-directories variable.
87 ;; If the point is on a #include line, the file to be #included is searched
88 ;; for in the same manner. This can be disabled with the ff-ignore-include
89 ;; variable, or by calling ff-get-other-file instead of ff-find-other-file.
91 ;; If the file was not found, ff-find-other-file will prompt you for where
92 ;; to create the new "corresponding file" (defaults to the current directory),
93 ;; unless the variable ff-always-try-to-create is set to nil.
95 ;; GIVEN AN ARGUMENT (with the ^U prefix), ff-find-other-file will get the
96 ;; other file in another (the other?) window (see find-file-other-window and
97 ;; switch-to-buffer-other-window). This can be set on a more permanent basis
98 ;; by setting ff-always-in-other-window to t in which case the ^U prefix will
99 ;; do the opposite of what was described above.
101 ;; THERE ARE FIVE AVAILABLE HOOKS, called in this order if non-nil:
103 ;; - ff-pre-find-hook - called before the search for the other file starts
104 ;; - ff-not-found-hook - called when the other file could not be found
105 ;; - ff-pre-load-hook - called just before the other file is 'loaded'
106 ;; - ff-file-created-hook - called when the other file is created
107 ;; - ff-post-load-hook - called just after the other file is 'loaded'
109 ;; The *load-hook allow you to place point where you want it in the other
110 ;; file.
112 ;; CREDITS:
113 ;; Many thanks go to TUSC Computer Systems Pty Ltd for providing an environ-
114 ;; ment that made the development of this package possible.
116 ;; Many thanks also go to all those who provided valuable feedback throughout
117 ;; the development of this package:
118 ;; Rolf Ebert in particular, Fritz Knabe, Heddy Boubaker, Sebastian Kremer,
119 ;; Vasco Lopes Paulo, Mark A. Plaksin, Robert Lang, Trevor West, Kevin
120 ;; Pereira, Benedict Lofstedt & Justin Vallon.
122 ;;; Code:
123 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
124 ;; User definable variables:
126 (defgroup ff nil
127 "Find a file corresponding to this one given a pattern."
128 :prefix "ff-"
129 :link '(emacs-commentary-link "find-file")
130 :group 'find-file)
132 (defcustom ff-pre-find-hook nil
133 "List of functions to be called before the search for the file starts."
134 :type 'hook
135 :group 'ff)
137 (defcustom ff-pre-load-hook nil
138 "List of functions to be called before the other file is loaded."
139 :type 'hook
140 :group 'ff)
142 (defcustom ff-post-load-hook nil
143 "List of functions to be called after the other file is loaded."
144 :type 'hook
145 :group 'ff)
147 (defcustom ff-not-found-hook nil
148 "List of functions to be called if the other file could not be found."
149 :type 'hook
150 :group 'ff)
152 (defcustom ff-file-created-hook nil
153 "List of functions to be called if the other file needs to be created."
154 :type 'hook
155 :group 'ff)
157 (defcustom ff-case-fold-search nil
158 "Non-nil means ignore cases in matches (see `case-fold-search').
159 If you have extensions in different cases, you will want this to be nil."
160 :type 'boolean
161 :group 'ff)
163 (defcustom ff-always-in-other-window nil
164 "If non-nil, find the corresponding file in another window by default.
165 To override this, give an argument to `ff-find-other-file'."
166 :type 'boolean
167 :group 'ff)
169 (defcustom ff-ignore-include nil
170 "If non-nil, ignore `#include' lines."
171 :type 'boolean
172 :group 'ff)
174 (defcustom ff-always-try-to-create t
175 "If non-nil, always attempt to create the other file if it was not found."
176 :type 'boolean
177 :group 'ff)
179 (defcustom ff-quiet-mode nil
180 "If non-nil, trace which directories are being searched."
181 :type 'boolean
182 :group 'ff)
184 ;;;###autoload
185 (defvar ff-special-constructs
187 ;; C/C++ include, for NeXTSTEP too
188 (,(purecopy "^\#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]") .
189 (lambda ()
190 (buffer-substring (match-beginning 2) (match-end 2))))
192 ;; We include `ff-treat-as-special' documentation here so that autoload
193 ;; can make it available to be read prior to loading this file.
194 "*List of special constructs for `ff-treat-as-special' to recognize.
195 Each element, tried in order, has the form (REGEXP . EXTRACT).
196 If REGEXP matches the current line (from the beginning of the line),
197 `ff-treat-as-special' calls function EXTRACT with no args.
198 If EXTRACT returns nil, keep trying. Otherwise, return the
199 filename that EXTRACT returned.")
201 (defvaralias 'ff-related-file-alist 'ff-other-file-alist)
202 (defcustom ff-other-file-alist 'cc-other-file-alist
203 "Alist of extensions to find given the current file's extension.
205 This list should contain the most used extensions before the others,
206 since the search algorithm searches sequentially through each
207 directory specified in `ff-search-directories'. If a file is not found,
208 a new one is created with the first matching extension (`.cc' yields `.hh').
209 This alist should be set by the major mode."
210 :type '(choice (repeat (list regexp (choice (repeat string) function)))
211 symbol)
212 :group 'ff)
214 (defcustom ff-search-directories 'cc-search-directories
215 "List of directories to search for a specific file.
217 Set by default to `cc-search-directories', expanded at run-time.
219 This list is searched through with each extension specified in
220 `ff-other-file-alist' that matches this file's extension. So the
221 longer the list, the longer it'll take to realize that a file
222 may not exist.
224 A typical format is
226 '(\".\" \"/usr/include\" \"$PROJECT/*/include\")
228 Environment variables can be inserted between slashes (`/').
229 They will be replaced by their definition. If a variable does
230 not exist, it is replaced (silently) with an empty string.
232 The stars are *not* wildcards: they are searched for together with
233 the preceding slash. The star represents all the subdirectories except
234 `..', and each of these subdirectories will be searched in turn."
235 :type '(choice (repeat directory) symbol)
236 :group 'ff)
238 (defcustom cc-search-directories
239 '("." "/usr/include" "/usr/local/include/*")
240 "See the description of the `ff-search-directories' variable."
241 :type '(repeat directory)
242 :group 'ff)
244 (defcustom cc-other-file-alist
245 '(("\\.cc\\'" (".hh" ".h"))
246 ("\\.hh\\'" (".cc" ".C"))
248 ("\\.c\\'" (".h"))
249 ("\\.h\\'" (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))
251 ("\\.C\\'" (".H" ".hh" ".h"))
252 ("\\.H\\'" (".C" ".CC"))
254 ("\\.CC\\'" (".HH" ".H" ".hh" ".h"))
255 ("\\.HH\\'" (".CC"))
257 ("\\.c\\+\\+\\'" (".h++" ".hh" ".h"))
258 ("\\.h\\+\\+\\'" (".c++"))
260 ("\\.cpp\\'" (".hpp" ".hh" ".h"))
261 ("\\.hpp\\'" (".cpp"))
263 ("\\.cxx\\'" (".hxx" ".hh" ".h"))
264 ("\\.hxx\\'" (".cxx")))
265 "Alist of extensions to find given the current file's extension.
267 This list should contain the most used extensions before the others,
268 since the search algorithm searches sequentially through each directory
269 specified in `ff-search-directories'. If a file is not found, a new one
270 is created with the first matching extension (`.cc' yields `.hh')."
271 :type '(repeat (list regexp (choice (repeat string) function)))
272 :group 'ff)
274 (defcustom modula2-other-file-alist
276 ("\\.mi$" (".md")) ;; Modula-2 module definition
277 ("\\.md$" (".mi")) ;; and implementation.
279 "See the description for the `ff-search-directories' variable."
280 :type '(repeat (list regexp (choice (repeat string) function)))
281 :group 'ff)
284 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
285 ;; No user definable variables beyond this point!
286 ;; ==============================================
288 (make-variable-buffer-local 'ff-pre-find-hook)
289 (make-variable-buffer-local 'ff-pre-load-hook)
290 (make-variable-buffer-local 'ff-post-load-hook)
291 (make-variable-buffer-local 'ff-not-found-hook)
292 (make-variable-buffer-local 'ff-file-created-hook)
293 (make-variable-buffer-local 'ff-case-fold-search)
294 (make-variable-buffer-local 'ff-always-in-other-window)
295 (make-variable-buffer-local 'ff-ignore-include)
296 (make-variable-buffer-local 'ff-quiet-mode)
297 (make-variable-buffer-local 'ff-other-file-alist)
298 (make-variable-buffer-local 'ff-search-directories)
300 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
301 ;; User entry points
303 ;;;###autoload
304 (defun ff-get-other-file (&optional in-other-window)
305 "Find the header or source file corresponding to this file.
306 See also the documentation for `ff-find-other-file'.
308 If optional IN-OTHER-WINDOW is non-nil, find the file in another window."
309 (interactive "P")
310 (let ((ignore ff-ignore-include))
311 (setq ff-ignore-include t)
312 (ff-find-the-other-file in-other-window)
313 (setq ff-ignore-include ignore)))
315 ;;;###autoload
316 (defalias 'ff-find-related-file 'ff-find-other-file)
318 ;;;###autoload
319 (defun ff-find-other-file (&optional in-other-window ignore-include)
320 "Find the header or source file corresponding to this file.
321 Being on a `#include' line pulls in that file.
323 If optional IN-OTHER-WINDOW is non-nil, find the file in the other window.
324 If optional IGNORE-INCLUDE is non-nil, ignore being on `#include' lines.
326 Variables of interest include:
328 - `ff-case-fold-search'
329 Non-nil means ignore cases in matches (see `case-fold-search').
330 If you have extensions in different cases, you will want this to be nil.
332 - `ff-always-in-other-window'
333 If non-nil, always open the other file in another window, unless an
334 argument is given to `ff-find-other-file'.
336 - `ff-ignore-include'
337 If non-nil, ignores #include lines.
339 - `ff-always-try-to-create'
340 If non-nil, always attempt to create the other file if it was not found.
342 - `ff-quiet-mode'
343 If non-nil, traces which directories are being searched.
345 - `ff-special-constructs'
346 A list of regular expressions specifying how to recognize special
347 constructs such as include files etc, and an associated method for
348 extracting the filename from that construct.
350 - `ff-other-file-alist'
351 Alist of extensions to find given the current file's extension.
353 - `ff-search-directories'
354 List of directories searched through with each extension specified in
355 `ff-other-file-alist' that matches this file's extension.
357 - `ff-pre-find-hook'
358 List of functions to be called before the search for the file starts.
360 - `ff-pre-load-hook'
361 List of functions to be called before the other file is loaded.
363 - `ff-post-load-hook'
364 List of functions to be called after the other file is loaded.
366 - `ff-not-found-hook'
367 List of functions to be called if the other file could not be found.
369 - `ff-file-created-hook'
370 List of functions to be called if the other file has been created."
371 (interactive "P")
372 (let ((ignore ff-ignore-include))
373 (setq ff-ignore-include ignore-include)
374 (ff-find-the-other-file in-other-window)
375 (setq ff-ignore-include ignore)))
377 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
378 ;; Support functions
380 (defun ff-find-the-other-file (&optional in-other-window)
381 "Find the header or source file corresponding to the current file.
382 Being on a `#include' line pulls in that file, but see the help on
383 the `ff-ignore-include' variable.
385 If optional IN-OTHER-WINDOW is non-nil, find the file in another window."
387 (let (match ;; matching regexp for this file
388 suffixes ;; set of replacing regexps for the matching regexp
389 action ;; function to generate the names of the other files
390 fname ;; basename of this file
391 pos ;; where we start matching filenames
392 stub ;; name of the file without extension
393 alist ;; working copy of the list of file extensions
394 pathname ;; the pathname of the file or the #include line
395 default-name ;; file we should create if none found
396 format ;; what we have to match
397 found ;; name of the file or buffer found - nil if none
398 dirs ;; local value of ff-search-directories
399 no-match) ;; whether we know about this kind of file
401 (run-hooks 'ff-pre-find-hook 'ff-pre-find-hooks)
403 (message "Working...")
405 (setq dirs
406 (if (symbolp ff-search-directories)
407 (ff-list-replace-env-vars (symbol-value ff-search-directories))
408 (ff-list-replace-env-vars ff-search-directories)))
410 (setq fname (ff-treat-as-special))
412 (cond
413 ((and (not ff-ignore-include) fname)
414 (setq default-name fname)
415 (setq found (ff-get-file dirs fname nil in-other-window)))
417 ;; let's just get the corresponding file
419 (setq alist (if (symbolp ff-other-file-alist)
420 (symbol-value ff-other-file-alist)
421 ff-other-file-alist)
422 pathname (if (buffer-file-name)
423 (buffer-file-name)
424 "/none.none"))
426 (setq fname (file-name-nondirectory pathname)
427 no-match nil
428 match (car alist))
430 ;; find the table entry corresponding to this file
431 (setq pos (ff-string-match (car match) fname))
432 (while (and match (if (and pos (>= pos 0)) nil (not pos)))
433 (setq alist (cdr alist))
434 (setq match (car alist))
435 (setq pos (ff-string-match (car match) fname)))
437 ;; no point going on if we haven't found anything
438 (if (not match)
439 (setq no-match t)
441 ;; otherwise, suffixes contains what we need
442 (setq suffixes (car (cdr match))
443 action (car (cdr match))
444 found nil)
446 ;; if we have a function to generate new names,
447 ;; invoke it with the name of the current file
448 (if (and (atom action) (fboundp action))
449 (progn
450 (setq suffixes (funcall action (buffer-file-name))
451 match (cons (car match) (list suffixes))
452 stub nil
453 default-name (car suffixes)))
455 ;; otherwise build our filename stub
456 (cond
458 ;; get around the problem that 0 and nil both mean false!
459 ((= pos 0)
460 (setq format "")
461 (setq stub "")
465 (setq format (concat "\\(.+\\)" (car match)))
466 (string-match format fname)
467 (setq stub (substring fname (match-beginning 1) (match-end 1)))
470 ;; if we find nothing, we should try to get a file like this one
471 (setq default-name
472 (concat stub (car (car (cdr match))))))
474 ;; do the real work - find the file
475 (setq found
476 (ff-get-file dirs
477 stub
478 suffixes
479 in-other-window)))))
481 (cond
482 (no-match ;; could not even determine the other file
483 (message ""))
486 (cond
488 ((not found) ;; could not find the other file
490 (run-hooks 'ff-not-found-hook 'ff-not-found-hooks)
492 (cond
493 (ff-always-try-to-create ;; try to create the file
494 (let (name pathname)
496 (setq name
497 (expand-file-name
498 (read-file-name
499 (format "Find or create %s in: " default-name)
500 default-directory default-name nil)))
502 (setq pathname
503 (if (file-directory-p name)
504 (concat (file-name-as-directory name) default-name)
505 (setq found name)))
507 (ff-find-file pathname in-other-window t)))
509 (t ;; don't create the file, just whinge
510 (message "No file found for %s" fname))))
512 (t ;; matching file found
513 nil))))
515 found)) ;; return buffer-name or filename
517 (defun ff-other-file-name ()
518 "Return name of the header or source file corresponding to the current file.
519 Being on a `#include' line pulls in that file, but see the help on
520 the `ff-ignore-include' variable."
522 (let (match ;; matching regexp for this file
523 suffixes ;; set of replacing regexps for the matching regexp
524 action ;; function to generate the names of the other files
525 fname ;; basename of this file
526 pos ;; where we start matching filenames
527 stub ;; name of the file without extension
528 alist ;; working copy of the list of file extensions
529 pathname ;; the pathname of the file or the #include line
530 default-name ;; file we should create if none found
531 format ;; what we have to match
532 found ;; name of the file or buffer found - nil if none
533 dirs ;; local value of ff-search-directories
534 no-match) ;; whether we know about this kind of file
536 (message "Working...")
538 (setq dirs
539 (if (symbolp ff-search-directories)
540 (ff-list-replace-env-vars (symbol-value ff-search-directories))
541 (ff-list-replace-env-vars ff-search-directories)))
543 (setq fname (ff-treat-as-special))
545 (cond
546 ((and (not ff-ignore-include) fname)
547 (setq default-name fname)
548 (setq found (ff-get-file-name dirs fname nil)))
550 ;; let's just get the corresponding file
552 (setq alist (if (symbolp ff-other-file-alist)
553 (symbol-value ff-other-file-alist)
554 ff-other-file-alist)
555 pathname (if (buffer-file-name)
556 (buffer-file-name)
557 "/none.none"))
559 (setq fname (file-name-nondirectory pathname)
560 no-match nil
561 match (car alist))
563 ;; find the table entry corresponding to this file
564 (setq pos (ff-string-match (car match) fname))
565 (while (and match (if (and pos (>= pos 0)) nil (not pos)))
566 (setq alist (cdr alist))
567 (setq match (car alist))
568 (setq pos (ff-string-match (car match) fname)))
570 ;; no point going on if we haven't found anything
571 (if (not match)
572 (setq no-match t)
574 ;; otherwise, suffixes contains what we need
575 (setq suffixes (car (cdr match))
576 action (car (cdr match))
577 found nil)
579 ;; if we have a function to generate new names,
580 ;; invoke it with the name of the current file
581 (if (and (atom action) (fboundp action))
582 (progn
583 (setq suffixes (funcall action (buffer-file-name))
584 match (cons (car match) (list suffixes))
585 stub nil
586 default-name (car suffixes)))
588 ;; otherwise build our filename stub
589 (cond
591 ;; get around the problem that 0 and nil both mean false!
592 ((= pos 0)
593 (setq format "")
594 (setq stub "")
598 (setq format (concat "\\(.+\\)" (car match)))
599 (string-match format fname)
600 (setq stub (substring fname (match-beginning 1) (match-end 1)))
603 ;; if we find nothing, we should try to get a file like this one
604 (setq default-name
605 (concat stub (car (car (cdr match))))))
607 ;; do the real work - find the file
608 (setq found
609 (ff-get-file-name dirs stub suffixes)))))
610 found)) ;; return buffer-name or filename
612 (defun ff-get-file (search-dirs filename &optional suffix-list other-window)
613 "Find a file in the SEARCH-DIRS with the given FILENAME (or filename stub).
614 If (optional) SUFFIX-LIST is nil, search for FILENAME, otherwise search
615 for FILENAME with each of the given suffixes. Get the file or the buffer
616 corresponding to the name of the first file found, or nil."
617 (let ((filename (ff-get-file-name search-dirs filename suffix-list)))
619 (cond
620 ((not filename)
621 nil)
623 ((bufferp (get-file-buffer filename))
624 (ff-switch-to-buffer (get-file-buffer filename) other-window)
625 filename)
627 ((file-exists-p filename)
628 (ff-find-file filename other-window nil)
629 filename)
632 nil))))
634 (defun ff-get-file-name (search-dirs fname-stub &optional suffix-list)
635 "Find a file in SEARCH-DIRS with the given name (or stub) FNAME-STUB.
636 If (optional) SUFFIX-LIST is nil, search for FNAME-STUB, otherwise
637 search for FNAME-STUB with each of the given suffixes. Return the
638 name of the first file found."
639 (let (dirs ;; working copy of dirs to search
640 dir ;; the current dir considered
641 file ;; filename being looked for
642 rest ;; pathname after first /*
643 this-suffix ;; the suffix we are currently considering
644 suffixes ;; working copy of suffix-list
645 filename ;; built filename
646 blist ;; list of live buffers
647 buf ;; current buffer in blist
648 found) ;; whether we have found anything
650 (setq suffixes suffix-list)
652 ;; suffixes is nil => fname-stub is the file we are looking for
653 ;; otherwise fname-stub is a stub, and we append a suffix
654 (if suffixes
655 (setq this-suffix (car suffixes))
656 (setq this-suffix "")
657 (setq suffixes (list "")))
659 ;; find whether the file is in a buffer first
660 (while (and suffixes (not found))
661 (setq filename (concat fname-stub this-suffix))
663 (if (not ff-quiet-mode)
664 (message "Finding buffer %s..." filename))
666 (if (bufferp (get-file-buffer filename))
667 (setq found (buffer-file-name (get-file-buffer filename))))
669 (setq blist (buffer-list))
670 (setq buf (buffer-name (car blist)))
671 (while (and blist (not found))
673 (if (string-match (concat filename "<[0-9]+>") buf)
674 (setq found (buffer-file-name (car blist))))
676 (setq blist (cdr blist))
677 (setq buf (buffer-name (car blist))))
679 (setq suffixes (cdr suffixes))
680 (setq this-suffix (car suffixes)))
682 ;; now look for the real file
683 (setq dirs search-dirs)
684 (setq dir (car dirs))
685 (while (and (not found) dirs)
687 (setq suffixes suffix-list)
689 ;; if dir does not contain '/*', look for the file
690 (if (and dir (not (string-match "\\([^*]*\\)/\\\*\\(/.*\\)*" dir)))
691 (progn
693 ;; suffixes is nil => fname-stub is the file we are looking for
694 ;; otherwise fname-stub is a stub, and we append a suffix
695 (if suffixes
696 (setq this-suffix (car suffixes))
697 (setq this-suffix "")
698 (setq suffixes (list "")))
700 (while (and suffixes (not found))
702 (setq filename (concat fname-stub this-suffix))
703 (setq file (concat dir "/" filename))
705 (if (not ff-quiet-mode)
706 (message "Finding %s..." file))
708 (if (file-exists-p file)
709 (setq found file))
711 (setq suffixes (cdr suffixes))
712 (setq this-suffix (car suffixes))))
714 ;; otherwise dir matches the '/*', so search each dir separately
715 (progn
716 (if (match-beginning 2)
717 (setq rest (substring dir (match-beginning 2) (match-end 2)))
718 (setq rest "")
720 (setq dir (substring dir (match-beginning 1) (match-end 1)))
722 (let ((dirlist (ff-all-dirs-under dir '("..")))
723 this-dir compl-dirs)
725 (setq this-dir (car dirlist))
726 (while dirlist
727 (setq compl-dirs
728 (append
729 compl-dirs
730 (list (concat this-dir rest))
732 (setq dirlist (cdr dirlist))
733 (setq this-dir (car dirlist)))
735 (if compl-dirs
736 (setq found (ff-get-file-name compl-dirs
737 fname-stub
738 suffix-list))))))
739 (setq dirs (cdr dirs))
740 (setq dir (car dirs)))
742 (if found
743 (message "%s found" found))
745 found))
747 (defun ff-string-match (regexp string &optional start)
748 "Like `string-match', but set `case-fold-search' temporarily.
749 The value used comes from `ff-case-fold-search'."
750 (let ((case-fold-search ff-case-fold-search))
751 (if regexp
752 (string-match regexp string start))))
754 (defun ff-list-replace-env-vars (search-list)
755 "Replace environment variables (of the form $VARIABLE) in SEARCH-LIST."
756 (let (list
757 (var (car search-list)))
758 (while search-list
759 (if (string-match "\\(.*\\)\\$[({]*\\([a-zA-Z0-9_]+\\)[)}]*\\(.*\\)" var)
760 (setq var
761 (concat
762 (substring var (match-beginning 1) (match-end 1))
763 (getenv (substring var (match-beginning 2) (match-end 2)))
764 (substring var (match-beginning 3) (match-end 3)))))
765 (setq search-list (cdr search-list))
766 (setq list (cons var list))
767 (setq var (car search-list)))
768 (setq search-list (reverse list))))
770 (defun ff-treat-as-special ()
771 "Return the file to look for if the construct was special, else nil.
772 See variable `ff-special-constructs'."
773 (save-excursion
774 (beginning-of-line 1)
775 (let* (fname
776 (list ff-special-constructs)
777 (elem (car list))
778 (regexp (car elem))
779 (match (cdr elem)))
780 (while (and list (not fname))
781 (if (and (looking-at regexp) match)
782 (setq fname (funcall match)))
783 (setq list (cdr list))
784 (setq elem (car list))
785 (setq regexp (car elem))
786 (setq match (cdr elem)))
787 fname)))
789 (defun ff-basename (string)
790 "Return the basename of pathname STRING."
791 (setq string (concat "/" string))
792 (string-match ".*/\\([^/]+\\)$" string)
793 (setq string (substring string (match-beginning 1) (match-end 1))))
795 (defun ff-all-dirs-under (here &optional exclude)
796 "Get all the directory files under directory HERE.
797 Exclude all files in the optional EXCLUDE list."
798 (if (file-directory-p here)
799 (condition-case nil
800 (progn
801 (let ((files (directory-files here t))
802 (dirlist (list))
803 file)
804 (while files
805 (setq file (car files))
806 (if (and
807 (file-directory-p file)
808 (not (member (ff-basename file) exclude)))
809 (setq dirlist (cons file dirlist)))
810 (setq files (cdr files)))
811 (setq dirlist (reverse dirlist))))
812 (error nil))
813 nil))
815 (defun ff-switch-file (f1 f2 file &optional in-other-window new-file)
816 "Call F1 or F2 on FILE, according to IN-OTHER-WINDOW.
817 In addition, this runs various hooks.
819 Either F1 or F2 receives FILE as the sole argument.
820 The decision of which one to call is based on IN-OTHER-WINDOW
821 and on the global variable `ff-always-in-other-window'.
823 F1 and F2 are typically `find-file' / `find-file-other-window'
824 or `switch-to-buffer' / `switch-to-buffer-other-window' function pairs.
826 If optional NEW-FILE is t, then a special hook (`ff-file-created-hook') is
827 called before `ff-post-load-hook'."
828 (run-hooks 'ff-pre-load-hook 'ff-pre-load-hooks)
829 (if (or
830 (and in-other-window (not ff-always-in-other-window))
831 (and (not in-other-window) ff-always-in-other-window))
832 (funcall f2 file)
833 (funcall f1 file))
834 (if new-file
835 (run-hooks 'ff-file-created-hook 'ff-file-created-hooks))
836 (run-hooks 'ff-post-load-hook 'ff-post-load-hooks))
838 (defun ff-find-file (file &optional in-other-window new-file)
839 "Like `find-file', but may show the file in another window."
840 (ff-switch-file 'find-file
841 'find-file-other-window
842 file in-other-window new-file))
844 (defun ff-switch-to-buffer (buffer-or-name &optional in-other-window)
845 "Like `switch-to-buffer', but may show the buffer in another window."
847 (ff-switch-file 'switch-to-buffer
848 'switch-to-buffer-other-window
849 buffer-or-name in-other-window nil))
851 ;;;###autoload
852 (defun ff-mouse-find-other-file (event)
853 "Visit the file you click on."
854 (interactive "e")
855 (save-excursion
856 (mouse-set-point event)
857 (ff-find-other-file nil)))
859 ;;;###autoload
860 (defun ff-mouse-find-other-file-other-window (event)
861 "Visit the file you click on in another window."
862 (interactive "e")
863 (save-excursion
864 (mouse-set-point event)
865 (ff-find-other-file t)))
867 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
868 ;; This section offers an example of user defined function to select files
870 (defun ff-upcase-p (string &optional start end)
871 "Return t if STRING is all uppercase.
872 Given START and/or END, checks between these characters."
873 (let (match str)
874 (if (not start)
875 (setq start 0))
876 (if (not end)
877 (setq end (length string)))
878 (if (= start end)
879 (setq end (1+ end)))
880 (setq str (substring string start end))
881 (if (and
882 (ff-string-match "[A-Z]+" str)
883 (setq match (match-data))
884 (= (car match) 0)
885 (= (car (cdr match)) (length str)))
887 nil)))
889 (defun ff-cc-hh-converter (arg)
890 "Discriminate file extensions.
891 Build up a new file list based possibly on part of the directory name
892 and the name of the file passed in."
893 (ff-string-match "\\(.*\\)/\\([^/]+\\)/\\([^.]+\\).\\([^/]+\\)$" arg)
894 (let ((path (if (match-beginning 1)
895 (substring arg (match-beginning 1) (match-end 1)) nil))
896 (dire (if (match-beginning 2)
897 (substring arg (match-beginning 2) (match-end 2)) nil))
898 (file (if (match-beginning 3)
899 (substring arg (match-beginning 3) (match-end 3)) nil))
900 (extn (if (match-beginning 4)
901 (substring arg (match-beginning 4) (match-end 4)) nil))
902 return-list)
903 (cond
904 ;; fooZapJunk.cc => ZapJunk.{hh,h} or fooZapJunk.{hh,h}
905 ((and (string= extn "cc")
906 (ff-string-match "^\\([a-z]+\\)\\([A-Z].+\\)$" file))
907 (let ((stub (substring file (match-beginning 2) (match-end 2))))
908 (setq dire (upcase (substring file (match-beginning 1) (match-end 1))))
909 (setq return-list (list (concat stub ".hh")
910 (concat stub ".h")
911 (concat file ".hh")
912 (concat file ".h")))
914 ;; FOO/ZapJunk.hh => fooZapJunk.{cc,C} or ZapJunk.{cc,C}
915 ((and (string= extn "hh") (ff-upcase-p dire) file)
916 (let ((stub (concat (downcase dire) file)))
917 (setq return-list (list (concat stub ".cc")
918 (concat stub ".C")
919 (concat file ".cc")
920 (concat file ".C")))
922 ;; zap.cc => zap.hh or zap.h
923 ((string= extn "cc")
924 (let ((stub file))
925 (setq return-list (list (concat stub ".hh")
926 (concat stub ".h")))
928 ;; zap.hh => zap.cc or zap.C
929 ((string= extn "hh")
930 (let ((stub file))
931 (setq return-list (list (concat stub ".cc")
932 (concat stub ".C")))
935 nil))
937 return-list))
939 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
940 ;; This section offers an example of user defined function to place point.
941 ;; The regexps are Ada specific.
943 (defvar ff-function-name nil "Name of the function we are in.")
945 ;; bind with (setq ff-pre-load-hook 'ff-which-function-are-we-in)
947 (defvar ada-procedure-start-regexp)
948 (defvar ada-package-start-regexp)
950 (defun ff-which-function-are-we-in ()
951 "Return the name of the function whose definition/declaration point is in.
952 Also remember that name in `ff-function-name'."
953 (setq ff-function-name
954 (save-excursion
955 (if (or (re-search-backward ada-procedure-start-regexp nil t)
956 (re-search-backward ada-package-start-regexp nil t))
957 (match-string 0)))))
959 ;; bind with (setq ff-post-load-hook 'ff-set-point-accordingly)
961 (defun ff-set-point-accordingly ()
962 "Find the function specified in `ff-function-name'.
963 That name was previously determined by `ff-which-function-are-we-in'."
964 (if ff-function-name
965 (progn
966 (goto-char (point-min))
967 (search-forward ff-function-name nil t))))
969 (provide 'find-file)
971 ;; arch-tag: 5a2fc49e-3b0a-4708-9acf-fb14e471a97a
972 ;;; find-file.el ends here