Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/progmodes/etags.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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.

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\207" [require ring button xref fileloop] 2)
#@272 File name of tags table.
To switch to a new tags table, do not set this variable; instead,
invoke `visit-tags-table', which is the only reliable way of
setting the value of this variable, whether buffer-local or global.
Use the `etags' program to make a tags table file.
(defvar tags-file-name nil (#$ . 514))
(byte-code "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\314\315\316\317\320\321&	\210\306\322\310\311\323DD\324\314\325%\210\306\326\310\311\327DD\330\316\331\314\332&\210\306\333\310\311\334DD\335\314\336%\210\306\337\310\311\340DD\341\314\342%\207" [custom-declare-group etags nil "Tags tables." :group tools custom-declare-variable tags-case-fold-search funcall function #[0 "\300\207" [default] 1] "Whether tags operations should be case-sensitive.\nA value of t means case-insensitive, a value of nil means case-sensitive.\nAny other value means use the setting of `case-fold-search'." :type (choice (const :tag "Case-sensitive" nil) (const :tag "Case-insensitive" t) (other :tag "Use default" default)) :version "21.1" :safe symbolp tags-table-list #[0 "\300\207" [nil] 1] "List of file names of tags tables to search.\nAn element that is a directory means the file \"TAGS\" in that directory.\nTo switch to a new list of tags tables, setting this variable is sufficient.\nIf you set this variable, do not also set `tags-file-name'.\nUse the `etags' program to make a tags table file." (repeat file) tags-compression-info-list #[0 "\300\301!\207" [purecopy ("" ".Z" ".bz2" ".gz" ".xz" ".tgz")] 2] "List of extensions tried by etags when `auto-compression-mode' is on.\nAn empty string means search the non-compressed file." "24.1" (repeat string) tags-add-tables #[0 "\300\207" [ask-user] 1] "Control whether to add a new tags table to the current list.\nt means do; nil means don't (always start a new list).\nAny other value means ask the user whether to add a new tags table\nto the current list (as opposed to starting a new list)." (choice (const :tag "Do" t) (const :tag "Don't" nil) (other :tag "Ask" ask-user)) tags-revert-without-query #[0 "\300\207" [nil] 1] "Non-nil means reread a TAGS table without querying, if it has changed." boolean] 10)
#@442 List of tags tables to search, computed from `tags-table-list'.
This includes tables implicitly included by other tables.  The list is not
always complete: the included tables of a table are not known until that
table is read into core.  An element that is t is a placeholder
indicating that the preceding element is a table that has not been read
into core and might contain included tables to search.
See `tags-table-check-computed-list'.
(defvar tags-table-computed-list nil (#$ . 2705))
#@202 Value of `tags-table-list' that `tags-table-computed-list' corresponds to.
If `tags-table-list' changes, `tags-table-computed-list' is thrown away and
recomputed; see `tags-table-check-computed-list'.
(defvar tags-table-computed-list-for nil (#$ . 3203))
#@150 Pointer into `tags-table-computed-list' for the current state of searching.
Use `visit-tags-table-buffer' to cycle through tags tables in this list.
(defvar tags-table-list-pointer nil (#$ . 3465))
#@76 Pointer into `tags-table-computed-list', where the current search started.
(defvar tags-table-list-started-at nil (#$ . 3669))
#@127 List of sets of tags table which have been used together in the past.
Each element is a list of strings which are file names.
(defvar tags-table-set-list nil (#$ . 3803))
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\313%\210\314\315\316\317#\210\320\211\203@\211@\315
N\2039\316
N\2049\321\316\315N#\210
A\266\202\202\210\322\315\316\323#\210\300\324\302\303\325DD\326\306\327\330\331&\210\300\332\302\303\333DD\334\306\335\330\331&\210\300\336\302\303\337DD\340\306\341\330\331&\210\314\342\343\"\210\322\342\344\323#\207" [custom-declare-variable find-tag-hook funcall function #[0 "\300\207" [nil] 1] "Hook to be run by \\[find-tag] after finding a tag.  See `run-hooks'.\nThe value in the buffer in which \\[find-tag] is done is used,\nnot the value in the buffer \\[find-tag] goes to." :type hook find-tag-default-function #[0 "\300\207" [nil] 1] "A function of no arguments used by \\[find-tag] to pick a default tag.\nIf nil, and the symbol that is the value of `major-mode'\nhas a `find-tag-default-function' property (see `put'), that is used.\nOtherwise, `find-tag-default' is used." (choice (const nil) function) defvaralias find-tag-marker-ring-length xref-marker-ring-length nil (saved-value saved-variable-comment) put make-obsolete-variable "25.1" tags-tag-face #[0 "\300\207" [default] 1] "Face for tags in the output of `tags-apropos'." face :version "21.1" tags-apropos-verbose #[0 "\300\207" [nil] 1] "If non-nil, print the name of the tags file in the *Tags List* buffer." boolean tags-apropos-additional-actions #[0 "\300\207" [nil] 1] "Specify additional actions for `tags-apropos'.\n\nIf non-nil, value should be a list of triples (TITLE FUNCTION\nTO-SEARCH).  For each triple, `tags-apropos' processes TO-SEARCH and\nlists tags from it.  TO-SEARCH should be an alist, obarray, or symbol.\nIf it is a symbol, the symbol's value is used.\nTITLE, a string, is a title used to label the additional list of tags.\nFUNCTION is a function to call when a symbol is selected in the\n*Tags List* buffer.  It will be called with one argument SYMBOL which\nis the symbol being selected.\n\nExample value:\n\n   ((\"Emacs Lisp\" Info-goto-emacs-command-node obarray)\n    (\"Common Lisp\" common-lisp-hyperspec common-lisp-hyperspec-obarray)\n    (\"SCWM\" scwm-documentation scwm-obarray))" (repeat (list (string :tag "Title") function (sexp :tag "Tags to search"))) find-tag-marker-ring xref--marker-ring "use `xref-push-marker-stack' or `xref-pop-marker-stack' instead."] 8)
#@181 If non-nil, a function to choose a default tags file for a buffer.
This function receives no arguments and should return the default
tags table file to use for the current buffer.
(defvar default-tags-table-function nil (#$ . 6346))
#@130 Ring of markers which are locations visited by \[find-tag].
Pop back to the last location with \[negative-argument] \[find-tag].
(defvar tags-location-ring (make-ring xref-marker-ring-length) (#$ . 6586))
#@133 List of file names covered by current tags table.
nil means it has not yet been computed;
use function `tags-table-files' to do so.
(defvar tags-table-files nil (#$ . 6798))
#@50 List of tag names defined in current tags table.
(defvar tags-completion-table nil (#$ . 6978))
#@57 List of tags tables included by the current tags table.
(defvar tags-included-tables nil (#$ . 7080))
#@268 Hook to be called in a tags table buffer to identify the type of tags table.
The functions are called in order, with no arguments,
until one returns non-nil.  The function should make buffer-local bindings
of the format-parsing tags function variables if successful.
(defvar tags-table-format-functions '(etags-recognize-tags-table tags-recognize-empty-tags-table) (#$ . 7189))
#@157 Function to do the work of `file-of-tag' (which see).
One optional argument, a boolean specifying to return complete path (nil) or
relative path (non-nil).
(defvar file-of-tag-function nil (#$ . 7574))
#@69 Function to do the work of function `tags-table-files' (which see).
(defvar tags-table-files-function nil (#$ . 7782))
#@48 Function to build the `tags-completion-table'.
(defvar tags-completion-table-function nil (#$ . 7907))
#@174 Function to get info about a matched tag for `goto-tag-location-function'.
One optional argument, specifying to use explicit tag (non-nil) or not (nil).
The default is nil.
(defvar snarf-tag-function nil (#$ . 8017))
#@130 Function of to go to the location in the buffer specified by a tag.
One argument, the tag info returned by `snarf-tag-function'.
(defvar goto-tag-location-function nil (#$ . 8241))
#@73 Search function passed to `find-tag-in-order' for finding a regexp tag.
(defvar find-tag-regexp-search-function nil (#$ . 8428))
#@67 Tag order passed to `find-tag-in-order' for finding a regexp tag.
(defvar find-tag-regexp-tag-order nil (#$ . 8563))
#@62 Flag passed to `find-tag-in-order' for finding a regexp tag.
(defvar find-tag-regexp-next-line-after-failure-p nil (#$ . 8686))
#@66 Search function passed to `find-tag-in-order' for finding a tag.
(defvar find-tag-search-function nil (#$ . 8820))
#@60 Tag order passed to `find-tag-in-order' for finding a tag.
(defvar find-tag-tag-order nil (#$ . 8941))
#@55 Flag passed to `find-tag-in-order' for finding a tag.
(defvar find-tag-next-line-after-failure-p nil (#$ . 9050))
#@53 Function to do the work of `list-tags' (which see).
(defvar list-tags-function nil (#$ . 9170))
#@56 Function to do the work of `tags-apropos' (which see).
(defvar tags-apropos-function nil (#$ . 9272))
#@73 Function to do the work of function `tags-included-tables' (which see).
(defvar tags-included-tables-function nil (#$ . 9380))
#@66 Function to return t if current buffer contains valid tags file.
(defvar verify-tags-table-function nil (#$ . 9513))
#@187 Initialize the tags table in the current buffer.
Return non-nil if it is a valid tags table, and
in that case, also make the tags table state variables
buffer-local and set them to nil.
(defalias 'initialize-new-tags-table #[0 "\303\300!\210\304\303\301!\210\304\303\302!\210\304\305\306!\207" [tags-table-files tags-completion-table tags-included-tables make-local-variable nil run-hook-with-args-until-success tags-table-format-functions] 2 (#$ . 9637)])
(defvar tags-table-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [tags-table-mode-hook variable-documentation put "Hook run after entering Tags Table mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp tags-table-mode-map definition-name tags-table-mode] 4)
(defvar tags-table-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [tags-table-mode-abbrev-table tags-table-mode-map variable-documentation put purecopy "Keymap for `tags-table-mode'." boundp tags-table-mode-syntax-table definition-name tags-table-mode (lambda (#1=#:def-tmp-var) (defvar tags-table-mode-syntax-table #1#)) make-syntax-table "Syntax table for `tags-table-mode'." (lambda (#1#) (defvar tags-table-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `tags-table-mode'." derived-mode-parent special-mode] 5)
#@242 Major mode for tags table file buffers.

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `tags-table-mode-hook', as the final or penultimate step
during initialization.

\{tags-table-mode-map}
(defalias 'tags-table-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\307\331 \210)\332\333!\207" [delay-mode-hooks major-mode mode-name tags-table-mode-map tags-table-mode-syntax-table tags-table-mode-abbrev-table make-local-variable t special-mode tags-table-mode "Tags Table" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table initialize-new-tags-table run-mode-hooks tags-table-mode-hook local-abbrev-table buffer-undo-list] 5 (#$ . 11305) nil])
#@581 Tell tags commands to use tags table file FILE.
FILE should be the name of a file created with the `etags' program.
A directory name is ok too; it means file TAGS in that directory.

Normally \[visit-tags-table] sets the global value of `tags-file-name'.
With a prefix arg, set the buffer-local value instead.  When called
from Lisp, if the optional arg LOCAL is non-nil, set the local value.
When you find a tag with \[find-tag], the buffer it finds the tag
in is given a local value of this variable which is the name of the tags
file the tag was in.

(fn FILE &optional LOCAL)
(defalias 'visit-tags-table #[513 "
;\204\f\302\303\304D\"\210
p
\212\305!\204 \302\306\307\310E\"\210r\211q\210)\262*\266\211\203=\311\301!\210\312\311\300!\210
\211\207\313\300\"\210\312\211\207" [tags-file-name tags-completion-table signal wrong-type-argument stringp visit-tags-table-buffer file-missing "Visiting tags table" "No such file or directory" make-local-variable nil set-default] 9 (#$ . 12359) (byte-code "\302\303\"\206\304\305\306\303\"\307$	D\207" [default-directory current-prefix-arg locate-dominating-file "TAGS" read-file-name "Visit tags table (default TAGS): " expand-file-name t] 7)])
#@73 Compute `tags-table-computed-list' from `tags-table-list' if necessary.
(defalias 'tags-table-check-computed-list #[0 "\303\304\"	
\232\206^\303\305\"\305
!\306\211\203V@B\262\307@!\262
\211\203J\212\310\311!!)\203Jr\211q\210\212\312 \203F\303\304\312 \"A\244\241\210*\202O\313B\262A\262\202
\237\211\266\204\207" [tags-table-list tags-table-computed-list-for tags-table-computed-list mapcar tags-expand-table-name copy-sequence nil get-file-buffer tags-verify-table buffer-file-name tags-included-tables t] 9 (#$ . 13577)])
#@330 Extend `tags-table-computed-list' to remove the first t placeholder.

An element of the list that is t is a placeholder indicating that the
preceding element is a table that has not been read in and might
contain included tables to search.  This function reads in the first
such table and puts its included tables into the list.
(defalias 'tags-table-extend-computed-list #[0 "\211A@\301=\204\211A\262
\202
\212\302
@!\203a\303 \304\211\203Q@B\262\305@!\262
\211\203Er\211q\210\303 \203A\306\303 \"\241\210)\202J\301B\262A\262\202
\237\262AA\244\241\266\203\202f\211
AA\241)\207" [tags-table-computed-list t tags-verify-table tags-included-tables nil get-file-buffer append] 8 (#$ . 14134)])
#@67 Expand tags table name FILE into a complete file name.

(fn FILE)
(defalias 'tags-expand-table-name #[257 "\300
!\262
\301
!\203\300\302\"\207\207" [expand-file-name file-directory-p "TAGS"] 4 (#$ . 14859)])
#@251 Like (member FILE LIST) after applying `tags-expand-table-name'.
More precisely, apply `tags-expand-table-name' to FILE
and each element of LIST, returning the link whose car is the first match.
If an element of LIST is t, ignore it.

(fn FILE LIST)
(defalias 'tags-table-list-member #[514 "\300!\262\211\203 \211@\301=\204
\300@!\230\204 \211A\262
\202\207" [tags-expand-table-name t] 5 (#$ . 15077)])
#@179 Read FILE into a buffer and verify that it is a valid tags table.
Sets the current buffer to one visiting FILE (if it exists).
Returns non-nil if it is a valid table.

(fn FILE)
(defalias 'tags-verify-table #[257 "\306
!\203Q\306
!q\210\204\307 \210\310p!\204J	\311
\2030\312@\n\"\203)\313\262

A\262\202\262
\204B\204B\314\315\316\"!\203J\317\313\211\"\210\307 \210\205\205 \207\320
!\205\205\321
!\302
!
\230\204w\f\235\211\203n\211\240\210\210
=\203w\211
q\210\307 \210\205\203 \266\202\207" [verify-tags-table-function revert-without-query buffer-file-name tags-revert-without-query tags-table-list tags-file-name get-file-buffer tags-table-mode verify-visited-file-modtime nil string-match t yes-or-no-p format "Tags file %s has changed, read new contents? " revert-buffer file-exists-p find-file-noselect] 6 (#$ . 15496)])
#@357 Search current tags tables for tags for THIS-FILE.
Subroutine of `visit-tags-table-buffer'.
Looks for a tags table that has such tags or that includes a table
that has them.  Returns the name of the first such table.
Non-nil CORE-ONLY means check only tags tables that are already in
buffers.  If CORE-ONLY is nil, it is ignored.

(fn THIS-FILE CORE-ONLY)
(defalias 'tags-table-including #[514 "\303\211\204I
\203I\203
A@\304=\203)
AA\262\202
A@\304=\203)\305 \210
\203B
@\306\307!\210\310\311\312 \"\235\203A
\262
)
A\262\202\211\205w\303\211A=\204t\313
@\n\"\203b\211@\262\211A\262
\211@\304=\203O\211A\262
\202O
\266\202\207" [tags-table-computed-list tags-file-name tags-table-list nil t tags-table-extend-computed-list visit-tags-table-buffer same mapcar expand-file-name tags-table-files tags-table-list-member] 9 (#$ . 16363)])
#@136 Move `tags-table-list-pointer' along and set `tags-file-name'.
Subroutine of `visit-tags-table-buffer'.Returns nil when out of tables.
(defalias 'tags-next-table #[0 "A@\304=\203\305 \210\202A\211\204	\n=\203!\306\211\207@\211\207" [tags-table-list-pointer tags-table-computed-list tags-table-list-started-at tags-file-name t tags-table-extend-computed-list nil] 3 (#$ . 17231)])
#@705 Select the buffer containing the current tags table.
Optional arg CONT specifies which tags table to visit.
If CONT is a string, visit that file as a tags table.
If CONT is t, visit the next table in `tags-table-list'.
If CONT is the atom `same', don't look for a new table;
 just select the buffer visiting `tags-file-name'.
If CONT is nil or absent, choose a first buffer from information in
 `tags-file-name', `tags-table-list', `tags-table-list-pointer'.
Optional second arg CBUF, if non-nil, specifies the initial buffer,
which is important if that buffer has a local value of `tags-file-name'.
Returns t if it visits a tags table, or nil if there are no more in the list.

(fn &optional CONT CBUF)
(defalias 'visit-tags-table-buffer #[512 "\211\203\211q\210
\306\267\2024\204\252\307\310\311\312!\"\210\202\252\313 \203\252\314!\204\252\315!\204\252\313 \204 \202\252\316 \210
;\203C
\317\262\206\251\300\320 \236A\206\251	\203T	 \206\251\n\203hr\321\n\322\"\206d\321\n\317\")\206\251\203w\323\"\204w\206\251\f\317
\203\232\324@!\211\262\203\232\314
!\204\232\315
!\204\232
A\262\202y
@\266\202\206\251\325\326\327
\330\322$!\324!
\322=\205\267$??\205\213
p\331
!\203l
\332p!\210\204h
\323
\"\211\203\334\211$\211%\202g
&\211\203\361\323@\"\204\361\211A\262
\202\336\211\203
\f&>\204
\f&B&\211@\202]
\f\203%
'\322=\204
'\203%
\333\334!\203%
\fB\202]
\335\336!\210\f\203:
\f&>\204:
\f&B&\f\211\203Y
\211@\211;\203R
\337
!\211\203Q
\340
!\210\210
A\266\202\202;
\210C\316 \210%$\210\210\322\202\211

q\210\341\300!\210\211=\203{
\317\307\315!\203\206
\342\202\207
\343\"\266\202\207" [tags-file-name default-tags-table-function buffer-file-name tags-table-computed-list tags-table-list default-directory #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (same 13 t 27)) user-error "%s" substitute-command-keys "No tags table in use; use \\[visit-tags-table] to select one" tags-next-table get-file-buffer file-exists-p tags-table-check-computed-list nil buffer-local-variables tags-table-including t tags-table-list-member tags-expand-table-name expand-file-name read-file-name "Visit tags table (default TAGS): " "TAGS" tags-verify-table bury-buffer y-or-n-p "Keep current list of tags tables also? " message "Starting a new list of tags tables" find-buffer-visiting kill-buffer kill-local-variable "File %s is not a valid tags table" "File %s does not exist" tags-table-list-pointer tags-table-list-started-at tags-table-set-list tags-add-tables] 11 (#$ . 17633)])
#@87 Reset tags state to cancel effect of any previous \[visit-tags-table] or \[find-tag].
(defalias 'tags-reset-tags-tables #[0 "\306\211W\203	AA
H\203	AA
H\307\211\223\210\211T\262
\202
\210\310 \210\307\311!\307\211\307\211\n\307\211\211\f\207" [xref-marker-ring-length tags-location-ring tags-file-name tags-table-list tags-table-computed-list tags-table-computed-list-for 0 nil xref-clear-marker-stack make-ring tags-table-list-pointer tags-table-list-started-at tags-table-set-list] 5 (#$ . 20224) nil])
#@272 Return the file name of the file whose tags point is within.
Assumes the tags table is the current buffer.
If RELATIVE is non-nil, file name returned is relative to tags
table file's directory. If RELATIVE is nil, file name returned
is complete.

(fn &optional RELATIVE)
(defalias 'file-of-tag #[256 "
!\207" [file-of-tag-function] 3 (#$ . 20752)])
#@223 Return a list of files in the current tags table.
Assumes the tags table is the current buffer.  The file names are returned
as they appeared in the `etags' command that created the table, usually
without directory names.
(defalias 'tags-table-files #[0 "\206	 \211\207" [tags-table-files tags-table-files-function] 2 (#$ . 21109)])
#@107 Return a list of tags tables included by the current table.
Assumes the tags table is the current buffer.
(defalias 'tags-included-tables #[0 "\206	 \211\207" [tags-included-tables tags-included-tables-function] 2 (#$ . 21453)])
#@342 Build `tags-completion-table' on demand for a buffer's tags tables.
Optional argument BUF specifies the buffer for which to build
`tags-completion-table', and defaults to the current buffer.
The tags included in the completion table are those in the current
tags table for BUF and its (recursively) included tags tables.

(fn &optional BUF)
(defalias 'tags-completion-table #[256 "\211\204p\262
r\211q\210\206K\3031C\304\211\305\306	\"\210\212\307
\"\203.\n B\262\310\262
\202)\305\311	\"\210\312\313\314\"!\237\211\266\2020\202K\210\305\315!\210\304\211)\207" [tags-completion-table buffer-file-name tags-completion-table-function (quit) nil message "Making tags completion table for %s..." visit-tags-table-buffer t "Making tags completion table for %s...done" delete-dups apply nconc "Tags completion table construction aborted."] 7 (#$ . 21693)])
(defalias 'tags-lazy-completion-table #[0 "p\300\301\302\303\304!\305\"\306\307%\207" [make-byte-code 771 "r\300q\210\212\302\303 \210)\304
\305\300!$*\207" vconcat vector [enable-recursive-minibuffers t visit-tags-table-buffer complete-with-action tags-completion-table] 8 "\n\n(fn STRING PRED ACTION)"] 7])
#@121 Using tags, return a completion table for the text around point.
If no tags table is loaded, do nothing and return nil.
(defalias 'tags-completion-at-point-function #[0 "\204	\2057\303 \304 \305
\2054\212\306`G\307#b\210\310\305\311#\2053`\262

Gu\210\211`\312 \313\314\257))\266\203\207" [tags-table-list tags-file-name completion-ignore-case find-tag--completion-ignore-case find-tag--default nil + -1 search-backward t tags-lazy-completion-table :exclusive no] 8 (#$ . 22879)])
#@63 Read a tag name, with defaulting and completion.

(fn STRING)
(defalias 'find-tag-tag #[257 "\301 \302 \303
\203\304\305\306\307\310\311	\"##\202\312 \313\211\211\211&\211\314\232\2035
\2066\315\316!\2026\211)\207" [completion-ignore-case find-tag--completion-ignore-case find-tag--default completing-read format "%s (default %s): " substring 0 string-match "[ :]+\\'" tags-lazy-completion-table nil "" user-error "There is no default tag"] 11 (#$ . 23377)])
(defalias 'find-tag--completion-ignore-case #[0 "\302>\203\207	\207" [tags-case-fold-search case-fold-search (t nil)] 2])
(defalias 'find-tag--default #[0 "\206	\300N\206\302 \207" [find-tag-default-function major-mode find-tag-default] 2])
#@32 Last tag found by \[find-tag].
(defvar last-tag nil (#$ . 24107))
#@178 Get interactive arguments for tag functions.
The functions using this are `find-tag-noselect',
`find-tag-other-window', and `find-tag-regexp'.

(fn PROMPT &optional NO-DEFAULT)
(defalias 'find-tag-interactive #[513 "\203	\203\302\303!\304W\203\305\202\306D\207\211\203\"\307!\202%\310!C\207" [current-prefix-arg last-tag nil prefix-numeric-value 0 - t read-string find-tag-tag] 5 (#$ . 24180)])
(defvar find-tag-history nil)
#@949 Find tag (in current tags table) whose name contains TAGNAME.
Returns the buffer containing the tag's definition and moves its point there,
but does not select the buffer.
The default for TAGNAME is the expression in the buffer near point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

A marker representing the point when this command is invoked is pushed
onto a ring and may be popped back to with \[pop-tag-mark].
Contrast this with the ring of marks gone to by the command.

See documentation of variable `tags-file-name'.

(fn TAGNAME &optional NEXT-P REGEXP-P)
(defalias 'find-tag-noselect #[769 "B	
\306=\2039\307!\203\310\311!\202\251\312\313\"\314
!\206%\315\316!q\317!b\210
\320\211\223\210\321\302!\210\262
\202\251\322 \210
\203K\f\203K\323\324!\210\202P\323 \210\325 r\326\203`\f\203`\f\202a\203i
\202k\203t\202v\203\202\201\203\212\327\202\213\330?\206\223\f?&q\210\211`\320\223\210\321\302!\210\331\"\210p)\262
)\207" [find-tag-history find-tag-hook local-find-tag-hook tags-location-ring last-tag find-tag-regexp-search-function - ring-empty-p user-error "No previous tag locations" ring-remove 0 marker-buffer error "The marked buffer has been deleted" marker-position nil run-hooks xref-push-marker-stack visit-tags-table-buffer same make-marker find-tag-in-order "matching" "containing" ring-insert find-tag-search-function find-tag-regexp-tag-order find-tag-tag-order find-tag-regexp-next-line-after-failure-p find-tag-next-line-after-failure-p] 11 (#$ . 24626) (find-tag-interactive "Find tag: ")])
#@924 Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition, and move point there.
The default for TAGNAME is the expression in the buffer around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is the atom `-' (interactively, with prefix arg that is a negative number
or just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

A marker representing the point when this command is invoked is pushed
onto a ring and may be popped back to with \[pop-tag-mark].
Contrast this with the ring of marks gone to by the command.

See documentation of variable `tags-file-name'.

(fn TAGNAME &optional NEXT-P REGEXP-P)
(defalias 'find-tag #[769 "\300#r\211q\210`)\3011\302!0\202\210\303!\210\211b\207" [find-tag-noselect (error) switch-to-buffer pop-to-buffer] 7 (#$ . 26587) (find-tag-interactive "Find tag: ")])
(make-obsolete 'find-tag 'xref-find-definitions "25.1")
#@939 Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another window, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

A marker representing the point when this command is invoked is pushed
onto a ring and may be popped back to with \[pop-tag-mark].
Contrast this with the ring of marks gone to by the command.

See documentation of variable `tags-file-name'.

(fn TAGNAME &optional NEXT-P REGEXP-P)
(defalias 'find-tag-other-window #[769 "\300 \301#\211q\210`\302\303 \304!\210\302\303 \"\210\"\207" [window-point find-tag-noselect set-window-point selected-window switch-to-buffer-other-window] 11 (#$ . 27777) (find-tag-interactive "Find tag other window: ")])
(make-obsolete 'find-tag-other-window 'xref-find-definitions-other-window "25.1")
#@929 Find tag (in current tags table) whose name contains TAGNAME.
Select the buffer containing the tag's definition in another frame, and
move point there.  The default for TAGNAME is the expression in the buffer
around or before point.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

If third arg REGEXP-P is non-nil, treat TAGNAME as a regexp.

A marker representing the point when this command is invoked is pushed
onto a ring and may be popped back to with \[pop-tag-mark].
Contrast this with the ring of marks gone to by the command.

See documentation of variable `tags-file-name'.

(fn TAGNAME &optional NEXT-P)
(defalias 'find-tag-other-frame #[513 "\301\302\")\207" [pop-up-frames t find-tag-other-window] 5 (#$ . 29074) (find-tag-interactive "Find tag other frame: ")])
(make-obsolete 'find-tag-other-frame 'xref-find-definitions-other-frame "25.1")
#@854 Find tag (in current tags table) whose name matches REGEXP.
Select the buffer containing the tag's definition and move point there.

If second arg NEXT-P is t (interactively, with prefix arg), search for
another tag that matches the last tagname or regexp used.  When there are
multiple matches for a tag, more exact matches are found first.  If NEXT-P
is negative (interactively, with prefix arg that is a negative number or
just \[negative-argument]), pop back to the previous tag gone to.

If third arg OTHER-WINDOW is non-nil, select the buffer in another window.

A marker representing the point when this command is invoked is pushed
onto a ring and may be popped back to with \[pop-tag-mark].
Contrast this with the ring of marks gone to by the command.

See documentation of variable `tags-file-name'.

(fn REGEXP &optional NEXT-P OTHER-WINDOW)
(defalias 'find-tag-regexp #[769 "\211\203\300\202	\301\302#\207" [find-tag-other-window find-tag t] 7 (#$ . 30253) (find-tag-interactive "Find tag regexp: " t)])
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [make-obsolete find-tag-regexp xref-find-apropos "25.1" defalias pop-tag-mark xref-pop-marker-stack] 4)
#@35 Matches remembered between calls.
(defvar tag-lines-already-matched nil (#$ . 31437))
#@477 Internal tag-finding function.
PATTERN is a string to pass to arg SEARCH-FORWARD-FUNC, and to any
member of the function list ORDER.  If ORDER is nil, use saved state
to continue a previous search.

Arg NEXT-LINE-AFTER-FAILURE-P is non-nil if after a failed match,
point should be moved to the next line.

Arg MATCHING is a string, an English `-ing' word, to be used in an
error message.

(fn PATTERN SEARCH-FORWARD-FUNC ORDER NEXT-LINE-AFTER-FAILURE-P MATCHING FIRST-SEARCH)
(defalias 'find-tag-in-order #[1542 "\305\211\306\307 \305\310>\203\202	p
\212\203!\305\202%\311\312!\210\3132\256\2044\311\306\"\203\206\203@\203@eb\210\305\262\203\200\f\305\306#\203u@!\203j\314 \305\223\n\235\204j\315\313\305\"\210\n\203H\316y\210\202HA\262\feb\210\202C\262\f\202)\n\203\227\n@\305\211\223\210\nA\211\204\212\305\211\223\210\317\320\n\203\247\321\202\250\322\f$0\210\323 \210\nB\324\f@\325>\203\311\212\316y\210\326 )\202\313\326 !\262 \262\f\262\327!\210~\210\330 \210!\210p*\207" [tags-case-fold-search case-fold-search tag-lines-already-matched snarf-tag-function goto-tag-location-function nil t make-marker (nil t) visit-tags-table-buffer same qualified-match-found point-at-bol throw 1 user-error "No %stags %s %s" "" "more " beginning-of-line expand-file-name (tag-exact-file-name-match-p tag-file-name-match-p tag-partial-file-name-match-p) file-of-tag tag-find-file-of-tag-noselect push-mark] 20 (#$ . 31530)])
#@55 Find the right line in the specified FILE.

(fn FILE)
(defalias 'tag-find-file-of-tag-noselect #[257 "\203	\202	\302\303

\204\"\203\"\304@P!\262A\262\202
\2032\305!\2042\306\307!!\210
\204U\211\203U\310@P!\204J\211A\262
\2022\306@P!\262\2022
\204l\203e\311\312	#\202n\311\313\"\202n
q\207" [auto-compression-mode tags-compression-info-list ("") nil find-buffer-visiting verify-visited-file-modtime find-file-noselect buffer-file-name file-exists-p error "File %s (with or without extensions %s) not found" "File %s not found"] 8 (#$ . 33023)])
#@13 

(fn FILE)
(defalias 'tag-find-file-of-tag #[257 "\300
!\3011\302
!0\202\210\303
!\207" [tag-find-file-of-tag-noselect (error) switch-to-buffer pop-to-buffer] 4 (#$ . 33609)])
#@178 If `etags-verify-tags-table', make buffer-local format variables.
If current buffer is a valid etags TAGS file, then give it
buffer-local values of tags table format variables.
(defalias 'etags-recognize-tags-table #[0 "\300 \205	\301\302\303\"\207" [etags-verify-tags-table mapc #[257 "\300
@!
AL\207" [make-local-variable] 3 "\n\n(fn ELT)"] ((file-of-tag-function . etags-file-of-tag) (tags-table-files-function . etags-tags-table-files) (tags-completion-table-function . etags-tags-completion-table) (snarf-tag-function . etags-snarf-tag) (goto-tag-location-function . etags-goto-tag-location) (find-tag-regexp-search-function . re-search-forward) (find-tag-regexp-tag-order tag-re-match-p) (find-tag-regexp-next-line-after-failure-p . t) (find-tag-search-function . search-forward) (find-tag-tag-order tag-exact-file-name-match-p tag-file-name-match-p tag-exact-match-p tag-implicit-name-match-p tag-symbol-match-p tag-word-match-p tag-partial-file-name-match-p tag-any-match-p) (find-tag-next-line-after-failure-p) (list-tags-function . etags-list-tags) (tags-apropos-function . etags-tags-apropos) (tags-included-tables-function . etags-tags-included-tables) (verify-tags-table-function . etags-verify-tags-table))] 3 (#$ . 33797)])
#@66 Return non-nil if the current buffer is a valid etags TAGS file.
(defalias 'etags-verify-tags-table #[0 "ef\300=\207" [12] 2 (#$ . 35043)])
#@27 

(fn &optional RELATIVE)
(defalias 'etags-file-of-tag #[256 "\212\301\302!\210\303\304\224\304\225{!
\203\211\202\305
\306!\"\262
)\207" [default-directory re-search-backward "\f\n\\([^\n]+\\),[0-9]*\n" convert-standard-filename 1 expand-file-name file-truename] 6 (#$ . 35189)])
(defalias 'etags-tags-completion-table #[0 "\301\302\303\304\"ed#\212eb\210\305\306\301\307#\203O\310\224\203\"\310\224\310\225{\2022\311\224b\210\312\301x\210`\311\224{\311\225b\210
`\301
\247\203A
@Y\205F\313#\266B\262\202
)
\207" [buffer-file-name nil make-progress-reporter format "Making tags completion table for %s..." re-search-forward "[\f	\n
()=,; ]?\\(?:\\([^\n
]+\\)
\\)?" t 1 0 "^\f	\n
()=,; " progress-reporter-do-update] 10])
#@31 

(fn &optional USE-EXPLICIT)
(defalias 'etags-snarf-tag #[256 "\300\211\211\211\212\301y\210\302\303!)\203\304\262\300\262e\262\202c\305\306!\210`S\307 {\262`\262
\305\310\307\311!\304#\203=\203=\211`S{\262\302\312!\203N\313`\314\300w\210`{!\262\305\315!\210\302\312!\203c\313`\314\300w\210`{!\262\316y\210BB\207" [nil -1 looking-at "\f\n" t search-forward "" point-at-bol "
" 2 "[0-9]" string-to-number "0-9" "," 1] 9 (#$ . 35937)])
#@605 Go to location of tag specified by TAG-INFO.
TAG-INFO is a cons (TEXT LINE . POSITION).
TEXT is the initial part of a line containing the tag.
LINE is the line number.
POSITION is the (one-based) char position of TEXT within the file.

If TEXT is t, it means the tag refers to exactly LINE or POSITION,
whichever is present, LINE having preference, no searching.
Either LINE or POSITION can be nil.  POSITION is used if present.

If the tag isn't exactly at the given position, then look near that
position using a search window that expands progressively until it
hits the start of file.

(fn TAG-INFO)
(defalias 'etags-goto-tag-location #[257 "\211AA
A@\303\211\211@\304=\203/\203eb\210Sy\210\202\264\203(b\210\202\264\305\306!\210\202\264\307\262\303\262\304=\203?\310\202@\311\312@!P\262
\203bT\262\203b\313	!\314=\203bSZ\262\204t\203teb\210Sy\210`\262\204{e\262b\210\315
!\262
\204\242Zb\210o\204\242\316
\\\304#\262\317_\262\202\203
\204\264\316
\303\304#\204\264\320\321\n#\210\304=\203\303\315\322!\203\303\314u\210\323 \207" [selective-display buffer-file-coding-system buffer-file-name nil t error "etags.el BUG: bogus direct file tag" 1000 "\\(^\\|
\\)" "^" regexp-quote coding-system-eol-type 1 looking-at re-search-forward 3 user-error "Rerun etags: `%s' not found in %s" "
" beginning-of-line] 10 (#$ . 36398)])
#@13 

(fn FILE)
(defalias 'etags-list-tags #[257 "eb\210\304\305\306Q\307\310#\205p\212\311y\210\312 )\307\211\211\311y\210m\204m\313\314!\204m\212	\307!)\262
@\262r\nq\210`)\262
\315!\210\316H\317U\203I\315\320!\210r\nq\210\321
`\322\323\n\324\325\326\327\310\330\331\332&\210)\333 \210\311y\210\202\310\266\205\207" [goto-tag-location-function snarf-tag-function standard-output tags-tag-face re-search-forward "\f\n\\(" "\\)," nil t 1 file-of-tag looking-at "\f" princ 0 40 " ...)" make-text-button tag-info file-path goto-func action #[257 "\300
\301\"\300\302\"\303\300\304\"!\210~\210\211!\207" [button-get tag-info goto-func tag-find-file-of-tag file-path] 7 "\n\n(fn BUTTON)"] follow-link face type button terpri] 23 (#$ . 37787)])
#@81 Execute BODY, give output to `standard-output' face FACE.

(fn FACE &rest BODY)
(defalias 'tags-with-face '(macro . #[385 "\300\301!\302
\303BC\304\305\306\307\n\310BBBBBC\"BB\207" [make-symbol "start" let ((with-current-buffer standard-output (point))) append put-text-property (with-current-buffer standard-output (point)) 'face (standard-output)] 13 (#$ . 38550)]))
#@83 Display tags matching REGEXP from `tags-apropos-additional-actions'.

(fn REGEXP)
(defalias 'etags-tags-apropos-additional #[257 "rq\210	\211\205\213\211@\302\303!\210rq\210`)\302@!\210\304
rq\210`)\305\306%\266\302\307!\210`
AA@\310\311\312\313\314	\"\315\"\316\317%
9\203[\320!\203R
J\262\202[\321\322\"c\210\323\262\324!\203i\325
\"\210\202}
\211\203|\211@
@!\210
A\266\202\202j\210\326\323`#\266
A\266\202\202\262
)\207" [standard-output tags-apropos-additional-actions princ "\n\n" put-text-property face highlight ":\n\n" make-byte-code 257 "\303
!\304\300\"\205%\305`\306!\210`\307\301A@\310\311\312\313\n\314\315\316\317&\210\320 \207" vconcat vector [tags-tag-face symbol-name string-match make-text-button princ action-internal action #[257 "\300
\301\"\300\302\"!\207" [button-get action-internal item] 5 "\n\n(fn BUTTON)"] item face follow-link t type button terpri] 17 "\n\n(fn SY)" boundp format-message "symbol `%s' has no value\n" nil vectorp mapatoms sort-lines] 12 (#$ . 38928)])
#@15 

(fn STRING)
(defalias 'etags-tags-apropos #[257 "\203(\306\307\310!!\210r	q\210`)\306\n!\210\311
r	q\210`)\312\313	%\266\306\307\314!!\210eb\210\315\316\317\"ed#\320\321\322#\203\357\211`\321
\247\203J
@Y\205O\323#\266\324 \210\212\f )\211@\322=?\205c\211@\212\211\203m\325 \202t\212\326y\210\325 ))
\203\325\322!\202\207\212\326y\210\325\322!)r	q\210`)\203\307\306\327\330\"!\210\306!\210\331H\332U\203\250\306\333!\210r	q\210\334
`\335\336\337
\340\341\342\322\312
\343\344&\210)\202\344\306\327\345\"!\210r	q\210\334
`\336\340\346\342\322\312
\343\344&\f\210)\266\347 \210\326y\210\2023\350\321!\266\205\373\306\351!\207" [tags-apropos-verbose standard-output buffer-file-name goto-tag-location-function snarf-tag-function tags-tag-face princ substitute-command-keys "Tags in file `" put-text-property face highlight "':\n\n" make-progress-reporter format-message "Making tags apropos buffer for `%s'..." re-search-forward nil t progress-reporter-do-update beginning-of-line file-of-tag 1 format "[%s]: " 0 40 " ...)" make-text-button tag-info file-path goto-func action #[257 "\300
\301\"\300\302\"\303\300\304\"!\210~\210\211!\207" [button-get tag-info goto-func tag-find-file-of-tag file-path] 7 "\n\n(fn BUTTON)"] follow-link type button "- %s" #[257 "\300\301\302\"!\210eb\207" [tag-find-file-of-tag button-get file-path] 5 "\n\n(fn BUTTON)"] terpri message "\n"] 25 (#$ . 39967)])
(defalias 'etags-tags-table-files #[0 "\300\211eb\210\301\302\300\303#\203*`\262
\300\210\304
x\210\305\306!\204\307
`S{!B\262\202
\237\207" [nil search-forward "\f\n" t "^," looking-at "include$" convert-standard-filename] 6])
(defalias 'etags-tags-included-tables #[0 "\300\211eb\210\301\302\300\303#\203,`\262
\300\210\304
x\210\305\306!\203\307\310`S{!!B\262\202
\237\207" [nil search-forward "\f\n" t "^," looking-at "include$" expand-file-name convert-standard-filename] 6])
#@131 Return non-nil if current buffer is empty.
If empty, make buffer-local values of the tags table format variables
that do nothing.
(defalias 'tags-recognize-empty-tags-table #[0 "\301 \302U\205\303\304\305\"\205\306\300!\210\307\211\207" [verify-tags-table-function buffer-size 0 mapc #[257 "\300
!\301L\207" [make-local-variable ignore] 3 "\n\n(fn SYM)"] (tags-table-files-function tags-completion-table-function find-tag-regexp-search-function find-tag-search-function tags-apropos-function tags-included-tables-function) make-local-variable #[0 "\300 \301U\207" [buffer-size 0] 2]] 3 (#$ . 41909)])
#@114 Return non-nil if TAG matches complete file name.
Any directory part of the file name is also matched.

(fn TAG)
(defalias 'tag-exact-file-name-match-p #[257 "\300\301!\205\212\302
G\\\206\303[u\210\300\304!)\207" [looking-at ",[0-9\n]" 2 1 "\f\n"] 3 (#$ . 42522)])
#@78 Return non-nil if TAG matches file name, excluding directory part.

(fn TAG)
(defalias 'tag-file-name-match-p #[257 "\300\301!\205\212\211GT\206\302[u\210\300\303!)\207" [looking-at ",[0-9\n]" 1 "/"] 3 (#$ . 42798)])
#@121 Return non-nil if current tag line matches TAG exactly.
Point should be just after a string that matches TAG.

(fn TAG)
(defalias 'tag-exact-match-p #[257 "`f\300=\203\301`G\300#f\302=\206\303\304\305!\306Q!\207" [1 - 127 looking-at "[^\n]*" regexp-quote "
"] 5 (#$ . 43026)])
#@122 Return non-nil if current tag line has an implicit name.
Point should be just after a string that matches TAG.

(fn TAG)
(defalias 'tag-implicit-name-match-p #[257 "\300\301\"\205\302\303!\205\212\211GT\206\304[u\210\302\305!)\207" [string-match "^[^ 	()=,;]+$" looking-at "[ 	()=,;]?[0-9]*,[0-9]*$" 1 "[\n 	()=,;]"] 4 (#$ . 43318)])
#@125 Return non-nil if current tag line matches TAG as a symbol.
Point should be just after a string that matches TAG.

(fn TAG)
(defalias 'tag-symbol-match-p #[257 "\300\301!\205!\300\302!\205!\212\211GT\206\303[u\210\300\304!\205 \300\305!)\207" [looking-at "\\Sw.*" "\\S_.*" 1 "\\Sw" "\\S_"] 3 (#$ . 43667)])
#@123 Return non-nil if current tag line matches TAG as a word.
Point should be just after a string that matches TAG.

(fn TAG)
(defalias 'tag-word-match-p #[257 "\300\301!\205\212\211G\206
\302[u\210\300\303!)\207" [looking-at "\\b.*" 1 "\\b"] 3 (#$ . 43988)])
#@182 Return non-nil if current tag matches file name.
This is a substring match, and it can include directory separators.
Point should be just after a string that matches TAG.

(fn TAG)
(defalias 'tag-partial-file-name-match-p #[257 "\300\301!\205\212\302 \210\303u\210\300\304!)\207" [looking-at ".*,[0-9\n]" beginning-of-line -2 "\f\n"] 3 (#$ . 44255)])
#@75 Return non-nil if current tag line contains TAG as a substring.

(fn TAG)
(defalias 'tag-any-match-p #[257 "\300\301!\207" [looking-at ".*"] 3 (#$ . 44614)])
#@64 Return non-nil if current tag line matches regexp RE.

(fn RE)
(defalias 'tag-re-match-p #[257 "\212\300 \210`\301\302\303 \304#\205\305\304#\262
)\207" [beginning-of-line search-forward "" line-end-position t re-search-backward] 6 (#$ . 44779)])
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301
N\203!\302
N\204!\305\302\301N#\210
A\266\202\202\210\306\301\302\307#\210\310\311\312\"\210\313\311\314\307#\207" [defvaralias tags-loop-revert-buffers fileloop-revert-buffers nil (saved-value saved-variable-comment) put make-obsolete-variable "27.1" defalias next-file tags-next-file make-obsolete "use tags-next-file or fileloop-initialize and fileloop-next-file instead"] 7)
#@510 Select next file among files in current tags table.

A first argument of t (prefix arg, if interactive) initializes to the
beginning of the list of files in the tags table.  If the argument is
neither nil nor t, it is evalled to initialize the list of files.

Non-nil second argument NOVISIT means use a temporary buffer
 to save time and avoid uninteresting warnings.

Value is nil if the file was already visited;
if the file was newly read in, the value is the filename.

(fn &optional INITIALIZE NOVISIT)
(defalias 'tags-next-file #[512 "
\203\300!\210\301
!\210\302p!\207" [tags--compat-initialize fileloop-next-file switch-to-buffer] 4 (#$ . 45480) (byte-code "\205\301C\207" [current-prefix-arg t] 1)])
(defalias 'tags--all-files #[0 "\212p\300\301 \210\302\303\304 \"\262
\301\305\"\203=\211\211A\203!\211A\262
\202\211\2032\211\211\302\303\304 \"\241\266\2029\302\303\304 \"\262\210\202
\262
)\207" [nil visit-tags-table-buffer mapcar expand-file-name tags-table-files t] 8])
(make-obsolete-variable 'tags-loop-operate 'fileloop-initialize "27.1")
#@59 Form for `tags-loop-continue' to eval to change one file.
(defvar tags-loop-operate nil (#$ . 46559))
(make-obsolete-variable 'tags-loop-scan 'fileloop-initialize "27.1")
#@178 Form for `tags-loop-continue' to eval to scan one file.
If it returns non-nil, this file needs processing by evalling
`tags-loop-operate'.  Otherwise, move on to the next file.
(defvar tags-loop-scan '(user-error "%s" (substitute-command-keys "No \\[tags-search] or \\[tags-query-replace] in progress")) (#$ . 46737))
#@147 Evaluate FORM and return its result.
Bind `case-fold-search' during the evaluation, depending on the value of
`tags-case-fold-search'.

(fn FORM)
(defalias 'tags-loop-eval #[257 "\302>\203\n\202	\303
!)\207" [tags-case-fold-search case-fold-search (t nil) eval] 3 (#$ . 47062)])
#@14 

(fn FILES)
(defalias 'tags--compat-files #[257 "\211\300=\203	\301 \207\302
!\203\207\211\242;\203\207\303
!\207" [t tags--all-files functionp eval] 3 (#$ . 47353)])
#@19 

(fn INITIALIZE)
(defalias 'tags--compat-initialize #[257 "\301\302!\203\f\303\202
\304\305#\207" [tags-loop-operate fileloop-initialize tags--compat-files #[0 "\301!\207" [tags-loop-operate tags-loop-eval] 2] #[0 "\301\302\"\210\303\207" [buffer-file-name message "Scanning file %s...found" nil] 3] #[0 "\301!\207" [tags-loop-scan tags-loop-eval] 2]] 5 (#$ . 47532)])
#@211 Continue last \[tags-search] or \[tags-query-replace] command.
Used noninteractively with non-nil argument to begin such a command (the
argument is passed to `next-file', which see).

(fn &optional FIRST-TIME)
(defalias 'tags-loop-continue #[256 "\211\203\300
!\210\301 \207" [tags--compat-initialize fileloop-continue] 3 (#$ . 47916) nil])
(make-obsolete 'tags-loop-continue 'fileloop-continue "27.1")
(defvar tags--last-search-operate-function nil)
#@392 Search through all files listed in tags table for match for REGEXP.
Stops when a match is found.
To continue searching for next match, use command \[tags-loop-continue].

If FILES if non-nil should be a list or an iterator returning the files to search.
The search will be restricted to these files.

Also see the documentation of the `tags-file-name' variable.

(fn REGEXP &optional FILES)
(defalias 'tags-search #[513 "
\303\232\203\f	=\204\304\305\206\306!\n#\210\307 \207" [fileloop--operate-function tags--last-search-operate-function tags-case-fold-search "" fileloop-initialize-search tags--compat-files t fileloop-continue] 6 (#$ . 48376) "sTags search (regexp): "])
#@379 Do `query-replace-regexp' of FROM with TO on all files listed in tags table.
Third arg DELIMITED (prefix arg) means replace only word-delimited matches.
If you exit (\[keyboard-quit], RET or q), you can resume the query replace
with the command \[tags-loop-continue].
For non-interactive use, superceded by `fileloop-initialize-replace'.

(fn FROM TO &optional DELIMITED FILES)
(defalias 'tags-query-replace #[1026 "\300\301\206	\302!\211\227\232?\205\303%\210\304 \207" [fileloop-initialize-replace tags--compat-files t default fileloop-continue] 10 (#$ . 49068) (byte-code "\300\301\302\211#\207" [query-replace-read-args "Tags query replace (regexp)" t] 4)])
(set-advertised-calling-convention 'tags-query-replace '(from to &optional delimited) "27.1")
#@555 Complete STRING from file names in the current tags table.
PREDICATE, if non-nil, is a function to filter possible matches:
if it returns nil, the match is ignored.  If PREDICATE is nil,
every possible match is acceptable.
WHAT is a flag specifying the type of completion: t means `all-completions'
operation, any other value means `try-completions' operation.

This function serves as COLLECTION argument to `completing-read',
see the Info node `(elisp) Programmed Completion' for more detailed
description of the arguments.

(fn STRING PREDICATE WHAT)
(defalias 'tags-complete-tags-table-file #[771 "\212\301\302 \210)\211\301=\203\303\304 #\202\305\304 #)\207" [enable-recursive-minibuffers t visit-tags-table-buffer all-completions tags-table-files try-completion] 7 (#$ . 49841)])
#@73 Get the file name that the current buffer corresponds in the tags file.
(defalias 'tags--get-current-buffer-name-in-tags-file #[0 "\212\300 \210\301\302 !)\303\302 \"\207" [visit-tags-table-buffer file-name-directory buffer-file-name file-relative-name] 4 (#$ . 50642)])
#@318 Display list of tags in file FILE.
This searches only the first table in the list, and no included
tables.  FILE should be as it appeared in the `etags' command,
usually without a directory specification.  If called
interactively, FILE defaults to the file name of the current
buffer.

(fn FILE &optional NEXT-MATCH)
(defalias 'list-tags #[513 "r\306\307!q\210p\310 \210
\311\211\312\211\312\313 \210\314\315!\210+\211\316\317\320!!\210rq\210`)\316!\210\321
rq\210`)\322\323%\266\316\317\324!!\210\212\312\311p\325?\"\203f\311\262!\203M\312\262\202M
\204p\326\327\"\210\266)\330
!\210)\266r\307q\210\331\332!\210\333 \210\312\211)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only get-buffer-create "*Tags List*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ substitute-command-keys "Tags in file `" put-text-property face highlight "':\n\n" visit-tags-table-buffer user-error "File %s not in current tags tables" internal-temp-output-buffer-show require apropos apropos-mode standard-output list-tags-function] 12 (#$ . 50921) (byte-code "\300\301\302\303\304\305 %C\207" [completing-read "List tags in file: " tags-complete-tags-table-file nil t tags--get-current-buffer-name-in-tags-file] 6)])
#@69 Display list of all tags in tags table REGEXP matches.

(fn REGEXP)
(defalias 'tags-apropos #[257 "r\306\307!q\210p\310 \210
\311\211\312\211\312\313 \210\314\315!\210+\211\316\317\320!!\210rq\210`)\316!\210\321
rq\210`)\322\323%\266\316\317\324!!\210\212\312p\325?\"\203_\311\262!\210\202L\266)\326!\210\327
!\210)\266r\307q\210\330\331!\210\332 \210\312\211)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only get-buffer-create "*Tags List*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ substitute-command-keys "Click mouse-2 to follow tags.\n\nTags matching regexp `" put-text-property face highlight "':\n\n" visit-tags-table-buffer etags-tags-apropos-additional internal-temp-output-buffer-show require apropos apropos-mode standard-output tags-apropos-function] 11 (#$ . 52265) "sTags apropos (regexp): "])
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311\312\313&\207" [make-obsolete tags-apropos xref-find-apropos "25.1" define-button-type tags-select-tags-table action select-tags-table-select follow-link t help-echo "RET, t or mouse-2: select tags table"] 8)
#@212 Select a tags table file from a menu of those you have already used.
The list of tags tables to select from is stored in `tags-table-set-list';
see the doc of that variable if you want to add names to the list.
(defalias 'select-tags-table #[0 "\305\306!\210\307\310\311 \210\n\307\211\203/\312 \262`\262
\313\314\315\"p\"\210\316
`\317\320\321@&\210\322c\210\203]@=\204V`\262
\313\314\315@\"p\"\210\316
`\317\320\321@@&\210\322c\210A\262\202/\f\203~
\204i\312 \262`\262
\315\f!c\210\316
`\317\320\321\f&\210\322c\210\323\f\324\325\326!\314\326\n\"B\"\"\262\203\264`\262
\315@!c\210\316
`\317\320\321@&\210\322c\210\323@\"\262\202\216eb\210\327\330!\210
\203\302
b\210\331\332 \333\310#\266\334\307!\210\335 \207" [buffer-read-only buffer-undo-list tags-table-set-list tags-table-list tags-file-name pop-to-buffer "*Tags Table List*" nil t erase-buffer point-marker princ mapcar abbreviate-file-name make-text-button type tags-select-tags-table etags-table "\n" delete apply nconc copy-sequence insert-before-markers "Type `t' to select a tags table or set of tags tables:\n\n" set-window-start selected-window 1 set-buffer-modified-p select-tags-table-mode] 11 (#$ . 53488) nil])
(defvar select-tags-table-mode-map (byte-code "\301 \302
\"\210\303
\304\305#\210\303
\306\307#\210\303
\310\311#\210\303
\312\307#\210\303
\313\311#\210\303
\314\315#\210\211\207" [button-buffer-map make-sparse-keymap set-keymap-parent define-key "t" push-button " " next-line "" previous-line "n" "p" "q" select-tags-table-quit] 5))
(defvar select-tags-table-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [select-tags-table-mode-hook variable-documentation put "Hook run after entering Select Tags Table mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp select-tags-table-mode-map definition-name select-tags-table-mode] 4)
(defvar select-tags-table-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [select-tags-table-mode-abbrev-table select-tags-table-mode-map variable-documentation put purecopy "Keymap for `select-tags-table-mode'." boundp select-tags-table-mode-syntax-table definition-name select-tags-table-mode (lambda (#1=#:def-tmp-var) (defvar select-tags-table-mode-syntax-table #1#)) make-syntax-table "Syntax table for `select-tags-table-mode'." (lambda (#1#) (defvar select-tags-table-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `select-tags-table-mode'." derived-mode-parent special-mode] 5)
#@289 Major mode for choosing a current tags table among those already loaded.

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `select-tags-table-mode-hook', as the final or penultimate step
during initialization.

\{select-tags-table-mode-map}
(defalias 'select-tags-table-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
)\331\332!\207" [delay-mode-hooks major-mode mode-name select-tags-table-mode-map select-tags-table-mode-syntax-table select-tags-table-mode-abbrev-table make-local-variable t special-mode select-tags-table-mode "Select Tags Table" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks select-tags-table-mode-hook local-abbrev-table] 5 (#$ . 56357) nil])
#@56 Select the tags table named on this line.

(fn BUTTON)
(defalias 'select-tags-table-select #[257 "\300
\301\"\302
!\210\303 \210\304\305\"\207" [button-get etags-table visit-tags-table select-tags-table-quit message "Tags table now %s"] 5 (#$ . 57448) (byte-code "\300\301 !\206\n\302\303!C\207" [button-at line-beginning-position error "No tags table on current line"] 2)])
#@49 Kill the buffer and delete the selected window.
(defalias 'select-tags-table-quit #[0 "\300\301\302 \"\207" [quit-window t selected-window] 3 (#$ . 57831) nil])
#@208 Perform tags completion on the text around point.
Completes to the set of names listed in the current tags table.
The string to complete is chosen in the same way as the default
for \[find-tag] (which see).
(defalias 'complete-tag #[0 "\204	\204\302\303\304\305!\"\210\306 \211\204\302\307!\202,\310
@A@\3118\312\313\233\314\"$\207" [tags-table-list tags-file-name user-error "%s" substitute-command-keys "No tags table loaded; try \\[visit-tags-table]" tags-completion-at-point-function "Nothing to complete" completion-in-region 2 plist-get 3 :predicate] 8 (#$ . 57999) nil])
(defconst etags--xref-limit 1000)
#@208 Tag order used in `xref-backend-definitions' to look for definitions.

If you want `xref-find-definitions' to find the tagged files by their
file name, add `tag-partial-file-name-match-p' to the list value.
(defvar etags-xref-find-definitions-tag-order '(tag-exact-match-p tag-implicit-name-match-p) (#$ . 58630))
(defalias 'etags--xref-backend #[0 "\300\207" [etags] 1])
(byte-code "\300\301\302\303\302\304%\210\300\305\302\306\302\307%\210\300\310\302\311\302\312%\210\300\313\302\314\302\315%\210\300\316\302\317\302\320%\207" [cl-generic-define-method xref-backend-identifier-at-point nil ((_backend (eql etags))) #[257 "\300 \207" [find-tag--default] 2 "\n\n(fn BACKEND)"] xref-backend-identifier-completion-table ((_backend (eql etags))) #[257 "\300 \207" [tags-lazy-completion-table] 2 "\n\n(fn BACKEND)"] xref-backend-identifier-completion-ignore-case ((_backend (eql etags))) #[257 "\300 \207" [find-tag--completion-ignore-case] 2 "\n\n(fn BACKEND)"] xref-backend-definitions ((_backend (eql etags)) symbol) #[514 "\300
!\207" [etags--xref-find-definitions] 4 "\n\n(fn BACKEND SYMBOL)"] xref-backend-apropos ((_backend (eql etags)) symbol) #[514 "\300
\301\"\207" [etags--xref-find-definitions t] 5 "\n\n(fn BACKEND SYMBOL)"]] 6)
#@37 

(fn PATTERN &optional REGEXP\=\?)
(defalias 'etags--xref-find-definitions #[513 "\304\305\203\n\306\202\307\310\311\312\"\313 p\212\314?\"\203\227\304\262\203'	\202(\n\211\203\223\211@eb\210	\304\305#\203\214\315!W\203\214\211	!\2031\316 \210\317 \211@
A\211@
A
\320 \211B\321
\"\204\207\322	\323!\"\324\305=\203w\325\202x\"B\262\326\305#\266\266	\2021
A\266\202\202(\210\202)\237)\207" [case-fold-search find-tag-regexp-tag-order etags-xref-find-definitions-tag-order etags--xref-limit nil t re-search-forward search-forward make-hash-table :test equal find-tag--completion-ignore-case visit-tags-table-buffer hash-table-count beginning-of-line etags-snarf-tag file-of-tag gethash xref-make-etags-location expand-file-name xref-make "(filename match)" puthash] 23 (#$ . 59876)])
(byte-code "\300\301\302\303!\"\210\300\304\305\303!\"\210\300\306\304\"\210\307\306\310\311#\210\312\303\313\304#\314\303\315\316\317$\210\320\321\322\323\322\324%\207" [defalias xref-etags-location-p eieio-make-class-predicate xref-etags-location xref-etags-location--eieio-childp eieio-make-child-predicate xref-etags-location-child-p make-obsolete "use (cl-typep ... \\='xref-etags-location) instead" "25.1" define-symbol-prop cl-deftype-satisfies eieio-defclass-internal (xref-location) ((tag-info :type list :initarg :tag-info) (file :type string :initarg :file :reader xref-location-group)) (:documentation "Location of an etags tag.") cl-generic-define-method xref-location-group nil ((this xref-etags-location)) #[257 "\300
\301\"\207" [slot-value file] 4 "Access the slot `file' from object of class `xref-etags-location'.\n\n(fn THIS)"]] 7)
#@76 Create a new object of class type `xref-etags-location'.

(fn &rest SLOTS)
(defalias 'xref-etags-location #[128 "\300\301\302#\207" [apply make-instance xref-etags-location] 5 (#$ . 61561)])
(byte-code "\300\301\302\303#\300\207" [function-put xref-etags-location compiler-macro xref-etags-location--anon-cmacro] 4)
#@26 

(fn WHOLE &rest SLOTS)
(defalias 'xref-etags-location--anon-cmacro #[385 "\211@;\204
\207\300\301\302@@#@\303@DABB\"\207" [macroexp--warn-and-return format "Obsolete name arg %S to constructor %S" identity] 7 (#$ . 61884)])
#@22 

(fn TAG-INFO FILE)
(defalias 'xref-make-etags-location #[514 "\300\301\302\303\304!%\207" [make-instance xref-etags-location :tag-info :file expand-file-name] 9 (#$ . 62123)])
(byte-code "\300\301\302\303\302\304%\210\300\305\302\306\302\307%\210\310\311!\207" [cl-generic-define-method xref-location-marker nil ((l xref-etags-location)) #[257 "\211\300\301\302\"!r\211q\210\212\303\301\304\"!\210\305 *\262
\207" [find-file-noselect slot-value file etags-goto-tag-location tag-info point-marker] 7 "\n\n(fn L)"] xref-location-line ((l xref-etags-location)) #[257 "\211\300
\301\"A@\207" [slot-value tag-info] 5 "\n\n(fn L)"] provide etags] 6)