-;;; find-func.el --- find the definition of the elisp function near point
-
-;; Copyright (C) 1997 Free Software Foundation, Inc.
-
-;; Author: Jens Petersen <petersen@kurims.kyoto-u.ac.jp>
-;; Maintainer: petersen@kurims.kyoto-u.ac.jp
-;; Keywords: emacs-lisp, help, functions
-;; Created: 97/07/25
-
-;; This file is part of GNU Emacs.
-
-;; 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.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-;; 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.
-
-;;; Commentary:
-;;
-;; The funniest thing about this is that I can't imagine why a package
-;; so obviously useful as this hasn't been written before!!
-;; This probably belongs in "help.el" or somewhere like that.
-;;
-;; Put this file in your `load-path', byte-compile it and add the
-;; following code in your init file:
-;;
-;; ;;; find-func
-;; (load "find-function")
-;; (global-set-key [(control ?c) ?f] 'find-function)
-;; (global-set-key [(control ?c) ?4 ?f] 'find-function-other-window)
-;; (global-set-key [(control ?c) ?5 ?f] 'find-function-other-frame)
-;; (global-set-key [(control ?c) ?k] 'find-function-on-key)
-;;
-;; and away you go! It does pretty much what you would expect,
-;; putting the cursor at the definition of the function at point.
-;;
-;; The code is adapted from `describe-function', `describe-key'
-;; ("help.el") and `fff-find-loaded-emacs-lisp-function' (Noah Friedman's
-;; "fff.el").
-
-;;; To do:
-;;
-;; o custom?
-;;
-;; o improve handling of advice'd functions? (at the moment it goes to
-;; the advice, not the actual definition)
-
-;;;; Code:
-
-;;; User variables:
-(defgroup find-function nil
- "Find the definition of the elisp function near point."
- :prefix "find-function"
- :group 'lisp)
-
-(defcustom find-function-function 'function-at-point
- "*The function used by `find-function' to select the function near
-point.
-
-For example `function-at-point' or `function-called-at-point'."
- :type 'function
- :group 'find-function)
-
-(defcustom find-function-source-path nil
- "The default list of directories where find-function searches.
-
-If this variable is `nil' then find-function searches `load-path' by
-default."
- :type '(repeat directory)
- :group 'find-function)
-
-
-;;; Functions:
-
-;;;###autoload
-(defun find-function-noselect (function &optional path)
- "Returns list (BUFFER POINT) pointing to the definition of FUNCTION.
-
-Finds the Emacs Lisp library containing the definition of FUNCTION
-in a buffer and places point before the definition. The buffer is
-not selected.
-
-If the optional argument PATH is given, the library where FUNCTION is
-defined is searched in PATH instead of `load-path' (see
-`find-function-source-path')."
- (and (subrp (symbol-function function))
- (error "%s is a primitive function" function))
- (if (not function)
- (error "You didn't specify a function"))
- (let ((def (symbol-function function))
- library aliases)
- (while (symbolp def)
- (or (eq def function)
- (if aliases
- (setq aliases (concat aliases
- (format ", which is an alias for %s"
- (symbol-name def))))
- (setq aliases (format "an alias for %s" (symbol-name
- def)))))
- (setq function (symbol-function function)
- def (symbol-function function)))
- (if aliases
- (message aliases))
- (setq library
- (cond ((eq (car-safe def) 'autoload)
- (nth 1 def))
- ((describe-function-find-file function))))
- (if (null library)
- (error (format "`%s' is not in `load-history'" function)))
- (if (string-match "\\(\\.elc?\\'\\)" library)
- (setq library (substring library 0 (match-beginning 1))))
- (let* ((path (or path find-function-source-path))
- (compression (or (rassq 'jka-compr-handler file-name-handler-alist)
- (member 'crypt-find-file-hook find-file-hooks)))
- (filename (or (locate-library (concat library ".el")
- t path)
- (locate-library library t path)
- (if compression
- (or (locate-library (concat library ".el.gz")
- t path)
- (locate-library (concat library ".gz")
- t path))))))
- (if (not filename)
- (error "The library \"%s\" is not in the path." library))
- (save-excursion
- (set-buffer (find-file-noselect filename))
- (save-match-data
- (let (;; avoid defconst, defgroup, defvar (any others?)
- (regexp (format "^\\s-*(def[^cgv\W]\\w+\\s-+%s\\s-" function))
- (syntable (syntax-table)))
- (set-syntax-table emacs-lisp-mode-syntax-table)
- (goto-char (point-min))
- (if (prog1
- (re-search-forward regexp nil t)
- (set-syntax-table syntable))
- (progn
- (beginning-of-line)
- (list (current-buffer) (point)))
- (error "Cannot find definition of %s" function))))))))
-
-(defun function-at-point ()
- (or (condition-case ()
- (let ((stab (syntax-table)))
- (unwind-protect
- (save-excursion
- (set-syntax-table emacs-lisp-mode-syntax-table)
- (or (not (zerop (skip-syntax-backward "_w")))
- (eq (char-syntax (char-after (point))) ?w)
- (eq (char-syntax (char-after (point))) ?_)
- (forward-sexp -1))
- (skip-chars-forward "`'")
- (let ((obj (read (current-buffer))))
- (and (symbolp obj) (fboundp obj) obj)))
- (set-syntax-table stab)))
- (error nil))
- (condition-case ()
- (save-excursion
- (save-restriction
- (narrow-to-region (max (point-min) (- (point) 1000)) (point-max))
- (backward-up-list 1)
- (forward-char 1)
- (let (obj)
- (setq obj (read (current-buffer)))
- (and (symbolp obj) (fboundp obj) obj))))
- (error nil))))
-
-(defun find-function-read-function ()
- "Read and return a function, defaulting to the one near point.
-
-The function named by `find-function-function' is used to select the
-default function."
- (let ((fn (funcall find-function-function))
- (enable-recursive-minibuffers t)
- val)
- (setq val (completing-read
- (if fn
- (format "Find function (default %s): " fn)
- "Find function: ")
- obarray 'fboundp t))
- (list (if (equal val "")
- fn (intern val)))))
-
-(defun find-function-do-it (function path switch-fn)
- "Find Emacs Lisp FUNCTION in PATH and display it with SWITCH-FN.
-Point is saved if FUNCTION is in the current buffer."
- (let ((orig-point (point))
- (buffer-point (find-function-noselect function path)))
- (if buffer-point
- (progn
- (if (eq (current-buffer) (car buffer-point))
- (push-mark orig-point))
- (funcall switch-fn (car buffer-point))
- (goto-char (elt buffer-point 1))
- (recenter 0)))))
-
-;;;###autoload
-(defun find-function (function &optional path)
- "Find the definition of the function near point in the current window.
-
-Finds the Emacs Lisp library containing the definition of the function
-near point (selected by `find-function-function') and places point
-before the definition. Point is saved if FUNCTION is in the current
-buffer.
-
-If the optional argument PATH is given, the library where FUNCTION is
-defined is searched in PATH instead of `load-path'"
- (interactive (find-function-read-function))
- (find-function-do-it function path 'switch-to-buffer))
-
-;;;###autoload
-(defun find-function-other-window (function &optional path)
- "Find the definition of the function near point in the other window.
-
-Finds the Emacs Lisp package containing the definition of the function
-near point (selected by `find-function-function') and places point
-before the definition. Point is saved if FUNCTION is in the current
-buffer.
-
-If the optional argument PATH is given, the package where FUNCTION is
-defined is searched in PATH instead of `load-path'"
- (interactive (find-function-read-function))
- (find-function-do-it function path 'switch-to-buffer-other-window))
-
-;;;###autoload
-(defun find-function-other-frame (function &optional path)
- "Find the definition of the function near point in the another frame.
-
-Finds the Emacs Lisp package containing the definition of the function
-near point (selected by `find-function-function') and places point
-before the definition. Point is saved if FUNCTION is in the current
-buffer.
-
-If the optional argument PATH is given, the package where FUNCTION is
-defined is searched in PATH instead of `load-path'"
- (interactive (find-function-read-function))
- (find-function-do-it function path 'switch-to-buffer-other-frame))
-
-;;;###autoload
-(defun find-function-on-key (key)
- "Find the function that KEY invokes. KEY is a string.
-Point is saved if FUNCTION is in the current buffer."
- (interactive "kFind function on key: ")
- ;; If this key seq ends with a down event, discard the
- ;; following click or drag event. Otherwise that would
- ;; erase an eventual message.
- (let ((type (aref key (1- (length key)))))
- (if (listp type) (setq type (car type)))
- (and (symbolp type)
- (memq 'down (event-modifiers type))
- (read-event)))
- (save-excursion
- (let ((modifiers (event-modifiers (aref key 0)))
- window position)
- ;; For a mouse button event, go to the button it applies to
- ;; to get the right key bindings. And go to the right place
- ;; in case the keymap depends on where you clicked.
- (if (or (memq 'click modifiers) (memq 'down modifiers)
- (memq 'drag modifiers))
- (setq window (posn-window (event-start (aref key 0)))
- position (posn-point (event-start (aref key 0)))))
- (if (windowp window)
- (progn
- (set-buffer (window-buffer window))
- (goto-char position)))
- ;; Ok, now look up the key and name the command.
- (let ((defn (key-binding key)))
- (if (or (null defn) (integerp defn))
- (message "%s is undefined" (key-description key))
- (if (consp defn)
- (message (if (windowp window)
- "%s at that spot runs %s"
- "%s runs %s")
- (key-description key) (prin1-to-string defn))
- (find-function-other-window defn)))))))
-
-(provide 'find-func)
-
-;;; find-func.el ends here
-
+;;; find-func.el --- find the definition of the Emacs Lisp function near point
+
+;; Copyright (C) 1997, 1999, 2001, 2002, 2003, 2004,
+;; 2005, 2006, 2007 Free Software Foundation, Inc.
+
+;; Author: Jens Petersen <petersen@kurims.kyoto-u.ac.jp>
+;; Maintainer: petersen@kurims.kyoto-u.ac.jp
+;; Keywords: emacs-lisp, functions, variables
+;; Created: 97/07/25
+
+;; This file is part of GNU Emacs.
+
+;; 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.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; 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., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+;;
+;; The funniest thing about this is that I can't imagine why a package
+;; so obviously useful as this hasn't been written before!!
+;; ;;; find-func
+;; (find-function-setup-keys)
+;;
+;; or just:
+;;
+;; (load "find-func")
+;;
+;; if you don't like the given keybindings and away you go! It does
+;; pretty much what you would expect, putting the cursor at the
+;; definition of the function or variable at point.
+;;
+;; The code started out from `describe-function', `describe-key'
+;; ("help.el") and `fff-find-loaded-emacs-lisp-function' (Noah Friedman's
+;; "fff.el").
+
+;;; Code:
+
+(require 'loadhist)
+
+;;; User variables:
+
+(defgroup find-function nil
+ "Finds the definition of the Emacs Lisp symbol near point."
+;; :prefix "find-function"
+ :group 'lisp)
+
+(defconst find-function-space-re "\\(?:\\s-\\|\n\\|;.*\n\\)+")
+
+(defcustom find-function-regexp
+ ;; Match things like (defun foo ...), (defmacro foo ...),
+ ;; (define-skeleton foo ...), (define-generic-mode 'foo ...),
+ ;; (define-derived-mode foo ...), (define-minor-mode foo)
+ (concat
+ "^\\s-*(\\(def\\(ine-skeleton\\|ine-generic-mode\\|ine-derived-mode\\|\
+ine\\(?:-global\\)?-minor-mode\\|ine-compilation-mode\\|un-cvs-mode\\|\
+foo\\|[^icfgv]\\(\\w\\|\\s_\\)+\\*?\\)\\|easy-mmode-define-[a-z-]+\\|easy-menu-define\\|\
+menu-bar-make-toggle\\)"
+ find-function-space-re
+ "\\('\\|\(quote \\)?%s\\(\\s-\\|$\\|\(\\|\)\\)")
+ "The regexp used by `find-function' to search for a function definition.
+Note it must contain a `%s' at the place where `format'
+should insert the function name. The default value avoids `defconst',
+`defgroup', `defvar', `defface'.
+
+Please send improvements and fixes to the maintainer."
+ :type 'regexp
+ :group 'find-function
+ :version "21.1")
+
+(defcustom find-variable-regexp
+ (concat
+ "^\\s-*(\\(def[^fumag]\\(\\w\\|\\s_\\)+\\*?\\|\
+easy-mmode-def\\(map\\|syntax\\)\\|easy-menu-define\\)"
+ find-function-space-re
+ "%s\\(\\s-\\|$\\)")
+ "The regexp used by `find-variable' to search for a variable definition.
+Note it must contain a `%s' at the place where `format'
+should insert the variable name. The default value
+avoids `defun', `defmacro', `defalias', `defadvice', `defgroup', `defface'.
+
+Please send improvements and fixes to the maintainer."
+ :type 'regexp
+ :group 'find-function
+ :version "21.1")
+
+(defcustom find-face-regexp
+ (concat"^\\s-*(defface" find-function-space-re "%s\\(\\s-\\|$\\)")
+ "The regexp used by `find-face' to search for a face definition.
+Note it must contain a `%s' at the place where `format'
+should insert the face name.
+
+Please send improvements and fixes to the maintainer."
+ :type 'regexp
+ :group 'find-function
+ :version "22.1")
+
+(defvar find-function-regexp-alist
+ '((nil . find-function-regexp)
+ (defvar . find-variable-regexp)
+ (defface . find-face-regexp))
+ "Alist mapping definition types into regexp variables.
+Each regexp variable's value should actually be a format string
+to be used to substitute the desired symbol name into the regexp.")
+(put 'find-function-regexp-alist 'risky-local-variable t)
+
+(defcustom find-function-source-path nil
+ "The default list of directories where `find-function' searches.
+
+If this variable is nil then `find-function' searches `load-path' by
+default."
+ :type '(repeat directory)
+ :group 'find-function)
+
+(defcustom find-function-recenter-line 1
+ "The window line-number from which to start displaying a symbol definition.
+A value of nil implies center the beginning of the definition.
+See `find-function' and `find-variable'."
+ :type '(choice (const :tag "Center" nil)
+ integer)
+ :group 'find-function
+ :version "20.3")
+
+(defcustom find-function-after-hook nil
+ "Hook run after finding symbol definition.
+
+See the functions `find-function' and `find-variable'."
+ :group 'find-function
+ :version "20.3")
+
+;;; Functions:
+
+(defun find-library-suffixes ()
+ (let ((suffixes nil))
+ (dolist (suffix (get-load-suffixes) (nreverse suffixes))
+ (unless (string-match "elc" suffix) (push suffix suffixes)))))
+
+(defun find-library-name (library)
+ "Return the absolute file name of the Lisp source of LIBRARY."
+ ;; If the library is byte-compiled, try to find a source library by
+ ;; the same name.
+ (if (string-match "\\.el\\(c\\(\\..*\\)?\\)\\'" library)
+ (setq library (replace-match "" t t library)))
+ (or (locate-file library
+ (or find-function-source-path load-path)
+ (append (find-library-suffixes) load-file-rep-suffixes))
+ (error "Can't find library %s" library)))
+
+(defvar find-function-C-source-directory
+ (let ((dir (expand-file-name "src" source-directory)))
+ (when (and (file-directory-p dir) (file-readable-p dir))
+ dir))
+ "Directory where the C source files of Emacs can be found.
+If nil, do not try to find the source code of functions and variables
+defined in C.")
+
+(defun find-function-C-source (fun-or-var file type)
+ "Find the source location where FUN-OR-VAR is defined in FILE.
+TYPE should be nil to find a function, or `defvar' to find a variable."
+ (unless find-function-C-source-directory
+ (setq find-function-C-source-directory
+ (read-directory-name "Emacs C source dir: " nil nil t)))
+ (setq file (expand-file-name file find-function-C-source-directory))
+ (unless (file-readable-p file)
+ (error "The C source file %s is not available"
+ (file-name-nondirectory file)))
+ (unless type
+ (setq fun-or-var (indirect-function fun-or-var)))
+ (with-current-buffer (find-file-noselect file)
+ (goto-char (point-min))
+ (unless (re-search-forward
+ (if type
+ (concat "DEFVAR[A-Z_]*[ \t\n]*([ \t\n]*\""
+ (regexp-quote (symbol-name fun-or-var))
+ "\"")
+ (concat "DEFUN[ \t\n]*([ \t\n]*\""
+ (regexp-quote (subr-name fun-or-var))
+ "\""))
+ nil t)
+ (error "Can't find source for %s" fun-or-var))
+ (cons (current-buffer) (match-beginning 0))))
+
+;;;###autoload
+(defun find-library (library)
+ "Find the elisp source of LIBRARY."
+ (interactive
+ (list
+ (completing-read "Library name: "
+ 'locate-file-completion
+ (cons (or find-function-source-path load-path)
+ (find-library-suffixes)))))
+ (let ((buf (find-file-noselect (find-library-name library))))
+ (condition-case nil (switch-to-buffer buf) (error (pop-to-buffer buf)))))
+
+;;;###autoload
+(defun find-function-search-for-symbol (symbol type library)
+ "Search for SYMBOL's definition of type TYPE in LIBRARY.
+Visit the library in a buffer, and return a cons cell (BUFFER . POSITION),
+or just (BUFFER . nil) if the definition can't be found in the file.
+
+If TYPE is nil, look for a function definition.
+Otherwise, TYPE specifies the kind of definition,
+and it is interpreted via `find-function-regexp-alist'.
+The search is done in the source for library LIBRARY."
+ (if (null library)
+ (error "Don't know where `%s' is defined" symbol))
+ ;; Some functions are defined as part of the construct
+ ;; that defines something else.
+ (while (and (symbolp symbol) (get symbol 'definition-name))
+ (setq symbol (get symbol 'definition-name)))
+ (if (string-match "\\`src/\\(.*\\.c\\)\\'" library)
+ (find-function-C-source symbol (match-string 1 library) type)
+ (if (string-match "\\.el\\(c\\)\\'" library)
+ (setq library (substring library 0 (match-beginning 1))))
+ (let* ((filename (find-library-name library))
+ (regexp-symbol (cdr (assq type find-function-regexp-alist))))
+ (with-current-buffer (find-file-noselect filename)
+ (let ((regexp (format (symbol-value regexp-symbol)
+ ;; Entry for ` (backquote) macro in loaddefs.el,
+ ;; (defalias (quote \`)..., has a \ but
+ ;; (symbol-name symbol) doesn't. Add an
+ ;; optional \ to catch this.
+ (concat "\\\\?"
+ (regexp-quote (symbol-name symbol)))))
+ (case-fold-search))
+ (with-syntax-table emacs-lisp-mode-syntax-table
+ (goto-char (point-min))
+ (if (or (re-search-forward regexp nil t)
+ ;; `regexp' matches definitions using known forms like
+ ;; `defun', or `defvar'. But some functions/variables
+ ;; are defined using special macros (or functions), so
+ ;; if `regexp' can't find the definition, we look for
+ ;; something of the form "(SOMETHING <symbol> ...)".
+ ;; This fails to distinguish function definitions from
+ ;; variable declarations (or even uses thereof), but is
+ ;; a good pragmatic fallback.
+ (re-search-forward
+ (concat "^([^ ]+" find-function-space-re "['(]?"
+ (regexp-quote (symbol-name symbol))
+ "\\_>")
+ nil t))
+ (progn
+ (beginning-of-line)
+ (cons (current-buffer) (point)))
+ (cons (current-buffer) nil))))))))
+
+;;;###autoload
+(defun find-function-noselect (function)
+ "Return a pair (BUFFER . POINT) pointing to the definition of FUNCTION.
+
+Finds the source file containing the definition of FUNCTION
+in a buffer and the point of the definition. The buffer is
+not selected. If the function definition can't be found in
+the buffer, returns (BUFFER).
+
+If the file where FUNCTION is defined is not known, then it is
+searched for in `find-function-source-path' if non-nil, otherwise
+in `load-path'."
+ (if (not function)
+ (error "You didn't specify a function"))
+ (let ((def (symbol-function function))
+ aliases)
+ (while (symbolp def)
+ (or (eq def function)
+ (if aliases
+ (setq aliases (concat aliases
+ (format ", which is an alias for `%s'"
+ (symbol-name def))))
+ (setq aliases (format "`%s' an alias for `%s'"
+ function (symbol-name def)))))
+ (setq function (symbol-function function)
+ def (symbol-function function)))
+ (if aliases
+ (message "%s" aliases))
+ (let ((library
+ (cond ((eq (car-safe def) 'autoload)
+ (nth 1 def))
+ ((subrp def)
+ (help-C-file-name def 'subr))
+ ((symbol-file function 'defun)))))
+ (find-function-search-for-symbol function nil library))))
+
+(defun find-function-read (&optional type)
+ "Read and return an interned symbol, defaulting to the one near point.
+
+If TYPE is nil, insist on a symbol with a function definition.
+Otherwise TYPE should be `defvar' or `defface'.
+If TYPE is nil, defaults using `function-called-at-point',
+otherwise uses `variable-at-point'."
+ (let ((symb (if (null type)
+ (function-called-at-point)
+ (if (eq type 'defvar)
+ (variable-at-point)
+ (variable-at-point t))))
+ (predicate (cdr (assq type '((nil . fboundp) (defvar . boundp)
+ (defface . facep)))))
+ (prompt (cdr (assq type '((nil . "function") (defvar . "variable")
+ (defface . "face")))))
+ (enable-recursive-minibuffers t)
+ val)
+ (if (equal symb 0)
+ (setq symb nil))
+ (setq val (completing-read
+ (concat "Find "
+ prompt
+ (if symb
+ (format " (default %s)" symb))
+ ": ")
+ obarray predicate t nil))
+ (list (if (equal val "")
+ symb
+ (intern val)))))
+
+(defun find-function-do-it (symbol type switch-fn)
+ "Find Emacs Lisp SYMBOL in a buffer and display it.
+TYPE is nil to search for a function definition,
+or else `defvar' or `defface'.
+
+The variable `find-function-recenter-line' controls how
+to recenter the display. SWITCH-FN is the function to call
+to display and select the buffer.
+See also `find-function-after-hook'.
+
+Set mark before moving, if the buffer already existed."
+ (let* ((orig-point (point))
+ (orig-buf (window-buffer))
+ (orig-buffers (buffer-list))
+ (buffer-point (save-excursion
+ (find-definition-noselect symbol type)))
+ (new-buf (car buffer-point))
+ (new-point (cdr buffer-point)))
+ (when buffer-point
+ (when (memq new-buf orig-buffers)
+ (push-mark orig-point))
+ (funcall switch-fn new-buf)
+ (when new-point (goto-char new-point))
+ (recenter find-function-recenter-line)
+ (run-hooks 'find-function-after-hook))))
+
+;;;###autoload
+(defun find-function (function)
+ "Find the definition of the FUNCTION near point.
+
+Finds the source file containing the definition of the function
+near point (selected by `function-called-at-point') in a buffer and
+places point before the definition.
+Set mark before moving, if the buffer already existed.
+
+The library where FUNCTION is defined is searched for in
+`find-function-source-path', if non-nil, otherwise in `load-path'.
+See also `find-function-recenter-line' and `find-function-after-hook'."
+ (interactive (find-function-read))
+ (find-function-do-it function nil 'switch-to-buffer))
+
+;;;###autoload
+(defun find-function-other-window (function)
+ "Find, in another window, the definition of FUNCTION near point.
+
+See `find-function' for more details."
+ (interactive (find-function-read))
+ (find-function-do-it function nil 'switch-to-buffer-other-window))
+
+;;;###autoload
+(defun find-function-other-frame (function)
+ "Find, in another frame, the definition of FUNCTION near point.
+
+See `find-function' for more details."
+ (interactive (find-function-read))
+ (find-function-do-it function nil 'switch-to-buffer-other-frame))
+
+;;;###autoload
+(defun find-variable-noselect (variable &optional file)
+ "Return a pair `(BUFFER . POINT)' pointing to the definition of VARIABLE.
+
+Finds the library containing the definition of VARIABLE in a buffer and
+the point of the definition. The buffer is not selected.
+If the variable's definition can't be found in the buffer, return (BUFFER).
+
+The library where VARIABLE is defined is searched for in FILE or
+`find-function-source-path', if non-nil, otherwise in `load-path'."
+ (if (not variable)
+ (error "You didn't specify a variable")
+ (let ((library (or file
+ (symbol-file variable 'defvar)
+ (help-C-file-name variable 'var))))
+ (find-function-search-for-symbol variable 'defvar library))))
+
+;;;###autoload
+(defun find-variable (variable)
+ "Find the definition of the VARIABLE at or before point.
+
+Finds the library containing the definition of the variable
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.
+
+Set mark before moving, if the buffer already existed.
+
+The library where VARIABLE is defined is searched for in
+`find-function-source-path', if non-nil, otherwise in `load-path'.
+See also `find-function-recenter-line' and `find-function-after-hook'."
+ (interactive (find-function-read 'defvar))
+ (find-function-do-it variable 'defvar 'switch-to-buffer))
+
+;;;###autoload
+(defun find-variable-other-window (variable)
+ "Find, in another window, the definition of VARIABLE near point.
+
+See `find-variable' for more details."
+ (interactive (find-function-read 'defvar))
+ (find-function-do-it variable 'defvar 'switch-to-buffer-other-window))
+
+;;;###autoload
+(defun find-variable-other-frame (variable)
+ "Find, in another frame, the definition of VARIABLE near point.
+
+See `find-variable' for more details."
+ (interactive (find-function-read 'defvar))
+ (find-function-do-it variable 'defvar 'switch-to-buffer-other-frame))
+
+;;;###autoload
+(defun find-definition-noselect (symbol type &optional file)
+ "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL.
+If the definition can't be found in the buffer, return (BUFFER).
+TYPE says what type of definition: nil for a function, `defvar' for a
+variable, `defface' for a face. This function does not switch to the
+buffer nor display it.
+
+The library where SYMBOL is defined is searched for in FILE or
+`find-function-source-path', if non-nil, otherwise in `load-path'."
+ (cond
+ ((not symbol)
+ (error "You didn't specify a symbol"))
+ ((null type)
+ (find-function-noselect symbol))
+ ((eq type 'defvar)
+ (find-variable-noselect symbol file))
+ (t
+ (let ((library (or file (symbol-file symbol type))))
+ (find-function-search-for-symbol symbol type library)))))
+
+;; For symmetry, this should be called find-face; but some programs
+;; assume that, if that name is defined, it means something else.
+;;;###autoload
+(defun find-face-definition (face)
+ "Find the definition of FACE. FACE defaults to the name near point.
+
+Finds the Emacs Lisp library containing the definition of the face
+near point (selected by `variable-at-point') in a buffer and
+places point before the definition.
+
+Set mark before moving, if the buffer already existed.
+
+The library where FACE is defined is searched for in
+`find-function-source-path', if non-nil, otherwise in `load-path'.
+See also `find-function-recenter-line' and `find-function-after-hook'."
+ (interactive (find-function-read 'defface))
+ (find-function-do-it face 'defface 'switch-to-buffer))
+
+;;;###autoload
+(defun find-function-on-key (key)
+ "Find the function that KEY invokes. KEY is a string.
+Set mark before moving, if the buffer already existed."
+ (interactive "kFind function on key: ")
+ (let (defn)
+ (save-excursion
+ (let* ((event (and (eventp key) (aref key 0))) ; Null event OK below.
+ (start (event-start event))
+ (modifiers (event-modifiers event))
+ (window (and (or (memq 'click modifiers) (memq 'down modifiers)
+ (memq 'drag modifiers))
+ (posn-window start))))
+ ;; For a mouse button event, go to the button it applies to
+ ;; to get the right key bindings. And go to the right place
+ ;; in case the keymap depends on where you clicked.
+ (when (windowp window)
+ (set-buffer (window-buffer window))
+ (goto-char (posn-point start)))
+ (setq defn (key-binding key))))
+ (let ((key-desc (key-description key)))
+ (if (or (null defn) (integerp defn))
+ (message "%s is unbound" key-desc)
+ (if (consp defn)
+ (message "%s runs %s" key-desc (prin1-to-string defn))
+ (find-function-other-window defn))))))
+
+;;;###autoload
+(defun find-function-at-point ()
+ "Find directly the function at point in the other window."
+ (interactive)
+ (let ((symb (function-called-at-point)))
+ (when symb
+ (find-function-other-window symb))))
+
+;;;###autoload
+(defun find-variable-at-point ()
+ "Find directly the variable at point in the other window."
+ (interactive)
+ (let ((symb (variable-at-point)))
+ (when (and symb (not (equal symb 0)))
+ (find-variable-other-window symb))))
+
+;;;###autoload
+(defun find-function-setup-keys ()
+ "Define some key bindings for the find-function family of functions."
+ (define-key ctl-x-map "F" 'find-function)
+ (define-key ctl-x-4-map "F" 'find-function-other-window)
+ (define-key ctl-x-5-map "F" 'find-function-other-frame)
+ (define-key ctl-x-map "K" 'find-function-on-key)
+ (define-key ctl-x-map "V" 'find-variable)
+ (define-key ctl-x-4-map "V" 'find-variable-other-window)
+ (define-key ctl-x-5-map "V" 'find-variable-other-frame))
+
+(provide 'find-func)
+
+;; arch-tag: 43ecd81c-74dc-4d9a-8f63-a61e55670d64
+;;; find-func.el ends here