;; Maintainer: FSF
;; Keywords: c, matching, tools
-;; Copyright (C) 1994, 1995, 2002 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 2001, 2002, 2003, 2004,
+;; 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 2, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; format above can be changed to include a function to be called when the
;; current file matches the regexp:
;;
-;; '(("\\.cc$" cc-function)
+;; '(("\\.cc$" cc--function)
;; ("\\.hh$" hh-function))
;;
;; These functions must return a list consisting of the possible names of the
;; ("\\.hh$" ff-cc-hh-converter)
;; ("\\.c$" (".h"))
;; ("\\.h$" (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))))
-;;
+;;
;; ff-cc-hh-converter is included at the end of this file as a reference.
-;;
+;;
;; SEARCHING is carried out in a set of directories specified by the
;; ff-search-directories variable:
;;
:type 'boolean
:group 'ff)
+;;;###autoload
(defvar ff-special-constructs
'(
;; C/C++ include, for NeXTSTEP too
("^\#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]" .
(lambda ()
- (setq fname (buffer-substring (match-beginning 2) (match-end 2)))))
-
- ;; Ada import
- ("^with[ \t]+\\([a-zA-Z0-9_\\.]+\\)" .
- (lambda ()
- (setq fname (buffer-substring (match-beginning 1) (match-end 1)))
- (require 'ada-mode)
- (setq fname (concat (ada-make-filename-from-adaname fname)
- ada-spec-suffix))))
+ (buffer-substring (match-beginning 2) (match-end 2))))
)
- "*A list of regular expressions for `ff-find-file'.
-Specifies how to recognise special constructs such as include files
-etc. and an associated method for extracting the filename from that
-construct.")
-
+ ;; We include `ff-treat-as-special' documentation here so that autoload
+ ;; can make it available to be read prior to loading this file.
+ "*List of special constructs for `ff-treat-as-special' to recognize.
+Each element, tried in order, has the form (REGEXP . EXTRACT).
+If REGEXP matches the current line (from the beginning of the line),
+`ff-treat-as-special' calls function EXTRACT with no args.
+If EXTRACT returns nil, keep trying. Otherwise, return the
+filename that EXTRACT returned.")
+
+(defvaralias 'ff-related-file-alist 'ff-other-file-alist)
(defcustom ff-other-file-alist 'cc-other-file-alist
"*Alist of extensions to find given the current file's extension.
This list is searched through with each extension specified in
`ff-other-file-alist' that matches this file's extension. So the
-longer the list, the longer it'll take to realise that a file
+longer the list, the longer it'll take to realize that a file
may not exist.
A typical format is
:group 'ff)
(defcustom cc-other-file-alist
- '(
- ("\\.cc$" (".hh" ".h"))
- ("\\.hh$" (".cc" ".C"))
+ '(("\\.cc\\'" (".hh" ".h"))
+ ("\\.hh\\'" (".cc" ".C"))
- ("\\.c$" (".h"))
- ("\\.h$" (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))
+ ("\\.c\\'" (".h"))
+ ("\\.h\\'" (".c" ".cc" ".C" ".CC" ".cxx" ".cpp"))
- ("\\.C$" (".H" ".hh" ".h"))
- ("\\.H$" (".C" ".CC"))
+ ("\\.C\\'" (".H" ".hh" ".h"))
+ ("\\.H\\'" (".C" ".CC"))
- ("\\.CC$" (".HH" ".H" ".hh" ".h"))
- ("\\.HH$" (".CC"))
+ ("\\.CC\\'" (".HH" ".H" ".hh" ".h"))
+ ("\\.HH\\'" (".CC"))
- ("\\.cxx$" (".hh" ".h"))
- ("\\.cpp$" (".hh" ".h"))
- )
+ ("\\.c\\+\\+\\'" (".h++" ".hh" ".h"))
+ ("\\.h\\+\\+\\'" (".c++"))
+
+ ("\\.cpp\\'" (".hpp" ".hh" ".h"))
+ ("\\.hpp\\'" (".cpp"))
+
+ ("\\.cxx\\'" (".hxx" ".hh" ".h"))
+ ("\\.hxx\\'" (".cxx")))
"*Alist of extensions to find given the current file's extension.
This list should contain the most used extensions before the others,
(ff-find-the-other-file in-other-window)
(setq ff-ignore-include ignore)))
+;;;###autoload
+(defalias 'ff-find-related-file 'ff-find-other-file)
+
;;;###autoload
(defun ff-find-other-file (&optional in-other-window ignore-include)
"Find the header or source file corresponding to this file.
If non-nil, traces which directories are being searched.
- `ff-special-constructs'
- A list of regular expressions specifying how to recognise special
+ A list of regular expressions specifying how to recognize special
constructs such as include files etc, and an associated method for
extracting the filename from that construct.
(ff-list-replace-env-vars (symbol-value ff-search-directories))
(ff-list-replace-env-vars ff-search-directories)))
- (save-excursion
- (beginning-of-line 1)
- (setq fname (ff-treat-as-special)))
+ (setq fname (ff-treat-as-special))
(cond
((and (not ff-ignore-include) fname)
(read-file-name
(format "Find or create %s in: " default-name)
default-directory default-name nil)))
-
+
(setq pathname
(if (file-directory-p name)
(concat (file-name-as-directory name) default-name)
(setq found name)))
-
+
(ff-find-file pathname in-other-window t)))
(t ;; don't create the file, just whinge
(ff-list-replace-env-vars (symbol-value ff-search-directories))
(ff-list-replace-env-vars ff-search-directories)))
- (save-excursion
- (beginning-of-line 1)
- (setq fname (ff-treat-as-special)))
+ (setq fname (ff-treat-as-special))
(cond
((and (not ff-ignore-include) fname)
for fname with each of the given suffixes. Get the file or the buffer
corresponding to the name of the first file found, or nil."
(let ((filename (ff-get-file-name search-dirs filename suffix-list)))
-
+
(cond
((not filename)
nil)
((bufferp (get-file-buffer filename))
(ff-switch-to-buffer (get-file-buffer filename) other-window)
filename)
-
+
((file-exists-p filename)
(ff-find-file filename other-window nil)
filename)
(setq this-suffix (car suffixes))
(setq this-suffix "")
(setq suffixes (list "")))
-
+
;; find whether the file is in a buffer first
(while (and suffixes (not found))
(setq filename (concat fname-stub this-suffix))
;; if dir does not contain '/*', look for the file
(if (and dir (not (string-match "\\([^*]*\\)/\\\*\\(/.*\\)*" dir)))
(progn
-
+
;; suffixes is nil => fname-stub is the file we are looking for
;; otherwise fname-stub is a stub, and we append a suffix
(if suffixes
(setq this-suffix (car suffixes))
(setq this-suffix "")
(setq suffixes (list "")))
-
+
(while (and suffixes (not found))
(setq filename (concat fname-stub this-suffix))
(setq file (concat dir "/" filename))
-
+
(if (not ff-quiet-mode)
(message "Finding %s..." file))
(if (file-exists-p file)
(setq found file))
-
+
(setq suffixes (cdr suffixes))
(setq this-suffix (car suffixes))))
(defun ff-treat-as-special ()
"Return the file to look for if the construct was special, else nil.
-The construct is defined in the variable `ff-special-constructs'."
- (let* (fname
- (list ff-special-constructs)
- (elem (car list))
- (regexp (car elem))
- (match (cdr elem)))
- (while (and list (not fname))
- (if (and (looking-at regexp) match)
- (setq fname (funcall match)))
- (setq list (cdr list))
- (setq elem (car list))
- (setq regexp (car elem))
- (setq match (cdr elem)))
- fname))
+See variable `ff-special-constructs'."
+ (save-excursion
+ (beginning-of-line 1)
+ (let* (fname
+ (list ff-special-constructs)
+ (elem (car list))
+ (regexp (car elem))
+ (match (cdr elem)))
+ (while (and list (not fname))
+ (if (and (looking-at regexp) match)
+ (setq fname (funcall match)))
+ (setq list (cdr list))
+ (setq elem (car list))
+ (setq regexp (car elem))
+ (setq match (cdr elem)))
+ fname)))
(defun ff-basename (string)
"Return the basename of pathname STRING."
))
(t
nil))
-
+
return-list))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar ff-function-name nil "Name of the function we are in.")
-;(eval-when-compile (require 'ada-mode))
-
;; bind with (setq ff-pre-load-hook 'ff-which-function-are-we-in)
;;
+(defvar ada-procedure-start-regexp)
+(defvar ada-package-start-regexp)
+
(defun ff-which-function-are-we-in ()
"Return the name of the function whose definition/declaration point is in.
Also remember that name in `ff-function-name'."
-
- (setq ff-function-name nil)
-
- (save-excursion
- (if (re-search-backward ada-procedure-start-regexp nil t)
- (setq ff-function-name (buffer-substring (match-beginning 0)
- (match-end 0)))
- ; we didn't find a procedure start, perhaps there is a package
- (if (re-search-backward ada-package-start-regexp nil t)
- (setq ff-function-name (buffer-substring (match-beginning 0)
- (match-end 0)))
- ))))
+ (setq ff-function-name
+ (save-excursion
+ (if (or (re-search-backward ada-procedure-start-regexp nil t)
+ (re-search-backward ada-package-start-regexp nil t))
+ (match-string 0)))))
;; bind with (setq ff-post-load-hook 'ff-set-point-accordingly)
;;
(provide 'find-file)
+;; arch-tag: 5a2fc49e-3b0a-4708-9acf-fb14e471a97a
;;; find-file.el ends here