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, 2001, 2002, 2003, 2004,
   8 ;;   2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   9
  10 ;; This file is part of GNU Emacs.
  11
  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.
  16
  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.
  21
  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/>.
  24
  25 ;;; Commentary:
  26
  27 ;; PURPOSE:
  28 ;; This package features a function called ff-find-other-file, which performs
  29 ;; the following function:
  30 ;;
  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.
  33 ;;
  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.
  38 ;;
  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:
  42 ;;
  43 ;;   '(("\\.cc$"  (".hh" ".h"))
  44 ;;     ("\\.hh$"  (".cc" ".C" ".CC" ".cxx" ".cpp")))
  45 ;;
  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.
  50 ;;
  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:
  58 ;;
  59 ;;   '(("\\.cc$"  cc--function)
  60 ;;     ("\\.hh$"  hh-function))
  61 ;;
  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:
  66 ;;
  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"))))
  72 ;;
  73 ;; ff-cc-hh-converter is included at the end of this file as a reference.
  74 ;;
  75 ;; SEARCHING is carried out in a set of directories specified by the
  76 ;; ff-search-directories variable:
  77 ;;
  78 ;;     ("." "../../src" "../include/*" "/usr/local/*/src/*" "$PROJECT/src")
  79 ;;
  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.
  86 ;;
  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.
  90 ;;
  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.
  94 ;;
  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.
 100 ;;
 101 ;; THERE ARE FIVE AVAILABLE HOOKS, called in this order if non-nil:
 102 ;;
 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'
 108 ;;
 109 ;; The *load-hook allow you to place point where you want it in the other
 110 ;; file.
 111
 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.
 115 ;;
 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.
 121
 122 ;;; Code:
 123 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 124 ;; User definable variables:
 125
 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)
 131
 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)
 136
 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)
 141
 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)
 146
 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)
 151
 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)
 156
 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)
 162
 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)
 168
 169 (defcustom ff-ignore-include nil
 170   "If non-nil, ignore `#include' lines."
 171   :type 'boolean
 172   :group 'ff)
 173
 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)
 178
 179 (defcustom ff-quiet-mode nil
 180   "If non-nil, trace which directories are being searched."
 181   :type 'boolean
 182   :group 'ff)
 183
 184 ;;;###autoload
 185 (defvar ff-special-constructs
 186   `(
 187     ;; C/C++ include, for NeXTSTEP too
 188     (,(purecopy "^\#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]") .
 189      (lambda ()
 190        (buffer-substring (match-beginning 2) (match-end 2))))
 191     )
 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.")
 200
 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.
 204
 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)
 213
 214 (defcustom ff-search-directories 'cc-search-directories
 215   "List of directories to search for a specific file.
 216
 217 Set by default to `cc-search-directories', expanded at run-time.
 218
 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.
 223
 224 A typical format is
 225
 226     '(\".\" \"/usr/include\" \"$PROJECT/*/include\")
 227
 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.
 231
 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)
 237
 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)
 243
 244 (defcustom cc-other-file-alist
 245   '(("\\.cc\\'"  (".hh" ".h"))
 246     ("\\.hh\\'"  (".cc" ".C"))
 247
 248     ("\\.c\\'"   (".h"))
 249     ("\\.h\\'"   (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))
 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   :type '(repeat (list regexp (choice (repeat string) function)))
 272   :group 'ff)
 273
 274 (defcustom modula2-other-file-alist
 275   '(
 276     ("\\.mi$" (".md")) ;; Modula-2 module definition
 277     ("\\.md$" (".mi")) ;; and implementation.
 278     )
 279   "See the description for the `ff-search-directories' variable."
 280   :type '(repeat (list regexp (choice (repeat string) function)))
 281   :group 'ff)
 282
 283
 284 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 285 ;; No user definable variables beyond this point!
 286 ;; ==============================================
 287
 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)
 299
 300 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 301 ;; User entry points
 302
 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'.
 307
 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)))
 314
 315 ;;;###autoload
 316 (defalias 'ff-find-related-file 'ff-find-other-file)
 317
 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.
 322
 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.
 325
 326 Variables of interest include:
 327
 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.
 331
 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'.
 335
 336  - `ff-ignore-include'
 337    If non-nil, ignores #include lines.
 338
 339  - `ff-always-try-to-create'
 340    If non-nil, always attempt to create the other file if it was not found.
 341
 342  - `ff-quiet-mode'
 343    If non-nil, traces which directories are being searched.
 344
 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.
 349
 350  - `ff-other-file-alist'
 351    Alist of extensions to find given the current file's extension.
 352
 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.
 356
 357  - `ff-pre-find-hook'
 358    List of functions to be called before the search for the file starts.
 359
 360  - `ff-pre-load-hook'
 361    List of functions to be called before the other file is loaded.
 362
 363  - `ff-post-load-hook'
 364    List of functions to be called after the other file is loaded.
 365
 366  - `ff-not-found-hook'
 367    List of functions to be called if the other file could not be found.
 368
 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)))
 376
 377 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 378 ;; Support functions
 379
 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.
 384
 385 If optional IN-OTHER-WINDOW is non-nil, find the file in another window."
 386
 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
 400
 401     (run-hooks 'ff-pre-find-hook 'ff-pre-find-hooks)
 402
 403     (message "Working...")
 404
 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)))
 409
 410     (setq fname (ff-treat-as-special))
 411
 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)))
 416
 417      ;; let's just get the corresponding file
 418      (t
 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"))
 425
 426       (setq fname (file-name-nondirectory pathname)
 427             no-match nil
 428             match (car alist))
 429
 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)))
 436
 437       ;; no point going on if we haven't found anything
 438       (if (not match)
 439           (setq no-match t)
 440
 441         ;; otherwise, suffixes contains what we need
 442         (setq suffixes (car (cdr match))
 443               action (car (cdr match))
 444               found nil)
 445
 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)))
 454
 455           ;; otherwise build our filename stub
 456           (cond
 457
 458            ;; get around the problem that 0 and nil both mean false!
 459            ((= pos 0)
 460             (setq format "")
 461             (setq stub "")
 462             )
 463
 464            (t
 465             (setq format (concat "\\(.+\\)" (car match)))
 466             (string-match format fname)
 467             (setq stub (substring fname (match-beginning 1) (match-end 1)))
 468             ))
 469
 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))))))
 473
 474         ;; do the real work - find the file
 475         (setq found
 476               (ff-get-file dirs
 477                            stub
 478                            suffixes
 479                            in-other-window)))))
 480
 481     (cond
 482      (no-match                     ;; could not even determine the other file
 483       (message ""))
 484
 485      (t
 486       (cond
 487
 488        ((not found)                ;; could not find the other file
 489
 490         (run-hooks 'ff-not-found-hook 'ff-not-found-hooks)
 491
 492         (cond
 493          (ff-always-try-to-create  ;; try to create the file
 494           (let (name pathname)
 495
 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)))
 501
 502             (setq pathname
 503                   (if (file-directory-p name)
 504                       (concat (file-name-as-directory name) default-name)
 505                     (setq found name)))
 506
 507             (ff-find-file pathname in-other-window t)))
 508
 509          (t                        ;; don't create the file, just whinge
 510           (message "No file found for %s" fname))))
 511
 512        (t                          ;; matching file found
 513         nil))))
 514
 515     found))                        ;; return buffer-name or filename
 516
 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."
 521
 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
 535
 536     (message "Working...")
 537
 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)))
 542
 543     (setq fname (ff-treat-as-special))
 544
 545     (cond
 546      ((and (not ff-ignore-include) fname)
 547       (setq default-name fname)
 548       (setq found (ff-get-file-name dirs fname nil)))
 549
 550      ;; let's just get the corresponding file
 551      (t
 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"))
 558
 559       (setq fname (file-name-nondirectory pathname)
 560             no-match nil
 561             match (car alist))
 562
 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)))
 569
 570       ;; no point going on if we haven't found anything
 571       (if (not match)
 572           (setq no-match t)
 573
 574         ;; otherwise, suffixes contains what we need
 575         (setq suffixes (car (cdr match))
 576               action (car (cdr match))
 577               found nil)
 578
 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)))
 587
 588           ;; otherwise build our filename stub
 589           (cond
 590
 591            ;; get around the problem that 0 and nil both mean false!
 592            ((= pos 0)
 593             (setq format "")
 594             (setq stub "")
 595             )
 596
 597            (t
 598             (setq format (concat "\\(.+\\)" (car match)))
 599             (string-match format fname)
 600             (setq stub (substring fname (match-beginning 1) (match-end 1)))
 601             ))
 602
 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))))))
 606
 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
 611
 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)))
 618
 619     (cond
 620      ((not filename)
 621       nil)
 622
 623      ((bufferp (get-file-buffer filename))
 624       (ff-switch-to-buffer (get-file-buffer filename) other-window)
 625       filename)
 626
 627      ((file-exists-p filename)
 628       (ff-find-file filename other-window nil)
 629       filename)
 630
 631      (t
 632       nil))))
 633
 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
 649
 650     (setq suffixes suffix-list)
 651
 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 "")))
 658
 659     ;; find whether the file is in a buffer first
 660     (while (and suffixes (not found))
 661       (setq filename (concat fname-stub this-suffix))
 662
 663       (if (not ff-quiet-mode)
 664           (message "Finding buffer %s..." filename))
 665
 666       (if (bufferp (get-file-buffer filename))
 667           (setq found (buffer-file-name (get-file-buffer filename))))
 668
 669       (setq blist (buffer-list))
 670       (setq buf (buffer-name (car blist)))
 671       (while (and blist (not found))
 672
 673         (if (string-match (concat filename "<[0-9]+>") buf)
 674             (setq found (buffer-file-name (car blist))))
 675
 676         (setq blist (cdr blist))
 677         (setq buf (buffer-name (car blist))))
 678
 679       (setq suffixes (cdr suffixes))
 680       (setq this-suffix (car suffixes)))
 681
 682     ;; now look for the real file
 683     (setq dirs search-dirs)
 684     (setq dir  (car dirs))
 685     (while (and (not found) dirs)
 686
 687       (setq suffixes suffix-list)
 688
 689       ;; if dir does not contain '/*', look for the file
 690       (if (and dir (not (string-match "\\([^*]*\\)/\\\*\\(/.*\\)*" dir)))
 691           (progn
 692
 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 "")))
 699
 700             (while (and suffixes (not found))
 701
 702               (setq filename (concat fname-stub this-suffix))
 703               (setq file (concat dir "/" filename))
 704
 705               (if (not ff-quiet-mode)
 706                   (message "Finding %s..." file))
 707
 708               (if (file-exists-p file)
 709                   (setq found file))
 710
 711               (setq suffixes (cdr suffixes))
 712               (setq this-suffix (car suffixes))))
 713
 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 "")
 719             )
 720           (setq dir  (substring dir (match-beginning 1) (match-end 1)))
 721
 722           (let ((dirlist (ff-all-dirs-under dir '("..")))
 723                 this-dir compl-dirs)
 724
 725             (setq this-dir (car dirlist))
 726             (while dirlist
 727               (setq compl-dirs
 728                     (append
 729                      compl-dirs
 730                      (list (concat this-dir rest))
 731                      ))
 732               (setq dirlist  (cdr dirlist))
 733               (setq this-dir (car dirlist)))
 734
 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)))
 741
 742     (if found
 743         (message "%s found" found))
 744
 745     found))
 746
 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))))
 753
 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))))
 769
 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)))
 788
 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))))
 794
 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))
 814
 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.
 818
 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'.
 822
 823 F1 and F2 are typically `find-file' / `find-file-other-window'
 824 or `switch-to-buffer' / `switch-to-buffer-other-window' function pairs.
 825
 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))
 837
 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))
 843
 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."
 846
 847   (ff-switch-file 'switch-to-buffer
 848                   'switch-to-buffer-other-window
 849                   buffer-or-name in-other-window nil))
 850
 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)))
 858
 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)))
 866
 867 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 868 ;; This section offers an example of user defined function to select files
 869
 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)))
 886         t
 887       nil)))
 888
 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")))
 913         ))
 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")))
 921         ))
 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")))
 927         ))
 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")))
 933         ))
 934      (t
 935       nil))
 936
 937     return-list))
 938
 939 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 940 ;; This section offers an example of user defined function to place point.
 941 ;; The regexps are Ada specific.
 942
 943 (defvar ff-function-name nil "Name of the function we are in.")
 944
 945 ;; bind with (setq ff-pre-load-hook 'ff-which-function-are-we-in)
 946 ;;
 947 (defvar ada-procedure-start-regexp)
 948 (defvar ada-package-start-regexp)
 949
 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)))))
 958
 959 ;; bind with (setq ff-post-load-hook 'ff-set-point-accordingly)
 960 ;;
 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))))
 968
 969 (provide 'find-file)
 970
 971 ;; arch-tag: 5a2fc49e-3b0a-4708-9acf-fb14e471a97a
 972 ;;; find-file.el ends here