;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:03 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/find-func.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(custom-declare-group 'find-function nil "Finds the definition of the Emacs Lisp symbol near point." :group 'lisp)
(defconst find-function-space-re "\\(?:\\s-\\|\n\\|;.*\n\\)+")
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\305\306\307\310\311&	\210\300\315\316\317\304\305\306\307\310\320&	\207" [custom-declare-variable find-function-regexp (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.\nNote it must contain a `%s' at the place where `format'\nshould insert the function name.  The default value avoids `defconst',\n`defgroup', `defvar', `defface'.\n\nPlease send improvements and fixes to the maintainer." :type regexp :group find-function :version "21.1" 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.\nNote it must contain a `%s' at the place where `format'\nshould insert the variable name.  The default value\navoids `defun', `defmacro', `defalias', `defadvice', `defgroup', `defface'.\n\nPlease send improvements and fixes to the maintainer." find-face-regexp (concat "^\\s-*(defface" find-function-space-re "%s\\(\\s-\\|$\\)") "The regexp used by `find-face' to search for a face definition.\nNote it must contain a `%s' at the place where `format'\nshould insert the face name.\n\nPlease send improvements and fixes to the maintainer." "22.1"] 10)
#@185 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.
(defvar find-function-regexp-alist '((nil . find-function-regexp) (defvar . find-variable-regexp) (defface . find-face-regexp)) (#$ . 2413))
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311\312\313&\210\304\314\315\316\310\317\312\313\320\321&	\210\304\322\306\323\310\324\312\313\320\321&	\207" [put find-function-regexp-alist risky-local-variable t custom-declare-variable find-function-source-path nil "The default list of directories where `find-function' searches.\n\nIf this variable is nil then `find-function' searches `load-path' by\ndefault." :type (repeat directory) :group find-function find-function-recenter-line 1 "The window line-number from which to start displaying a symbol definition.\nA value of nil implies center the beginning of the definition.\nSee `find-function' and `find-variable'." (choice (const :tag "Center" nil) integer) :version "20.3" find-function-after-hook "Hook run after finding symbol definition.\n\nSee the functions `find-function' and `find-variable'." hook] 10)
(defalias 'find-library-suffixes #[nil "\303\304 \303\211\203 \n@\305\306	\"\204	B\nA\211\204\303\237+\207" [suffixes suffix --dolist-tail-- nil get-load-suffixes string-match "elc"] 4])
(defalias 'find-library--load-name #[(library) "\n\306\211\203+\f@\307\"\310\311
\"\204#
G	GW\203#
)\fA\211\204\n*	\232?\2054	)\207" [library name load-path dir --dolist-tail-- rel nil file-relative-name string-match "\\`\\.\\./"] 4])
#@122 Return the absolute file name of the Emacs Lisp source of LIBRARY.
LIBRARY should be a string (the name of the library).
(defalias 'find-library-name #[(library) "\305\306\"\203\307\310\311\211$\312	\206\n\313 #\206S\312	\206\"\n#\206S\314!\203O\315!\211\205K\312\f	\206<\n\313 #\206K\312\f	\206I\n#)\206S\316\317\"\207" [library find-function-source-path load-path load-file-rep-suffixes rel string-match "\\.el\\(c\\(\\..*\\)?\\)\\'" replace-match "" t locate-file find-library-suffixes file-name-absolute-p find-library--load-name error "Can't find library %s"] 6 (#$ . 4074)])
#@143 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.
(defvar find-function-C-source-directory (byte-code "\302\303\"\304	!\205\305	!\205	)\207" [source-directory dir expand-file-name "src" file-directory-p file-readable-p] 3) (#$ . 4686))
#@135 Return the original function symbol of an advised function FUNC.
If FUNC is not the symbol of an advised function, just returns FUNC.
(defalias 'find-function-advised-original #[(func) "9\203\302\303!\203\304\305!\236A\306	!\205	)\206\207" [func ofunc featurep advice origname ad-get-advice-info fboundp] 3 (#$ . 5027)])
#@134 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.
(defalias 'find-function-C-source #[(fun-or-var file type) "\206\n\305\306\307\211\310$\311\n	\"\312\n!\203\204&	\202&\313\314\315\n!\"\210)\2043\316\317\316\f!!!r\320\n!q\210eb\210\321\203L\322\323\324\f!!\325Q\202T\326\323\327\f!!\325Q\307\310#\204_\313\330\f\"\210p\331\224)B\207" [find-function-C-source-directory dir file type fun-or-var read-directory-name "Emacs C source dir: " nil t expand-file-name file-readable-p error "The C source file %s is not available" file-name-nondirectory find-function-advised-original indirect-function find-file-noselect re-search-forward "DEFVAR[A-Z_]*[ 	\n]*([ 	\n]*\"" regexp-quote symbol-name "\"" "DEFUN[ 	\n]*([ 	\n]*\"" subr-name "Can't find source for %s" 0] 5 (#$ . 5367)])
#@94 Find the Emacs Lisp source of LIBRARY.
LIBRARY should be a string (the name of the library).
(defalias 'find-library #[(library) "\302\303!!\304\305\306\217)\207" [library buf find-file-noselect find-library-name nil (switch-to-buffer buf) ((error (pop-to-buffer buf)))] 3 (#$ . 6247) (let* ((dirs (or find-function-source-path load-path)) (suffixes (find-library-suffixes)) (table (apply-partially 'locate-file-completion-table dirs suffixes)) (def (if (eq (function-called-at-point) 'require) (condition-case nil (save-excursion (backward-up-list) (forward-char) (forward-sexp 2) (thing-at-point 'symbol)) (error nil)) (thing-at-point 'symbol)))) (if (and def (not (test-completion def table))) (progn (setq def nil))) (list (completing-read (if def (format "Library name (default %s): " def) "Library name: ") table nil nil nil nil def)))])
#@410 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.
(defalias 'find-function-search-for-symbol #[(symbol type library) "\204	\306\307	\"\210	9\203	\310N\203	\310N\211\202\n\311\312\"\203,\313	\314\315\"\n#\207\311\316\"\2039\317\315\224O\311\320\"\203F\317\315\224O\321!\n\f\236Ar\322!q\210\323
J\324\325\326	!!P\"\327!\"\330 p#$\331\216\332%!\210eb\210\333\"\327\334#\204\222\333\335&\336\325\326	!!\337\260\327\334#\203\233\340 \210p`B\202\236p\327B.\207" [library symbol type filename find-function-regexp-alist regexp-symbol error "Don't know where `%s' is defined" definition-name string-match "\\`src/\\(.*\\.\\(c\\|m\\)\\)\\'" find-function-C-source match-string 1 "\\.el\\(c\\)\\'" 0 "\\.emacs\\(.el\\)" find-library-name find-file-noselect format "\\\\?" regexp-quote symbol-name nil syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1=#:buffer #2=#:table set-syntax-table] 2)) set-syntax-table re-search-forward t "^([^ ]+" "['(]?" "\\_>" beginning-of-line case-fold-search regexp #1# #2# emacs-lisp-mode-syntax-table find-function-space-re] 8 (#$ . 7100)])
#@592 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 FUNCTION is a built-in function, this function normally
attempts to find it in the Emacs C sources; however, if LISP-ONLY
is non-nil, signal an error instead.

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'.
(defalias 'find-function-noselect #[(function &optional lisp-only) "\204\306\307!\210\310!K\311\2119\203@\n=\2042	\203*	\312\313\314\n!\"P\2022\312\315\314\n!#\310!K\310!K\211\202	\203I\316\317	\"\210\n\211\242)\320=\203Y\nA@\202s\321\n!\203o\f\203h\306\322\"\210\323\n\324\"\202s\325\326\"\327\311
#+\207" [function aliases def object lisp-only library error "You didn't specify a function" find-function-advised-original nil format ", which is an alias for `%s'" symbol-name "`%s' is an alias for `%s'" message "%s" autoload subrp "%s is a built-in function" help-C-file-name subr symbol-file defun find-function-search-for-symbol] 6 (#$ . 8573)])
#@278 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'.
(defalias 'find-function-read #[(&optional type) "\204	\306 \202\307=\203\310 \202\310\311!\211\312=?\205 	\313\236A\314\236A\315\f\n\2055\316\317\n\"\320R\311\321\322
\311\323\211\n\205K\324\n!&!.C\207" [type symb1 symb predicate prompt-type prompt function-called-at-point defvar variable-at-point t 0 ((nil . fboundp) (defvar . boundp) (defface . facep)) ((nil . "function") (defvar . "variable") (defface . "face")) "Find " format " (default %s)" ": " intern completing-read nil symbol-name enable-recursive-minibuffers obarray] 11 (#$ . 9852)])
#@376 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.
(defalias 'find-function-do-it #[(symbol type switch-fn) "`\306 \307 \212\310\f\")\211@

A
\205=
\n>\203&\311!\210
!\210\2035b\210\312!\210\313\314!.\207" [orig-point orig-buf orig-buffers symbol type buffer-point window-buffer buffer-list find-definition-noselect push-mark recenter run-hooks find-function-after-hook new-buf new-point switch-fn find-function-recenter-line] 4 (#$ . 10712)])
#@469 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'.
(defalias 'find-function #[(function) "\301\302\303#\207" [function find-function-do-it nil switch-to-buffer] 4 (#$ . 11510) (find-function-read)])
#@104 Find, in another window, the definition of FUNCTION near point.

See `find-function' for more details.
(defalias 'find-function-other-window #[(function) "\301\302\303#\207" [function find-function-do-it nil switch-to-buffer-other-window] 4 (#$ . 12134) (find-function-read)])
#@103 Find, in another frame, the definition of FUNCTION near point.

See `find-function' for more details.
(defalias 'find-function-other-frame #[(function) "\301\302\303#\207" [function find-function-do-it nil switch-to-buffer-other-frame] 4 (#$ . 12419) (find-function-read)])
#@414 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'.
(defalias 'find-variable-noselect #[(variable &optional file) "\204\303\304!\207	\206\305\306\"\206\307\310\"\311\306\n#)\207" [variable file library error "You didn't specify a variable" symbol-file defvar help-C-file-name var find-function-search-for-symbol] 4 (#$ . 12701)])
#@467 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'.
(defalias 'find-variable #[(variable) "\301\302\303#\207" [variable find-function-do-it defvar switch-to-buffer] 4 (#$ . 13410) (byte-code "\300\301!\207" [find-function-read defvar] 2)])
#@104 Find, in another window, the definition of VARIABLE near point.

See `find-variable' for more details.
(defalias 'find-variable-other-window #[(variable) "\301\302\303#\207" [variable find-function-do-it defvar switch-to-buffer-other-window] 4 (#$ . 14072) (byte-code "\300\301!\207" [find-function-read defvar] 2)])
#@103 Find, in another frame, the definition of VARIABLE near point.

See `find-variable' for more details.
(defalias 'find-variable-other-frame #[(variable) "\301\302\303#\207" [variable find-function-do-it defvar switch-to-buffer-other-frame] 4 (#$ . 14397) (byte-code "\300\301!\207" [find-function-read defvar] 2)])
#@431 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'.
(defalias 'find-definition-noselect #[(symbol type &optional file) "\204\304\305!\207	\204\306!\207	\307=\203\310\n\"\207\n\206#\311	\"\312	#)\207" [symbol type file library error "You didn't specify a symbol" find-function-noselect defvar find-variable-noselect symbol-file find-function-search-for-symbol] 4 (#$ . 14719)])
#@482 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'.
(defalias 'find-face-definition #[(face) "\301\302\303#\207" [face find-function-do-it defface switch-to-buffer] 4 (#$ . 15495) (byte-code "\300\301!\207" [find-function-read defface] 2)])
#@110 Find the function that KEY invokes.  KEY is a string.
Set mark before moving, if the buffer already existed.
(defalias 'find-function-on-key #[(key) "\306\212\307	!\205\f	\310H\311\n!\312\n!\313\f>\204'\314\f>\204'\315\f>\205,\211@)\316!\203W\317!q\210\320
8\206T
A@:\203Q
A@@\202T
A@)b\210\321	!-\322	!\203j\250\203r\323\324\"\202\205:\203\202\323\325\326!#\202\205\327!*\207" [defn key event start modifiers position nil eventp 0 event-start event-modifiers click down drag windowp window-buffer 5 key-binding key-description message "%s is unbound" "%s runs %s" prin1-to-string find-function-other-window window key-desc] 6 (#$ . 16173) "kFind function on key: "])
#@58 Find directly the function at point in the other window.
(defalias 'find-function-at-point #[nil "\301 \211\205\n\302!)\207" [symb function-called-at-point find-function-other-window] 3 (#$ . 16886) nil])
#@58 Find directly the variable at point in the other window.
(defalias 'find-variable-at-point #[nil "\301 \211\205\302\232?\205\303!)\207" [symb variable-at-point 0 find-variable-other-window] 3 (#$ . 17100) nil])
#@69 Define some key bindings for the find-function family of functions.
(defalias 'find-function-setup-keys #[nil "\303\304\305#\210\303	\304\306#\210\303\n\304\307#\210\303\310\311#\210\303\312\313#\210\303	\312\314#\210\303\n\312\315#\207" [ctl-x-map ctl-x-4-map ctl-x-5-map define-key "F" find-function find-function-other-window find-function-other-frame "K" find-function-on-key "V" find-variable find-variable-other-window find-variable-other-frame] 4 (#$ . 17324)])
(provide 'find-func)