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