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 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 (defvar ff-special-constructs
 186   '(
 187     ;; C/C++ include, for NeXTSTEP too
 188     ("^\#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]" .
 189      (lambda ()
 190        (setq fname (buffer-substring (match-beginning 2) (match-end 2)))))
 191     )
 192   "*A list of regular expressions for `ff-find-file'.
 193 Specifies how to recognise special constructs such as include files
 194 etc. and an associated method for extracting the filename from that
 195 construct.")
 196
 197 (defvaralias 'ff-related-file-alist 'ff-other-file-alist)
 198 (defcustom ff-other-file-alist 'cc-other-file-alist
 199   "*Alist of extensions to find given the current file's extension.
 200
 201 This list should contain the most used extensions before the others,
 202 since the search algorithm searches sequentially through each
 203 directory specified in `ff-search-directories'.  If a file is not found,
 204 a new one is created with the first matching extension (`.cc' yields `.hh').
 205 This alist should be set by the major mode."
 206   :type '(choice (repeat (list regexp (choice (repeat string) function)))
 207                  symbol)
 208   :group 'ff)
 209
 210 (defcustom ff-search-directories 'cc-search-directories
 211   "*List of directories to search for a specific file.
 212
 213 Set by default to `cc-search-directories', expanded at run-time.
 214
 215 This list is searched through with each extension specified in
 216 `ff-other-file-alist' that matches this file's extension.  So the
 217 longer the list, the longer it'll take to realise that a file
 218 may not exist.
 219
 220 A typical format is
 221
 222     '(\".\" \"/usr/include\" \"$PROJECT/*/include\")
 223
 224 Environment variables can be inserted between slashes (`/').
 225 They will be replaced by their definition. If a variable does
 226 not exist, it is replaced (silently) with an empty string.
 227
 228 The stars are *not* wildcards: they are searched for together with
 229 the preceding slash.  The star represents all the subdirectories except
 230 `..', and each of these subdirectories will be searched in turn."
 231   :type '(choice (repeat directory) symbol)
 232   :group 'ff)
 233
 234 (defcustom cc-search-directories
 235   '("." "/usr/include" "/usr/local/include/*")
 236   "*See the description of the `ff-search-directories' variable."
 237   :type '(repeat directory)
 238   :group 'ff)
 239
 240 (defcustom cc-other-file-alist
 241   '(
 242     ("\\.cc$"  (".hh" ".h"))
 243     ("\\.hh$"  (".cc" ".C"))
 244
 245     ("\\.c$"   (".h"))
 246     ("\\.h$"   (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))
 247
 248     ("\\.C$"   (".H"  ".hh" ".h"))
 249     ("\\.H$"   (".C"  ".CC"))
 250
 251     ("\\.CC$"  (".HH" ".H"  ".hh" ".h"))
 252     ("\\.HH$"  (".CC"))
 253
 254     ("\\.cxx$" (".hh" ".h"))
 255     ("\\.cpp$" (".hh" ".h"))
 256     )
 257   "*Alist of extensions to find given the current file's extension.
 258
 259 This list should contain the most used extensions before the others,
 260 since the search algorithm searches sequentially through each directory
 261 specified in `ff-search-directories'.  If a file is not found, a new one
 262 is created with the first matching extension (`.cc' yields `.hh')."
 263   :type '(repeat (list regexp (choice (repeat string) function)))
 264   :group 'ff)
 265
 266 (defcustom modula2-other-file-alist
 267   '(
 268     ("\\.mi$" (".md")) ;; Modula-2 module definition
 269     ("\\.md$" (".mi")) ;; and implementation.
 270     )
 271   "*See the description for the `ff-search-directories' variable."
 272   :type '(repeat (list regexp (choice (repeat string) function)))
 273   :group 'ff)
 274
 275
 276 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 277 ;; No user definable variables beyond this point!
 278 ;; ==============================================
 279
 280 (make-variable-buffer-local 'ff-pre-find-hook)
 281 (make-variable-buffer-local 'ff-pre-load-hook)
 282 (make-variable-buffer-local 'ff-post-load-hook)
 283 (make-variable-buffer-local 'ff-not-found-hook)
 284 (make-variable-buffer-local 'ff-file-created-hook)
 285 (make-variable-buffer-local 'ff-case-fold-search)
 286 (make-variable-buffer-local 'ff-always-in-other-window)
 287 (make-variable-buffer-local 'ff-ignore-include)
 288 (make-variable-buffer-local 'ff-quiet-mode)
 289 (make-variable-buffer-local 'ff-other-file-alist)
 290 (make-variable-buffer-local 'ff-search-directories)
 291
 292 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 293 ;; User entry points
 294
 295 ;;;###autoload
 296 (defun ff-get-other-file (&optional in-other-window)
 297   "Find the header or source file corresponding to this file.
 298 See also the documentation for `ff-find-other-file'.
 299
 300 If optional IN-OTHER-WINDOW is non-nil, find the file in another window."
 301   (interactive "P")
 302   (let ((ignore ff-ignore-include))
 303     (setq ff-ignore-include t)
 304     (ff-find-the-other-file in-other-window)
 305     (setq ff-ignore-include ignore)))
 306
 307 ;;;###autoload
 308 (defalias 'ff-find-related-file 'ff-find-other-file)
 309
 310 ;;;###autoload
 311 (defun ff-find-other-file (&optional in-other-window ignore-include)
 312   "Find the header or source file corresponding to this file.
 313 Being on a `#include' line pulls in that file.
 314
 315 If optional IN-OTHER-WINDOW is non-nil, find the file in the other window.
 316 If optional IGNORE-INCLUDE is non-nil, ignore being on `#include' lines.
 317
 318 Variables of interest include:
 319
 320  - `ff-case-fold-search'
 321    Non-nil means ignore cases in matches (see `case-fold-search').
 322    If you have extensions in different cases, you will want this to be nil.
 323
 324  - `ff-always-in-other-window'
 325    If non-nil, always open the other file in another window, unless an
 326    argument is given to `ff-find-other-file'.
 327
 328  - `ff-ignore-include'
 329    If non-nil, ignores #include lines.
 330
 331  - `ff-always-try-to-create'
 332    If non-nil, always attempt to create the other file if it was not found.
 333
 334  - `ff-quiet-mode'
 335    If non-nil, traces which directories are being searched.
 336
 337  - `ff-special-constructs'
 338    A list of regular expressions specifying how to recognise special
 339    constructs such as include files etc, and an associated method for
 340    extracting the filename from that construct.
 341
 342  - `ff-other-file-alist'
 343    Alist of extensions to find given the current file's extension.
 344
 345  - `ff-search-directories'
 346    List of directories searched through with each extension specified in
 347    `ff-other-file-alist' that matches this file's extension.
 348
 349  - `ff-pre-find-hook'
 350    List of functions to be called before the search for the file starts.
 351
 352  - `ff-pre-load-hook'
 353    List of functions to be called before the other file is loaded.
 354
 355  - `ff-post-load-hook'
 356    List of functions to be called after the other file is loaded.
 357
 358  - `ff-not-found-hook'
 359    List of functions to be called if the other file could not be found.
 360
 361  - `ff-file-created-hook'
 362    List of functions to be called if the other file has been created."
 363   (interactive "P")
 364   (let ((ignore ff-ignore-include))
 365     (setq ff-ignore-include ignore-include)
 366     (ff-find-the-other-file in-other-window)
 367     (setq ff-ignore-include ignore)))
 368
 369 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 370 ;; Support functions
 371
 372 (defun ff-find-the-other-file (&optional in-other-window)
 373   "Find the header or source file corresponding to the current file.
 374 Being on a `#include' line pulls in that file, but see the help on
 375 the `ff-ignore-include' variable.
 376
 377 If optional IN-OTHER-WINDOW is non-nil, find the file in another window."
 378
 379   (let (match           ;; matching regexp for this file
 380         suffixes        ;; set of replacing regexps for the matching regexp
 381         action          ;; function to generate the names of the other files
 382         fname           ;; basename of this file
 383         pos             ;; where we start matching filenames
 384         stub            ;; name of the file without extension
 385         alist           ;; working copy of the list of file extensions
 386         pathname        ;; the pathname of the file or the #include line
 387         default-name    ;; file we should create if none found
 388         format          ;; what we have to match
 389         found           ;; name of the file or buffer found - nil if none
 390         dirs            ;; local value of ff-search-directories
 391         no-match)       ;; whether we know about this kind of file
 392
 393     (run-hooks 'ff-pre-find-hook 'ff-pre-find-hooks)
 394
 395     (message "Working...")
 396
 397     (setq dirs
 398           (if (symbolp ff-search-directories)
 399               (ff-list-replace-env-vars (symbol-value ff-search-directories))
 400             (ff-list-replace-env-vars ff-search-directories)))
 401
 402     (save-excursion
 403       (beginning-of-line 1)
 404       (setq fname (ff-treat-as-special)))
 405
 406     (cond
 407      ((and (not ff-ignore-include) fname)
 408       (setq default-name fname)
 409       (setq found (ff-get-file dirs fname nil in-other-window)))
 410
 411      ;; let's just get the corresponding file
 412      (t
 413       (setq alist (if (symbolp ff-other-file-alist)
 414                       (symbol-value ff-other-file-alist)
 415                     ff-other-file-alist)
 416             pathname (if (buffer-file-name)
 417                          (buffer-file-name)
 418                        "/none.none"))
 419
 420       (setq fname (file-name-nondirectory pathname)
 421             no-match nil
 422             match (car alist))
 423
 424       ;; find the table entry corresponding to this file
 425       (setq pos (ff-string-match (car match) fname))
 426       (while (and match (if (and pos (>= pos 0)) nil (not pos)))
 427         (setq alist (cdr alist))
 428         (setq match (car alist))
 429         (setq pos (ff-string-match (car match) fname)))
 430
 431       ;; no point going on if we haven't found anything
 432       (if (not match)
 433           (setq no-match t)
 434
 435         ;; otherwise, suffixes contains what we need
 436         (setq suffixes (car (cdr match))
 437               action (car (cdr match))
 438               found nil)
 439
 440         ;; if we have a function to generate new names,
 441         ;; invoke it with the name of the current file
 442         (if (and (atom action) (fboundp action))
 443             (progn
 444               (setq suffixes (funcall action (buffer-file-name))
 445                     match (cons (car match) (list suffixes))
 446                     stub nil
 447                     default-name (car suffixes)))
 448
 449           ;; otherwise build our filename stub
 450           (cond
 451
 452            ;; get around the problem that 0 and nil both mean false!
 453            ((= pos 0)
 454             (setq format "")
 455             (setq stub "")
 456             )
 457
 458            (t
 459             (setq format (concat "\\(.+\\)" (car match)))
 460             (string-match format fname)
 461             (setq stub (substring fname (match-beginning 1) (match-end 1)))
 462             ))
 463
 464           ;; if we find nothing, we should try to get a file like this one
 465           (setq default-name
 466                 (concat stub (car (car (cdr match))))))
 467
 468         ;; do the real work - find the file
 469         (setq found
 470               (ff-get-file dirs
 471                            stub
 472                            suffixes
 473                            in-other-window)))))
 474
 475     (cond
 476      (no-match                     ;; could not even determine the other file
 477       (message ""))
 478
 479      (t
 480       (cond
 481
 482        ((not found)                ;; could not find the other file
 483
 484         (run-hooks 'ff-not-found-hook 'ff-not-found-hooks)
 485
 486         (cond
 487          (ff-always-try-to-create  ;; try to create the file
 488           (let (name pathname)
 489
 490             (setq name
 491                   (expand-file-name
 492                    (read-file-name
 493                     (format "Find or create %s in: " default-name)
 494                     default-directory default-name nil)))
 495
 496             (setq pathname
 497                   (if (file-directory-p name)
 498                       (concat (file-name-as-directory name) default-name)
 499                     (setq found name)))
 500
 501             (ff-find-file pathname in-other-window t)))
 502
 503          (t                        ;; don't create the file, just whinge
 504           (message "No file found for %s" fname))))
 505
 506        (t                          ;; matching file found
 507         nil))))
 508
 509     found))                        ;; return buffer-name or filename
 510
 511 (defun ff-other-file-name ()
 512   "Return name of the header or source file corresponding to the current file.
 513 Being on a `#include' line pulls in that file, but see the help on
 514 the `ff-ignore-include' variable."
 515
 516   (let (match           ;; matching regexp for this file
 517         suffixes        ;; set of replacing regexps for the matching regexp
 518         action          ;; function to generate the names of the other files
 519         fname           ;; basename of this file
 520         pos             ;; where we start matching filenames
 521         stub            ;; name of the file without extension
 522         alist           ;; working copy of the list of file extensions
 523         pathname        ;; the pathname of the file or the #include line
 524         default-name    ;; file we should create if none found
 525         format          ;; what we have to match
 526         found           ;; name of the file or buffer found - nil if none
 527         dirs            ;; local value of ff-search-directories
 528         no-match)       ;; whether we know about this kind of file
 529
 530     (message "Working...")
 531
 532     (setq dirs
 533           (if (symbolp ff-search-directories)
 534               (ff-list-replace-env-vars (symbol-value ff-search-directories))
 535             (ff-list-replace-env-vars ff-search-directories)))
 536
 537     (save-excursion
 538       (beginning-of-line 1)
 539       (setq fname (ff-treat-as-special)))
 540
 541     (cond
 542      ((and (not ff-ignore-include) fname)
 543       (setq default-name fname)
 544       (setq found (ff-get-file-name dirs fname nil)))
 545
 546      ;; let's just get the corresponding file
 547      (t
 548       (setq alist (if (symbolp ff-other-file-alist)
 549                       (symbol-value ff-other-file-alist)
 550                     ff-other-file-alist)
 551             pathname (if (buffer-file-name)
 552                          (buffer-file-name)
 553                        "/none.none"))
 554
 555       (setq fname (file-name-nondirectory pathname)
 556             no-match nil
 557             match (car alist))
 558
 559       ;; find the table entry corresponding to this file
 560       (setq pos (ff-string-match (car match) fname))
 561       (while (and match (if (and pos (>= pos 0)) nil (not pos)))
 562         (setq alist (cdr alist))
 563         (setq match (car alist))
 564         (setq pos (ff-string-match (car match) fname)))
 565
 566       ;; no point going on if we haven't found anything
 567       (if (not match)
 568           (setq no-match t)
 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                     default-name (car suffixes)))
 583
 584           ;; otherwise build our filename stub
 585           (cond
 586
 587            ;; get around the problem that 0 and nil both mean false!
 588            ((= pos 0)
 589             (setq format "")
 590             (setq stub "")
 591             )
 592
 593            (t
 594             (setq format (concat "\\(.+\\)" (car match)))
 595             (string-match format fname)
 596             (setq stub (substring fname (match-beginning 1) (match-end 1)))
 597             ))
 598
 599           ;; if we find nothing, we should try to get a file like this one
 600           (setq default-name
 601                 (concat stub (car (car (cdr match))))))
 602
 603         ;; do the real work - find the file
 604         (setq found
 605               (ff-get-file-name dirs stub suffixes)))))
 606     found))                        ;; return buffer-name or filename
 607
 608 (defun ff-get-file (search-dirs filename &optional suffix-list other-window)
 609   "Find a file in the SEARCH-DIRS with the given FILENAME (or filename stub).
 610 If (optional) SUFFIX-LIST is nil, search for fname, otherwise search
 611 for fname with each of the given suffixes.  Get the file or the buffer
 612 corresponding to the name of the first file found, or nil."
 613   (let ((filename (ff-get-file-name search-dirs filename suffix-list)))
 614
 615     (cond
 616      ((not filename)
 617       nil)
 618
 619      ((bufferp (get-file-buffer filename))
 620       (ff-switch-to-buffer (get-file-buffer filename) other-window)
 621       filename)
 622
 623      ((file-exists-p filename)
 624       (ff-find-file filename other-window nil)
 625       filename)
 626
 627      (t
 628       nil))))
 629
 630 (defun ff-get-file-name (search-dirs fname-stub &optional suffix-list)
 631   "Find a file in SEARCH-DIRS with the given name (or stub) FNAME-STUB.
 632 If (optional) SUFFIX-LIST is nil, search for FNAME-STUB, otherwise
 633 search for FNAME-STUB with each of the given suffixes.  Return the
 634 name of the first file found."
 635   (let* (dirs         ;; working copy of dirs to search
 636          dir          ;; the current dir considered
 637          file         ;; filename being looked for
 638          rest         ;; pathname after first /*
 639          this-suffix  ;; the suffix we are currently considering
 640          suffixes     ;; working copy of suffix-list
 641          filename     ;; built filename
 642          blist        ;; list of live buffers
 643          buf          ;; current buffer in blist
 644          found)       ;; whether we have found anything
 645
 646     (setq suffixes suffix-list)
 647
 648     ;; suffixes is nil => fname-stub is the file we are looking for
 649     ;; otherwise fname-stub is a stub, and we append a suffix
 650     (if suffixes
 651         (setq this-suffix (car suffixes))
 652       (setq this-suffix "")
 653       (setq suffixes (list "")))
 654
 655     ;; find whether the file is in a buffer first
 656     (while (and suffixes (not found))
 657       (setq filename (concat fname-stub this-suffix))
 658
 659       (if (not ff-quiet-mode)
 660           (message "Finding buffer %s..." filename))
 661
 662       (if (bufferp (get-file-buffer filename))
 663           (setq found (buffer-file-name (get-file-buffer filename))))
 664
 665       (setq blist (buffer-list))
 666       (setq buf (buffer-name (car blist)))
 667       (while (and blist (not found))
 668
 669         (if (string-match (concat filename "<[0-9]+>") buf)
 670             (setq found (buffer-file-name (car blist))))
 671
 672         (setq blist (cdr blist))
 673         (setq buf (buffer-name (car blist))))
 674
 675       (setq suffixes (cdr suffixes))
 676       (setq this-suffix (car suffixes)))
 677
 678     ;; now look for the real file
 679     (setq dirs search-dirs)
 680     (setq dir  (car dirs))
 681     (while (and (not found) dirs)
 682
 683       (setq suffixes suffix-list)
 684
 685       ;; if dir does not contain '/*', look for the file
 686       (if (and dir (not (string-match "\\([^*]*\\)/\\\*\\(/.*\\)*" dir)))
 687           (progn
 688
 689             ;; suffixes is nil => fname-stub is the file we are looking for
 690             ;; otherwise fname-stub is a stub, and we append a suffix
 691             (if suffixes
 692                 (setq this-suffix (car suffixes))
 693               (setq this-suffix "")
 694               (setq suffixes (list "")))
 695
 696             (while (and suffixes (not found))
 697
 698               (setq filename (concat fname-stub this-suffix))
 699               (setq file (concat dir "/" filename))
 700
 701               (if (not ff-quiet-mode)
 702                   (message "Finding %s..." file))
 703
 704               (if (file-exists-p file)
 705                   (setq found file))
 706
 707               (setq suffixes (cdr suffixes))
 708               (setq this-suffix (car suffixes))))
 709
 710         ;; otherwise dir matches the '/*', so search each dir separately
 711         (progn
 712           (if (match-beginning 2)
 713               (setq rest (substring dir (match-beginning 2) (match-end 2)))
 714             (setq rest "")
 715             )
 716           (setq dir  (substring dir (match-beginning 1) (match-end 1)))
 717
 718           (let ((dirlist (ff-all-dirs-under dir '("..")))
 719                 this-dir compl-dirs)
 720
 721             (setq this-dir (car dirlist))
 722             (while dirlist
 723               (setq compl-dirs
 724                     (append
 725                      compl-dirs
 726                      (list (concat this-dir rest))
 727                      ))
 728               (setq dirlist  (cdr dirlist))
 729               (setq this-dir (car dirlist)))
 730
 731             (if compl-dirs
 732                 (setq found (ff-get-file-name compl-dirs
 733                                               fname-stub
 734                                               suffix-list))))))
 735       (setq dirs (cdr dirs))
 736       (setq dir (car dirs)))
 737
 738     (if found
 739         (message "%s found" found))
 740
 741     found))
 742
 743 (defun ff-string-match (regexp string &optional start)
 744   "Like `string-match', but set `case-fold-search' temporarily.
 745 The value used comes from `ff-case-fold-search'."
 746   (let ((case-fold-search ff-case-fold-search))
 747     (if regexp
 748         (string-match regexp string start))))
 749
 750 (defun ff-list-replace-env-vars (search-list)
 751   "Replace environment variables (of the form $VARIABLE) in SEARCH-LIST."
 752   (let (list
 753         (var (car search-list)))
 754     (while search-list
 755       (if (string-match "\\(.*\\)\\$[({]*\\([a-zA-Z0-9_]+\\)[)}]*\\(.*\\)" var)
 756           (setq var
 757                 (concat
 758                  (substring var (match-beginning 1) (match-end 1))
 759                  (getenv (substring var (match-beginning 2) (match-end 2)))
 760                  (substring var (match-beginning 3) (match-end 3)))))
 761       (setq search-list (cdr search-list))
 762       (setq list (cons var list))
 763       (setq var (car search-list)))
 764     (setq search-list (reverse list))))
 765
 766 (defun ff-treat-as-special ()
 767   "Return the file to look for if the construct was special, else nil.
 768 The construct is defined in the variable `ff-special-constructs'."
 769   (let* (fname
 770          (list ff-special-constructs)
 771          (elem (car list))
 772          (regexp (car elem))
 773          (match (cdr elem)))
 774     (while (and list (not fname))
 775       (if (and (looking-at regexp) match)
 776           (setq fname (funcall match)))
 777       (setq list (cdr list))
 778       (setq elem (car list))
 779       (setq regexp (car elem))
 780       (setq match (cdr elem)))
 781     fname))
 782
 783 (defun ff-basename (string)
 784   "Return the basename of pathname STRING."
 785   (setq string (concat "/" string))
 786   (string-match ".*/\\([^/]+\\)$" string)
 787   (setq string (substring string (match-beginning 1) (match-end 1))))
 788
 789 (defun ff-all-dirs-under (here &optional exclude)
 790   "Get all the directory files under directory HERE.
 791 Exclude all files in the optional EXCLUDE list."
 792   (if (file-directory-p here)
 793       (condition-case nil
 794           (progn
 795             (let ((files (directory-files here t))
 796                   (dirlist (list))
 797                   file)
 798               (while files
 799                 (setq file (car files))
 800                 (if (and
 801                      (file-directory-p file)
 802                      (not (member (ff-basename file) exclude)))
 803                     (setq dirlist (cons file dirlist)))
 804                 (setq files (cdr files)))
 805               (setq dirlist (reverse dirlist))))
 806         (error nil))
 807     nil))
 808
 809 (defun ff-switch-file (f1 f2 file &optional in-other-window new-file)
 810   "Call F1 or F2 on FILE, according to IN-OTHER-WINDOW.
 811 In addition, this runs various hooks.
 812
 813 Either F1 or F2 receives FILE as the sole argument.
 814 The decision of which one to call is based on IN-OTHER-WINDOW
 815 and on the global variable `ff-always-in-other-window'.
 816
 817 F1 and F2 are typically `find-file' / `find-file-other-window'
 818 or `switch-to-buffer' / `switch-to-buffer-other-window' function pairs.
 819
 820 If optional NEW-FILE is t, then a special hook (`ff-file-created-hook') is
 821 called before `ff-post-load-hook'."
 822   (run-hooks 'ff-pre-load-hook 'ff-pre-load-hooks)
 823   (if (or
 824        (and in-other-window (not ff-always-in-other-window))
 825        (and (not in-other-window) ff-always-in-other-window))
 826       (funcall f2 file)
 827     (funcall f1 file))
 828   (if new-file
 829       (run-hooks 'ff-file-created-hook 'ff-file-created-hooks))
 830   (run-hooks 'ff-post-load-hook 'ff-post-load-hooks))
 831
 832 (defun ff-find-file (file &optional in-other-window new-file)
 833   "Like `find-file', but may show the file in another window."
 834   (ff-switch-file 'find-file
 835                   'find-file-other-window
 836                   file in-other-window new-file))
 837
 838 (defun ff-switch-to-buffer (buffer-or-name &optional in-other-window)
 839   "Like `switch-to-buffer', but may show the buffer in another window."
 840
 841   (ff-switch-file 'switch-to-buffer
 842                   'switch-to-buffer-other-window
 843                   buffer-or-name in-other-window nil))
 844
 845 ;;;###autoload
 846 (defun ff-mouse-find-other-file (event)
 847   "Visit the file you click on."
 848   (interactive "e")
 849   (save-excursion
 850     (mouse-set-point event)
 851     (ff-find-other-file nil)))
 852
 853 ;;;###autoload
 854 (defun ff-mouse-find-other-file-other-window (event)
 855   "Visit the file you click on in another window."
 856   (interactive "e")
 857   (save-excursion
 858     (mouse-set-point event)
 859     (ff-find-other-file t)))
 860
 861 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 862 ;; This section offers an example of user defined function to select files
 863
 864 (defun ff-upcase-p (string &optional start end)
 865   "Return t if STRING is all uppercase.
 866 Given START and/or END, checks between these characters."
 867   (let (match str)
 868     (if (not start)
 869         (setq start 0))
 870     (if (not end)
 871         (setq end (length string)))
 872     (if (= start end)
 873         (setq end (1+ end)))
 874     (setq str (substring string start end))
 875     (if (and
 876          (ff-string-match "[A-Z]+" str)
 877          (setq match (match-data))
 878          (= (car match) 0)
 879          (= (car (cdr match)) (length str)))
 880         t
 881       nil)))
 882
 883 (defun ff-cc-hh-converter (arg)
 884   "Discriminate file extensions.
 885 Build up a new file list based possibly on part of the directory name
 886 and the name of the file passed in."
 887   (ff-string-match "\\(.*\\)/\\([^/]+\\)/\\([^.]+\\).\\([^/]+\\)$" arg)
 888   (let ((path (if (match-beginning 1)
 889                   (substring arg (match-beginning 1) (match-end 1)) nil))
 890         (dire (if (match-beginning 2)
 891                   (substring arg (match-beginning 2) (match-end 2)) nil))
 892         (file (if (match-beginning 3)
 893                   (substring arg (match-beginning 3) (match-end 3)) nil))
 894         (extn (if (match-beginning 4)
 895                   (substring arg (match-beginning 4) (match-end 4)) nil))
 896         return-list)
 897     (cond
 898      ;; fooZapJunk.cc => ZapJunk.{hh,h} or fooZapJunk.{hh,h}
 899      ((and (string= extn "cc")
 900            (ff-string-match "^\\([a-z]+\\)\\([A-Z].+\\)$" file))
 901       (let ((stub  (substring file (match-beginning 2) (match-end 2))))
 902         (setq dire (upcase (substring file (match-beginning 1) (match-end 1))))
 903         (setq return-list (list (concat stub ".hh")
 904                                 (concat stub ".h")
 905                                 (concat file ".hh")
 906                                 (concat file ".h")))
 907         ))
 908      ;; FOO/ZapJunk.hh => fooZapJunk.{cc,C} or ZapJunk.{cc,C}
 909      ((and (string= extn "hh") (ff-upcase-p dire) file)
 910       (let ((stub (concat (downcase dire) file)))
 911         (setq return-list (list (concat stub ".cc")
 912                                 (concat stub ".C")
 913                                 (concat file ".cc")
 914                                 (concat file ".C")))
 915         ))
 916      ;; zap.cc => zap.hh or zap.h
 917      ((string= extn "cc")
 918       (let ((stub file))
 919         (setq return-list (list (concat stub ".hh")
 920                                 (concat stub ".h")))
 921         ))
 922      ;; zap.hh => zap.cc or zap.C
 923      ((string= extn "hh")
 924       (let ((stub file))
 925         (setq return-list (list (concat stub ".cc")
 926                                 (concat stub ".C")))
 927         ))
 928      (t
 929       nil))
 930
 931     return-list))
 932
 933 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 934 ;; This section offers an example of user defined function to place point.
 935 ;; The regexps are Ada specific.
 936
 937 (defvar ff-function-name nil "Name of the function we are in.")
 938
 939 ;; bind with (setq ff-pre-load-hook 'ff-which-function-are-we-in)
 940 ;;
 941 (defun ff-which-function-are-we-in ()
 942   "Return the name of the function whose definition/declaration point is in.
 943 Also remember that name in `ff-function-name'."
 944
 945   (setq ff-function-name nil)
 946
 947   (save-excursion
 948     (if (re-search-backward ada-procedure-start-regexp nil t)
 949         (setq ff-function-name (buffer-substring (match-beginning 0)
 950                                                  (match-end 0)))
 951       ; we didn't find a procedure start, perhaps there is a package
 952       (if (re-search-backward ada-package-start-regexp nil t)
 953           (setq ff-function-name (buffer-substring (match-beginning 0)
 954                                                    (match-end 0)))
 955         ))))
 956
 957 ;; bind with (setq ff-post-load-hook 'ff-set-point-accordingly)
 958 ;;
 959 (defun ff-set-point-accordingly ()
 960   "Find the function specified in `ff-function-name'.
 961 That name was previously determined by `ff-which-function-are-we-in'."
 962   (if ff-function-name
 963       (progn
 964         (goto-char (point-min))
 965         (search-forward ff-function-name nil t))))
 966
 967 (provide 'find-file)
 968
 969 ;;; find-file.el ends here