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