;;; etags.el --- etags facility for Emacs
-;; Copyright (C) 1985, 1986, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1998,
-;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+;; Copyright (C) 1985-1986, 1988-1989, 1992-1996, 1998, 2000-2011
;; Free Software Foundation, Inc.
;; Author: Roland McGrath <roland@gnu.org>
:type '(repeat file))
;;;###autoload
-(defcustom tags-compression-info-list (purecopy '("" ".Z" ".bz2" ".gz" ".tgz"))
+(defcustom tags-compression-info-list
+ (purecopy '("" ".Z" ".bz2" ".gz" ".xz" ".tgz"))
"*List of extensions tried by etags when jka-compr is used.
An empty string means search the non-compressed file.
These extensions will be tried only if jka-compr was activated
\(i.e. via customize of `auto-compression-mode' or by calling the function
`auto-compression-mode')."
+ :version "24.1" ; added xz
:type '(repeat string)
:group 'etags)
(defun initialize-new-tags-table ()
"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
+in that case, also make the tags table state variables
buffer-local and set them to nil."
(set (make-local-variable 'tags-table-files) nil)
(set (make-local-variable 'tags-completion-table) nil)
(defun tags-table-mode ()
"Major mode for tags table file buffers."
(interactive)
- (setq major-mode 'tags-table-mode
+ (setq major-mode 'tags-table-mode ;FIXME: Use define-derived-mode.
mode-name "Tags Table"
buffer-undo-list t)
(initialize-new-tags-table))
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. Nil CORE-ONLY is ignored."
+buffers. If CORE-ONLY is nil, it is ignored."
(let ((tables tags-table-computed-list)
(found nil))
;; Loop over the list, looking for a table containing tags for THIS-FILE.
(search-backward pattern) ;FIXME: will fail if we're inside pattern.
(setq beg (point))
(forward-char (length pattern))
- (list beg (point) (tags-lazy-completion-table)))))))
+ (list beg (point) (tags-lazy-completion-table) :exclusive 'no))))))
\f
(defun find-tag-tag (string)
"Read a tag name, with defaulting and completion."
;; Dynamic bondage:
(defvar etags-case-fold-search)
(defvar etags-syntax-table)
+(defvar local-find-tag-hook)
;;;###autoload
(defun find-tag-noselect (tagname &optional next-p regexp-p)
;; Naive match found. Qualify the match.
(and (funcall (car order) pattern)
;; Make sure it is not a previous qualified match.
- (not (member (set-marker match-marker (save-excursion
- (beginning-of-line)
- (point)))
+ (not (member (set-marker match-marker (point-at-bol))
tag-lines-already-matched))
(throw 'qualified-match-found nil))
(if next-line-after-failure-p
(defun etags-file-of-tag (&optional relative) ; Doc string?
(save-excursion
(re-search-backward "\f\n\\([^\n]+\\),[0-9]*\n")
- (let ((str (buffer-substring (match-beginning 1) (match-end 1))))
+ (let ((str (convert-standard-filename
+ (buffer-substring (match-beginning 1) (match-end 1)))))
(if relative
str
- (expand-file-name str
- (file-truename default-directory))))))
+ (expand-file-name str (file-truename default-directory))))))
(defun etags-tags-completion-table () ; Doc string?
;; Find the end of the tag and record the whole tag text.
(search-forward "\177")
- (setq tag-text (buffer-substring (1- (point))
- (save-excursion (beginning-of-line)
- (point))))
+ (setq tag-text (buffer-substring (1- (point)) (point-at-bol)))
;; If use-explicit is non nil and explicit tag is present, use it as part of
;; return value. Else just skip it.
(setq explicit-start (point))
- (when (and (search-forward "\001" (save-excursion (forward-line 1) (point)) t)
+ (when (and (search-forward "\001" (point-at-bol 2) t)
use-explicit)
(setq tag-text (buffer-substring explicit-start (1- (point)))))
(end-of-line)
(skip-chars-backward "^," beg)
(or (looking-at "include$")
- (setq files (cons (buffer-substring beg (1- (point))) files))))
+ (push (convert-standard-filename
+ (buffer-substring beg (1- (point))))
+ files)))
(nreverse files)))
(defun etags-tags-included-tables () ; Doc string?
(setq beg (point))
(end-of-line)
(skip-chars-backward "^," beg)
- (if (looking-at "include$")
- ;; Expand in the default-directory of the tags table buffer.
- (setq files (cons (expand-file-name (buffer-substring beg (1- (point))))
- files))))
+ (when (looking-at "include$")
+ ;; Expand in the default-directory of the tags table buffer.
+ (push (expand-file-name (convert-standard-filename
+ (buffer-substring beg (1- (point)))))
+ files)))
(nreverse files)))
\f
;; Empty tags file support.
;; partial file name match, i.e. searched tag must match a substring
;; of the file name (potentially including a directory separator).
-(defun tag-partial-file-name-match-p (tag)
+(defun tag-partial-file-name-match-p (_tag)
"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."
(looking-at "\f\n"))))
;; t if point is in a tag line with a tag containing TAG as a substring.
-(defun tag-any-match-p (tag)
+(defun tag-any-match-p (_tag)
"Return non-nil if current tag line contains TAG as a substring."
(looking-at ".*\177"))
(save-excursion
(beginning-of-line)
(let ((bol (point)))
- (and (search-forward "\177" (save-excursion (end-of-line) (point)) t)
+ (and (search-forward "\177" (line-end-position) t)
(re-search-backward re bol t)))))
\f
(defcustom tags-loop-revert-buffers nil
(with-current-buffer buffer
(revert-buffer t t)))
(if (not (and new novisit))
- (set-buffer (find-file-noselect next novisit))
+ (find-file next novisit)
;; Like find-file, but avoids random warning messages.
- (set-buffer (get-buffer-create " *next-file*"))
+ (switch-to-buffer (get-buffer-create " *next-file*"))
(kill-all-local-variables)
(erase-buffer)
(setq new next)
Stops when a match is found.
To continue searching for next match, use command \\[tags-loop-continue].
-See documentation of variable `tags-file-name'."
+If FILE-LIST-FORM is non-nil, it should be a form that, when
+evaluated, will return a list of file names. The search will be
+restricted to these files.
+
+Aleso see the documentation of the `tags-file-name' variable."
(interactive "sTags search (regexp): ")
(if (and (equal regexp "")
(eq (car tags-loop-scan) 're-search-forward)
(try-completion string (tags-table-files) predicate))))
;;;###autoload
-(defun list-tags (file &optional next-match)
+(defun list-tags (file &optional _next-match)
"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
(define-key map "q" 'select-tags-table-quit)
map))
-(define-derived-mode select-tags-table-mode fundamental-mode "Select Tags Table"
- "Major mode for choosing a current tags table among those already loaded.
-
-\\{select-tags-table-mode-map}"
+(define-derived-mode select-tags-table-mode special-mode "Select Tags Table"
+ "Major mode for choosing a current tags table among those already loaded."
(setq buffer-read-only t))
(defun select-tags-table-select (button)
\f
(provide 'etags)
-;; arch-tag: b897c2b5-08f3-4837-b2d3-0e7d6db1b63e
;;; etags.el ends here