emacs-lisp/package.el (package-activate-1): Reload package after upgrade
[emacs.git] / lisp / emacs-lisp / find-func.el
blobc372117b1043772353f5544f2d4cd6f9785b139e
1 ;;; find-func.el --- find the definition of the Emacs Lisp function near point
3 ;; Copyright (C) 1997, 1999, 2001-2014 Free Software Foundation, Inc.
5 ;; Author: Jens Petersen <petersen@kurims.kyoto-u.ac.jp>
6 ;; Maintainer: petersen@kurims.kyoto-u.ac.jp
7 ;; Keywords: emacs-lisp, functions, variables
8 ;; Created: 97/07/25
10 ;; This file is part of GNU Emacs.
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.
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.
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/>.
25 ;;; Commentary:
27 ;; The funniest thing about this is that I can't imagine why a package
28 ;; so obviously useful as this hasn't been written before!!
29 ;; ;;; find-func
30 ;; (find-function-setup-keys)
32 ;; or just:
34 ;; (load "find-func")
36 ;; if you don't like the given keybindings and away you go! It does
37 ;; pretty much what you would expect, putting the cursor at the
38 ;; definition of the function or variable at point.
40 ;; The code started out from `describe-function', `describe-key'
41 ;; ("help.el") and `fff-find-loaded-emacs-lisp-function' (Noah Friedman's
42 ;; "fff.el").
44 ;;; Code:
46 ;;; User variables:
48 (defgroup find-function nil
49 "Finds the definition of the Emacs Lisp symbol near point."
50 ;; :prefix "find-function"
51 :group 'lisp)
53 (defconst find-function-space-re "\\(?:\\s-\\|\n\\|;.*\n\\)+")
55 (defcustom find-function-regexp
56 ;; Match things like (defun foo ...), (defmacro foo ...),
57 ;; (define-skeleton foo ...), (define-generic-mode 'foo ...),
58 ;; (define-derived-mode foo ...), (define-minor-mode foo)
59 (concat
60 "^\\s-*(\\(def\\(ine-skeleton\\|ine-generic-mode\\|ine-derived-mode\\|\
61 ine\\(?:-global\\)?-minor-mode\\|ine-compilation-mode\\|un-cvs-mode\\|\
62 foo\\|[^icfgv]\\(\\w\\|\\s_\\)+\\*?\\)\\|easy-mmode-define-[a-z-]+\\|easy-menu-define\\|\
63 menu-bar-make-toggle\\)"
64 find-function-space-re
65 "\\('\\|\(quote \\)?%s\\(\\s-\\|$\\|\(\\|\)\\)")
66 "The regexp used by `find-function' to search for a function definition.
67 Note it must contain a `%s' at the place where `format'
68 should insert the function name. The default value avoids `defconst',
69 `defgroup', `defvar', `defface'.
71 Please send improvements and fixes to the maintainer."
72 :type 'regexp
73 :group 'find-function
74 :version "21.1")
76 (defcustom find-variable-regexp
77 (concat
78 "^\\s-*(\\(def[^fumag]\\(\\w\\|\\s_\\)+\\*?\\|\
79 easy-mmode-def\\(map\\|syntax\\)\\|easy-menu-define\\)"
80 find-function-space-re
81 "%s\\(\\s-\\|$\\)")
82 "The regexp used by `find-variable' to search for a variable definition.
83 Note it must contain a `%s' at the place where `format'
84 should insert the variable name. The default value
85 avoids `defun', `defmacro', `defalias', `defadvice', `defgroup', `defface'.
87 Please send improvements and fixes to the maintainer."
88 :type 'regexp
89 :group 'find-function
90 :version "21.1")
92 (defcustom find-face-regexp
93 (concat"^\\s-*(defface" find-function-space-re "%s\\(\\s-\\|$\\)")
94 "The regexp used by `find-face' to search for a face definition.
95 Note it must contain a `%s' at the place where `format'
96 should insert the face name.
98 Please send improvements and fixes to the maintainer."
99 :type 'regexp
100 :group 'find-function
101 :version "22.1")
103 (defvar find-function-regexp-alist
104 '((nil . find-function-regexp)
105 (defvar . find-variable-regexp)
106 (defface . find-face-regexp))
107 "Alist mapping definition types into regexp variables.
108 Each regexp variable's value should actually be a format string
109 to be used to substitute the desired symbol name into the regexp.")
110 (put 'find-function-regexp-alist 'risky-local-variable t)
112 (defcustom find-function-source-path nil
113 "The default list of directories where `find-function' searches.
115 If this variable is nil then `find-function' searches `load-path' by
116 default."
117 :type '(repeat directory)
118 :group 'find-function)
120 (defcustom find-function-recenter-line 1
121 "The window line-number from which to start displaying a symbol definition.
122 A value of nil implies center the beginning of the definition.
123 See `find-function' and `find-variable'."
124 :type '(choice (const :tag "Center" nil)
125 integer)
126 :group 'find-function
127 :version "20.3")
129 (defcustom find-function-after-hook nil
130 "Hook run after finding symbol definition.
132 See the functions `find-function' and `find-variable'."
133 :type 'hook
134 :group 'find-function
135 :version "20.3")
137 ;;; Functions:
139 (defun find-library-suffixes ()
140 (let ((suffixes nil))
141 (dolist (suffix (get-load-suffixes) (nreverse suffixes))
142 (unless (string-match "elc" suffix) (push suffix suffixes)))))
144 (defun find-library--load-name (library)
145 (let ((name library))
146 (dolist (dir load-path)
147 (let ((rel (file-relative-name library dir)))
148 (if (and (not (string-match "\\`\\.\\./" rel))
149 (< (length rel) (length name)))
150 (setq name rel))))
151 (unless (equal name library) name)))
153 (defun find-library-name (library)
154 "Return the absolute file name of the Emacs Lisp source of LIBRARY.
155 LIBRARY should be a string (the name of the library)."
156 ;; If the library is byte-compiled, try to find a source library by
157 ;; the same name.
158 (if (string-match "\\.el\\(c\\(\\..*\\)?\\)\\'" library)
159 (setq library (replace-match "" t t library)))
161 (locate-file library
162 (or find-function-source-path load-path)
163 (find-library-suffixes))
164 (locate-file library
165 (or find-function-source-path load-path)
166 load-file-rep-suffixes)
167 (when (file-name-absolute-p library)
168 (let ((rel (find-library--load-name library)))
169 (when rel
171 (locate-file rel
172 (or find-function-source-path load-path)
173 (find-library-suffixes))
174 (locate-file rel
175 (or find-function-source-path load-path)
176 load-file-rep-suffixes)))))
177 (error "Can't find library %s" library)))
179 (defvar find-function-C-source-directory
180 (let ((dir (expand-file-name "src" source-directory)))
181 (if (file-accessible-directory-p dir) dir))
182 "Directory where the C source files of Emacs can be found.
183 If nil, do not try to find the source code of functions and variables
184 defined in C.")
186 (declare-function ad-get-advice-info "advice" (function))
188 (defun find-function-advised-original (func)
189 "Return the original function symbol of an advised function FUNC.
190 If FUNC is not the symbol of an advised function, just returns FUNC."
191 (or (and (symbolp func)
192 (featurep 'advice)
193 (let ((ofunc (cdr (assq 'origname (ad-get-advice-info func)))))
194 (and (fboundp ofunc) ofunc)))
195 func))
197 (defun find-function-C-source (fun-or-var file type)
198 "Find the source location where FUN-OR-VAR is defined in FILE.
199 TYPE should be nil to find a function, or `defvar' to find a variable."
200 (let ((dir (or find-function-C-source-directory
201 (read-directory-name "Emacs C source dir: " nil nil t))))
202 (setq file (expand-file-name file dir))
203 (if (file-readable-p file)
204 (if (null find-function-C-source-directory)
205 (setq find-function-C-source-directory dir))
206 (error "The C source file %s is not available"
207 (file-name-nondirectory file))))
208 (unless type
209 ;; Either or both an alias and its target might be advised.
210 (setq fun-or-var (find-function-advised-original
211 (indirect-function
212 (find-function-advised-original fun-or-var)))))
213 (with-current-buffer (find-file-noselect file)
214 (goto-char (point-min))
215 (unless (re-search-forward
216 (if type
217 (concat "DEFVAR[A-Z_]*[ \t\n]*([ \t\n]*\""
218 (regexp-quote (symbol-name fun-or-var))
219 "\"")
220 (concat "DEFUN[ \t\n]*([ \t\n]*\""
221 (regexp-quote (subr-name (advice--cd*r fun-or-var)))
222 "\""))
223 nil t)
224 (error "Can't find source for %s" fun-or-var))
225 (cons (current-buffer) (match-beginning 0))))
227 ;;;###autoload
228 (defun find-library (library)
229 "Find the Emacs Lisp source of LIBRARY.
230 LIBRARY should be a string (the name of the library)."
231 (interactive
232 (let* ((dirs (or find-function-source-path load-path))
233 (suffixes (find-library-suffixes))
234 (table (apply-partially 'locate-file-completion-table
235 dirs suffixes))
236 (def (if (eq (function-called-at-point) 'require)
237 ;; `function-called-at-point' may return 'require
238 ;; with `point' anywhere on this line. So wrap the
239 ;; `save-excursion' below in a `condition-case' to
240 ;; avoid reporting a scan-error here.
241 (condition-case nil
242 (save-excursion
243 (backward-up-list)
244 (forward-char)
245 (forward-sexp 2)
246 (thing-at-point 'symbol))
247 (error nil))
248 (thing-at-point 'symbol))))
249 (when (and def (not (test-completion def table)))
250 (setq def nil))
251 (list
252 (completing-read (if def (format "Library name (default %s): " def)
253 "Library name: ")
254 table nil nil nil nil def))))
255 (let ((buf (find-file-noselect (find-library-name library))))
256 (condition-case nil (switch-to-buffer buf) (error (pop-to-buffer buf)))))
258 ;;;###autoload
259 (defun find-function-search-for-symbol (symbol type library)
260 "Search for SYMBOL's definition of type TYPE in LIBRARY.
261 Visit the library in a buffer, and return a cons cell (BUFFER . POSITION),
262 or just (BUFFER . nil) if the definition can't be found in the file.
264 If TYPE is nil, look for a function definition.
265 Otherwise, TYPE specifies the kind of definition,
266 and it is interpreted via `find-function-regexp-alist'.
267 The search is done in the source for library LIBRARY."
268 (if (null library)
269 (error "Don't know where `%s' is defined" symbol))
270 ;; Some functions are defined as part of the construct
271 ;; that defines something else.
272 (while (and (symbolp symbol) (get symbol 'definition-name))
273 (setq symbol (get symbol 'definition-name)))
274 (if (string-match "\\`src/\\(.*\\.\\(c\\|m\\)\\)\\'" library)
275 (find-function-C-source symbol (match-string 1 library) type)
276 (when (string-match "\\.el\\(c\\)\\'" library)
277 (setq library (substring library 0 (match-beginning 1))))
278 ;; Strip extension from .emacs.el to make sure symbol is searched in
279 ;; .emacs too.
280 (when (string-match "\\.emacs\\(.el\\)" library)
281 (setq library (substring library 0 (match-beginning 1))))
282 (let* ((filename (find-library-name library))
283 (regexp-symbol (cdr (assq type find-function-regexp-alist))))
284 (with-current-buffer (find-file-noselect filename)
285 (let ((regexp (format (symbol-value regexp-symbol)
286 ;; Entry for ` (backquote) macro in loaddefs.el,
287 ;; (defalias (quote \`)..., has a \ but
288 ;; (symbol-name symbol) doesn't. Add an
289 ;; optional \ to catch this.
290 (concat "\\\\?"
291 (regexp-quote (symbol-name symbol)))))
292 (case-fold-search))
293 (with-syntax-table emacs-lisp-mode-syntax-table
294 (goto-char (point-min))
295 (if (or (re-search-forward regexp nil t)
296 ;; `regexp' matches definitions using known forms like
297 ;; `defun', or `defvar'. But some functions/variables
298 ;; are defined using special macros (or functions), so
299 ;; if `regexp' can't find the definition, we look for
300 ;; something of the form "(SOMETHING <symbol> ...)".
301 ;; This fails to distinguish function definitions from
302 ;; variable declarations (or even uses thereof), but is
303 ;; a good pragmatic fallback.
304 (re-search-forward
305 (concat "^([^ ]+" find-function-space-re "['(]?"
306 (regexp-quote (symbol-name symbol))
307 "\\_>")
308 nil t))
309 (progn
310 (beginning-of-line)
311 (cons (current-buffer) (point)))
312 (cons (current-buffer) nil))))))))
314 ;;;###autoload
315 (defun find-function-noselect (function &optional lisp-only)
316 "Return a pair (BUFFER . POINT) pointing to the definition of FUNCTION.
318 Finds the source file containing the definition of FUNCTION
319 in a buffer and the point of the definition. The buffer is
320 not selected. If the function definition can't be found in
321 the buffer, returns (BUFFER).
323 If FUNCTION is a built-in function, this function normally
324 attempts to find it in the Emacs C sources; however, if LISP-ONLY
325 is non-nil, signal an error instead.
327 If the file where FUNCTION is defined is not known, then it is
328 searched for in `find-function-source-path' if non-nil, otherwise
329 in `load-path'."
330 (if (not function)
331 (error "You didn't specify a function"))
332 (let ((def (symbol-function (find-function-advised-original function)))
333 aliases)
334 ;; FIXME for completeness, it might be nice to print something like:
335 ;; foo (which is advised), which is an alias for bar (which is advised).
336 (while (symbolp def)
337 (or (eq def function)
338 (if aliases
339 (setq aliases (concat aliases
340 (format ", which is an alias for `%s'"
341 (symbol-name def))))
342 (setq aliases (format "`%s' is an alias for `%s'"
343 function (symbol-name def)))))
344 (setq function (symbol-function (find-function-advised-original function))
345 def (symbol-function (find-function-advised-original function))))
346 (if aliases
347 (message "%s" aliases))
348 (let ((library
349 (cond ((autoloadp def) (nth 1 def))
350 ((subrp def)
351 (if lisp-only
352 (error "%s is a built-in function" function))
353 (help-C-file-name def 'subr))
354 ((symbol-file function 'defun)))))
355 (find-function-search-for-symbol function nil library))))
357 (defun find-function-read (&optional type)
358 "Read and return an interned symbol, defaulting to the one near point.
360 If TYPE is nil, insist on a symbol with a function definition.
361 Otherwise TYPE should be `defvar' or `defface'.
362 If TYPE is nil, defaults using `function-called-at-point',
363 otherwise uses `variable-at-point'."
364 (let* ((symb1 (cond ((null type) (function-called-at-point))
365 ((eq type 'defvar) (variable-at-point))
366 (t (variable-at-point t))))
367 (symb (unless (eq symb1 0) symb1))
368 (predicate (cdr (assq type '((nil . fboundp)
369 (defvar . boundp)
370 (defface . facep)))))
371 (prompt-type (cdr (assq type '((nil . "function")
372 (defvar . "variable")
373 (defface . "face")))))
374 (prompt (concat "Find " prompt-type
375 (and symb (format " (default %s)" symb))
376 ": "))
377 (enable-recursive-minibuffers t))
378 (list (intern (completing-read
379 prompt obarray predicate
380 t nil nil (and symb (symbol-name symb)))))))
382 (defun find-function-do-it (symbol type switch-fn)
383 "Find Emacs Lisp SYMBOL in a buffer and display it.
384 TYPE is nil to search for a function definition,
385 or else `defvar' or `defface'.
387 The variable `find-function-recenter-line' controls how
388 to recenter the display. SWITCH-FN is the function to call
389 to display and select the buffer.
390 See also `find-function-after-hook'.
392 Set mark before moving, if the buffer already existed."
393 (let* ((orig-point (point))
394 (orig-buf (window-buffer))
395 (orig-buffers (buffer-list))
396 (buffer-point (save-excursion
397 (find-definition-noselect symbol type)))
398 (new-buf (car buffer-point))
399 (new-point (cdr buffer-point)))
400 (when buffer-point
401 (when (memq new-buf orig-buffers)
402 (push-mark orig-point))
403 (funcall switch-fn new-buf)
404 (when new-point (goto-char new-point))
405 (recenter find-function-recenter-line)
406 (run-hooks 'find-function-after-hook))))
408 ;;;###autoload
409 (defun find-function (function)
410 "Find the definition of the FUNCTION near point.
412 Finds the source file containing the definition of the function
413 near point (selected by `function-called-at-point') in a buffer and
414 places point before the definition.
415 Set mark before moving, if the buffer already existed.
417 The library where FUNCTION is defined is searched for in
418 `find-function-source-path', if non-nil, otherwise in `load-path'.
419 See also `find-function-recenter-line' and `find-function-after-hook'."
420 (interactive (find-function-read))
421 (find-function-do-it function nil 'switch-to-buffer))
423 ;;;###autoload
424 (defun find-function-other-window (function)
425 "Find, in another window, the definition of FUNCTION near point.
427 See `find-function' for more details."
428 (interactive (find-function-read))
429 (find-function-do-it function nil 'switch-to-buffer-other-window))
431 ;;;###autoload
432 (defun find-function-other-frame (function)
433 "Find, in another frame, the definition of FUNCTION near point.
435 See `find-function' for more details."
436 (interactive (find-function-read))
437 (find-function-do-it function nil 'switch-to-buffer-other-frame))
439 ;;;###autoload
440 (defun find-variable-noselect (variable &optional file)
441 "Return a pair `(BUFFER . POINT)' pointing to the definition of VARIABLE.
443 Finds the library containing the definition of VARIABLE in a buffer and
444 the point of the definition. The buffer is not selected.
445 If the variable's definition can't be found in the buffer, return (BUFFER).
447 The library where VARIABLE is defined is searched for in FILE or
448 `find-function-source-path', if non-nil, otherwise in `load-path'."
449 (if (not variable)
450 (error "You didn't specify a variable")
451 (let ((library (or file
452 (symbol-file variable 'defvar)
453 (help-C-file-name variable 'var))))
454 (find-function-search-for-symbol variable 'defvar library))))
456 ;;;###autoload
457 (defun find-variable (variable)
458 "Find the definition of the VARIABLE at or before point.
460 Finds the library containing the definition of the variable
461 near point (selected by `variable-at-point') in a buffer and
462 places point before the definition.
464 Set mark before moving, if the buffer already existed.
466 The library where VARIABLE is defined is searched for in
467 `find-function-source-path', if non-nil, otherwise in `load-path'.
468 See also `find-function-recenter-line' and `find-function-after-hook'."
469 (interactive (find-function-read 'defvar))
470 (find-function-do-it variable 'defvar 'switch-to-buffer))
472 ;;;###autoload
473 (defun find-variable-other-window (variable)
474 "Find, in another window, the definition of VARIABLE near point.
476 See `find-variable' for more details."
477 (interactive (find-function-read 'defvar))
478 (find-function-do-it variable 'defvar 'switch-to-buffer-other-window))
480 ;;;###autoload
481 (defun find-variable-other-frame (variable)
482 "Find, in another frame, the definition of VARIABLE near point.
484 See `find-variable' for more details."
485 (interactive (find-function-read 'defvar))
486 (find-function-do-it variable 'defvar 'switch-to-buffer-other-frame))
488 ;;;###autoload
489 (defun find-definition-noselect (symbol type &optional file)
490 "Return a pair `(BUFFER . POINT)' pointing to the definition of SYMBOL.
491 If the definition can't be found in the buffer, return (BUFFER).
492 TYPE says what type of definition: nil for a function, `defvar' for a
493 variable, `defface' for a face. This function does not switch to the
494 buffer nor display it.
496 The library where SYMBOL is defined is searched for in FILE or
497 `find-function-source-path', if non-nil, otherwise in `load-path'."
498 (cond
499 ((not symbol)
500 (error "You didn't specify a symbol"))
501 ((null type)
502 (find-function-noselect symbol))
503 ((eq type 'defvar)
504 (find-variable-noselect symbol file))
506 (let ((library (or file (symbol-file symbol type))))
507 (find-function-search-for-symbol symbol type library)))))
509 ;; For symmetry, this should be called find-face; but some programs
510 ;; assume that, if that name is defined, it means something else.
511 ;;;###autoload
512 (defun find-face-definition (face)
513 "Find the definition of FACE. FACE defaults to the name near point.
515 Finds the Emacs Lisp library containing the definition of the face
516 near point (selected by `variable-at-point') in a buffer and
517 places point before the definition.
519 Set mark before moving, if the buffer already existed.
521 The library where FACE is defined is searched for in
522 `find-function-source-path', if non-nil, otherwise in `load-path'.
523 See also `find-function-recenter-line' and `find-function-after-hook'."
524 (interactive (find-function-read 'defface))
525 (find-function-do-it face 'defface 'switch-to-buffer))
527 ;;;###autoload
528 (defun find-function-on-key (key)
529 "Find the function that KEY invokes. KEY is a string.
530 Set mark before moving, if the buffer already existed."
531 (interactive "kFind function on key: ")
532 (let (defn)
533 (save-excursion
534 (let* ((event (and (eventp key) (aref key 0))) ; Null event OK below.
535 (start (event-start event))
536 (modifiers (event-modifiers event))
537 (window (and (or (memq 'click modifiers) (memq 'down modifiers)
538 (memq 'drag modifiers))
539 (posn-window start))))
540 ;; For a mouse button event, go to the button it applies to
541 ;; to get the right key bindings. And go to the right place
542 ;; in case the keymap depends on where you clicked.
543 (when (windowp window)
544 (set-buffer (window-buffer window))
545 (goto-char (posn-point start)))
546 (setq defn (key-binding key))))
547 (let ((key-desc (key-description key)))
548 (if (or (null defn) (integerp defn))
549 (message "%s is unbound" key-desc)
550 (if (consp defn)
551 (message "%s runs %s" key-desc (prin1-to-string defn))
552 (find-function-other-window defn))))))
554 ;;;###autoload
555 (defun find-function-at-point ()
556 "Find directly the function at point in the other window."
557 (interactive)
558 (let ((symb (function-called-at-point)))
559 (when symb
560 (find-function-other-window symb))))
562 ;;;###autoload
563 (defun find-variable-at-point ()
564 "Find directly the variable at point in the other window."
565 (interactive)
566 (let ((symb (variable-at-point)))
567 (when (and symb (not (equal symb 0)))
568 (find-variable-other-window symb))))
570 ;;;###autoload
571 (defun find-function-setup-keys ()
572 "Define some key bindings for the find-function family of functions."
573 (define-key ctl-x-map "F" 'find-function)
574 (define-key ctl-x-4-map "F" 'find-function-other-window)
575 (define-key ctl-x-5-map "F" 'find-function-other-frame)
576 (define-key ctl-x-map "K" 'find-function-on-key)
577 (define-key ctl-x-map "V" 'find-variable)
578 (define-key ctl-x-4-map "V" 'find-variable-other-window)
579 (define-key ctl-x-5-map "V" 'find-variable-other-frame))
581 (provide 'find-func)
583 ;;; find-func.el ends here