Fix completely broken changes of 4 Feb 95 by brat@htilbom.ernet.in,

which were obviously never tested or even examined closely before
being installed.
(find-tag-file-order): Variable removed.
(find-tag-noselect): Remove gratuitously added variable SEARCH-TAG and
bogus clobbering of find-tag-order for patterns ending in dot (serious
braindamage here).
(find-tag-in-order): Remove gratuitously added variable TAGS-TABLE-FILE.
Remove variable MATCH-TYPE and code testing it for stupid special case.
(etags-recognize-tags-table): Put tag-exact-file-name-match-p first in
find-tag-tag-order list.  Don't set bogus find-tag-file-order variable.
(etags-snarf-tag): Notice file name match and return tag info with t
in place of tag text.
(etags-goto-tag-location): If (car TAG-INFO) is t, go directly to
the specified location.
(tag-exact-file-name-match-p): Renamed from tag-filename-match-p, and fixed.
(tags-table-files): Doc fix: names are returned unexpanded.
(etags-tags-table-files): Don't expand file names.
(tags-table-including, next-file): Expand result of (tags-table-files).
(tags-complete-tags-table-file): New function, helper for interactive
spec of list-tags.
(list-tags): Revert to original code, but use that function to lazify
the completion table.
(tags-list-functions-in-file, tags-locate-file-in-tags-table):
Functions removed.

1 files changed, 136 insertions, 179 deletions

diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 2f21bacbeec..403fe0b7f9c 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -136,8 +136,6 @@ of the format-parsing tags function variables if successful.")
 (defvar goto-tag-location-function nil
   "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 find-tag-file-order nil
-  "Function which checks for complete and correct match, for file name as tag.")
 (defvar find-tag-regexp-search-function nil
   "Search function passed to `find-tag-in-order' for finding a regexp tag.")
 (defvar find-tag-regexp-tag-order nil
@@ -227,7 +225,7 @@ file the tag was in."
 	  (while tables
 	    (setq computed (cons (car tables) computed)
 		  table-buffer (get-file-buffer (car tables)))
-	    (if (and table-buffer 
+	    (if (and table-buffer
 		     ;; There is a buffer visiting the file.  Now make sure
 		     ;; it is initialized as a tag table buffer.
 		     (save-excursion
@@ -364,7 +362,8 @@ Returns non-nil iff it is a valid table."
 	  ;; Select the tags table buffer and get the file list up to date.
 	  (let ((tags-file-name (car tables)))
 	    (visit-tags-table-buffer 'same)
-	    (if (member this-file (tags-table-files))
+	    (if (member this-file (mapcar 'expand-file-name
+					  (tags-table-files)))
 		;; Found it.
 		(setq found tables))))
       (setq tables (cdr tables)))
@@ -387,7 +386,7 @@ Returns non-nil iff it is a valid table."
 		(setq elt (cdr elt))))
 	  ;; The last element we found in the computed list before FOUND
 	  ;; that appears in the user's list will be the table that
-	  ;; included the one we found.  
+	  ;; included the one we found.
 	  could-be))))
 
 ;; Subroutine of visit-tags-table-buffer.  Move tags-table-list-pointer
@@ -454,7 +453,7 @@ Returns t if it visits a tags table, or nil if there are no more in the list."
 		;; be frobnicated, and CONT will be set non-nil so we don't
 		;; do it below.
 		(and buffer-file-name
-		     (or 
+		     (or
 		      ;; First check only tables already in buffers.
 		      (tags-table-including buffer-file-name t)
 		      ;; Since that didn't find any, now do the
@@ -595,8 +594,9 @@ File name returned is relative to tags table file's directory."
 ;;;###autoload
 (defun tags-table-files ()
   "Return a list of files in the current tags table.
-Assumes the tags table is the current buffer.
-File names returned are absolute."
+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."
   (or tags-table-files
       (setq tags-table-files
 	    (funcall tags-table-files-function))))
@@ -717,8 +717,7 @@ See documentation of variable `tags-file-name'."
   (setq find-tag-history (cons tagname find-tag-history))
   ;; Save the current buffer's value of `find-tag-hook' before selecting the
   ;; tags table buffer.
-  (let ((local-find-tag-hook find-tag-hook)
-	(search-tag))
+  (let ((local-find-tag-hook find-tag-hook))
     (if (eq '- next-p)
 	;; Pop back to a previous location.
 	(if (null tags-location-stack)
@@ -744,7 +743,6 @@ See documentation of variable `tags-file-name'."
       ;; Record the location so we can pop back to it later.
       (let ((marker (make-marker)))
 	(save-excursion
-	  (setq search-tag (if next-p last-tag tagname))
 	  (set-buffer
 	   ;; find-tag-in-order does the real work.
 	   (find-tag-in-order
@@ -754,9 +752,7 @@ See documentation of variable `tags-file-name'."
 	      find-tag-search-function)
 	    (if regexp-p
 		find-tag-regexp-tag-order
-	      (if (string-match "\\b.*\\.\\w*" search-tag)
-		  find-tag-file-order
-		find-tag-tag-order))
+	      find-tag-tag-order)
 	    (if regexp-p
 		find-tag-regexp-next-line-after-failure-p
 	      find-tag-next-line-after-failure-p)
@@ -886,19 +882,16 @@ See documentation of variable `tags-file-name'."
 			  first-search)
   (let (file				;name of file containing tag
 	tag-info			;where to find the tag in FILE
-	tags-table-file			;name of tags file
 	(first-table t)
 	(tag-order order)
 	goto-func
-	match-type
 	)
     (save-excursion
       (or first-search			;find-tag-noselect has already done it.
 	  (visit-tags-table-buffer 'same))
 
       ;; Get a qualified match.
-      (setq match-type 
-	    (catch 'qualified-match-found
+      (catch 'qualified-match-found
 
 	;; Iterate over the list of tags tables.
 	(while (or first-table
@@ -910,12 +903,9 @@ See documentation of variable `tags-file-name'."
 	  (and first-search first-table
 	       ;; Start at beginning of tags file.
 	       (goto-char (point-min)))
-	  (or first-table
-	      (goto-char (point-min)))
 
 	  (setq first-table nil)
 
-	  (setq tags-table-file buffer-file-name)
 	  ;; Iterate over the list of ordering predicates.
 	  (while order
 	    (while (funcall search-forward-func pattern nil t)
@@ -934,8 +924,8 @@ See documentation of variable `tags-file-name'."
 	  (setq order tag-order))
 	;; We throw out on match, so only get here if there were no matches.
 	(error "No %stags %s %s" (if first-search "" "more ")
-	       matching pattern)))
-      
+	       matching pattern))
+
       ;; Found a tag; extract location info.
       (beginning-of-line)
       (setq tag-lines-already-matched (cons (point)
@@ -951,10 +941,8 @@ See documentation of variable `tags-file-name'."
       (set-buffer (find-file-noselect file))
       (widen)
       (push-mark)
-      (if (eq match-type 'tag-filename-match-p)
-	  (goto-char (point-min))
-	(funcall goto-func tag-info))
-      
+      (funcall goto-func tag-info)
+
       ;; Return the buffer where the tag was found.
       (current-buffer))))
 
@@ -978,12 +966,11 @@ See documentation of variable `tags-file-name'."
 		 (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-filename-match-p
+		 (find-tag-tag-order . (tag-exact-file-name-match-p
 					tag-exact-match-p
 					tag-symbol-match-p
 					tag-word-match-p
 					tag-any-match-p))
-		 (find-tag-file-order . (tag-filename-match-p))
 		 (find-tag-next-line-after-failure-p . nil)
 		 (list-tags-function . etags-list-tags)
 		 (tags-apropos-function . etags-tags-apropos)
@@ -1031,74 +1018,93 @@ See documentation of variable `tags-file-name'."
 
 (defun etags-snarf-tag ()
   (let (tag-text line startpos)
-    (search-forward "\177")
-    (setq tag-text (buffer-substring (1- (point))
-				     (save-excursion (beginning-of-line)
-						     (point))))
-    ;; Skip explicit tag name if present.
-    (search-forward "\001" (save-excursion (forward-line 1) (point)) t)
-    (if (looking-at "[0-9]")
-	(setq line (string-to-int (buffer-substring
-				   (point)
-				   (progn (skip-chars-forward "0-9")
-					  (point))))))
-    (search-forward ",")
-    (if (looking-at "[0-9]")
-	(setq startpos (string-to-int (buffer-substring
-				       (point)
-				       (progn (skip-chars-forward "0-9")
-					      (point))))))
+    (if (save-excursion
+	  (forward-line -1)
+	  (looking-at "\f\n"))
+	;; The match was for a source file name, not any tag within a file.
+	;; Give text of t, meaning to go exactly to the location we specify,
+	;; the beginning of the file.
+	(setq tag-text t
+	      line nil
+	      startpos 1)
+
+      ;; 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))))
+      ;; Skip explicit tag name if present.
+      (search-forward "\001" (save-excursion (forward-line 1) (point)) t)
+      (if (looking-at "[0-9]")
+	  (setq line (string-to-int (buffer-substring
+				     (point)
+				     (progn (skip-chars-forward "0-9")
+					    (point))))))
+      (search-forward ",")
+      (if (looking-at "[0-9]")
+	  (setq startpos (string-to-int (buffer-substring
+					 (point)
+					 (progn (skip-chars-forward "0-9")
+						(point)))))))
     ;; Leave point on the next line of the tags file.
     (forward-line 1)
     (cons tag-text (cons line startpos))))
 
 ;; TAG-INFO is a cons (TEXT LINE . POSITION) where TEXT is the initial part
 ;; of a line containing the tag and POSITION is the character position of
-;; TEXT within the file (starting from 1); LINE is the line number.  Either
+;; TEXT within the file (starting from 1); LINE is the line number.  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 may be nil; POSITION is used if present.  If the tag
 ;; isn't exactly at the given position then look around that position using
 ;; a search window which expands until it hits the start of file.
 (defun etags-goto-tag-location (tag-info)
   (let ((startpos (cdr (cdr tag-info)))
-	;; This constant is 1/2 the initial search window.
-	;; There is no sense in making it too small,
-	;; since just going around the loop once probably
-	;; costs about as much as searching 2000 chars.
-	(offset 1000)
-	(found nil)
-	(pat (concat (if (eq selective-display t)
-			 "\\(^\\|\^m\\)" "^")
-		     (regexp-quote (car tag-info)))))
-    ;; The character position in the tags table is 0-origin.
-    ;; Convert it to a 1-origin Emacs character position.
-    (if startpos (setq startpos (1+ startpos)))
-    ;; If no char pos was given, try the given line number.
-    (or startpos
-	(if (car (cdr tag-info))
-	    (setq startpos (progn (goto-line (car (cdr tag-info)))
-				  (point)))))
-    (or startpos
-	(setq startpos (point-min)))
-    ;; First see if the tag is right at the specified location.
-    (goto-char startpos)
-    (setq found (looking-at pat))
-    (while (and (not found)
-		(progn
-		  (goto-char (- startpos offset))
-		  (not (bobp))))
-      (setq found
-	    (re-search-forward pat (+ startpos offset) t)
-	    offset (* 3 offset)))	; expand search window
-    (or found
-	(re-search-forward pat nil t)
-	(error "Rerun etags: `%s' not found in %s"
-	       pat buffer-file-name)))
-  ;; Position point at the right place
-  ;; if the search string matched an extra Ctrl-m at the beginning.
-  (and (eq selective-display t)
-       (looking-at "\^m")
-       (forward-char 1))
-  (beginning-of-line))
+	offset found pat)
+    (if (eq (car tag-info) t)
+	;; Direct file tag.
+	(cond (line (goto-line line))
+	      (position (goto-char position))
+	      (t (error "etags.el BUG: bogus direct file tag")))
+      ;; This constant is 1/2 the initial search window.
+      ;; There is no sense in making it too small,
+      ;; since just going around the loop once probably
+      ;; costs about as much as searching 2000 chars.
+      (setq offset 1000
+	    found nil
+	    pat (concat (if (eq selective-display t)
+			    "\\(^\\|\^m\\)" "^")
+			(regexp-quote (car tag-info))))
+      ;; The character position in the tags table is 0-origin.
+      ;; Convert it to a 1-origin Emacs character position.
+      (if startpos (setq startpos (1+ startpos)))
+      ;; If no char pos was given, try the given line number.
+      (or startpos
+	  (if (car (cdr tag-info))
+	      (setq startpos (progn (goto-line (car (cdr tag-info)))
+				    (point)))))
+      (or startpos
+	  (setq startpos (point-min)))
+      ;; First see if the tag is right at the specified location.
+      (goto-char startpos)
+      (setq found (looking-at pat))
+      (while (and (not found)
+		  (progn
+		    (goto-char (- startpos offset))
+		    (not (bobp))))
+	(setq found
+	      (re-search-forward pat (+ startpos offset) t)
+	      offset (* 3 offset)))	; expand search window
+      (or found
+	  (re-search-forward pat nil t)
+	  (error "Rerun etags: `%s' not found in %s"
+		 pat buffer-file-name)))
+    ;; Position point at the right place
+    ;; if the search string matched an extra Ctrl-m at the beginning.
+    (and (eq selective-display t)
+	 (looking-at "\^m")
+	 (forward-char 1))
+    (beginning-of-line)))
 
 (defun etags-list-tags (file)
   (goto-char 1)
@@ -1138,9 +1144,7 @@ See documentation of variable `tags-file-name'."
       (end-of-line)
       (skip-chars-backward "^," beg)
       (or (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))))
+	  (setq files (cons (buffer-substring beg (1- (point))) files))))
     (nreverse files)))
 
 (defun etags-tags-included-tables ()
@@ -1218,10 +1222,10 @@ See documentation of variable `tags-file-name'."
        (save-excursion (backward-char (1+ (length tag)))
 		       (looking-at "\\b"))))
 
-(defun tag-filename-match-p (tag)
+(defun tag-exact-file-name-match-p (tag)
   (and (looking-at ",")
        (save-excursion (backward-char (1+ (length tag)))
-		       (looking-at "\\b"))))
+		       (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)
@@ -1258,8 +1262,9 @@ if the file was newly read in, the value is the filename."
 	 (save-excursion
 	   ;; Visit the tags table buffer to get its list of files.
 	   (visit-tags-table-buffer)
-	   ;; Copy the list so we can setcdr below.
-	   (setq next-file-list (copy-sequence (tags-table-files)))
+	   ;; Copy the list so we can setcdr below, and expand the file
+	   ;; names while we are at it, in this buffer's default directory.
+	   (setq next-file-list (mapcar 'expand-file-name (tags-table-files)))
 	   ;; Iterate over all the tags table files, collecting
 	   ;; a complete list of referenced file names.
 	   (while (visit-tags-table-buffer t)
@@ -1271,8 +1276,9 @@ if the file was newly read in, the value is the filename."
 	       ;; Use a copy so the next loop iteration will not modify the
 	       ;; list later returned by (tags-table-files).
 	       (if tail
-		   (setcdr tail (copy-sequence (tags-table-files)))
-		 (setq next-file-list (copy-sequence (tags-table-files))))))))
+		   (setcdr tail (mapcar 'expand-file-name (tags-table-files)))
+		 (setq next-file-list (mapcar 'expand-file-name
+					      (tags-table-files))))))))
 	(t
 	 ;; Initialize the list by evalling the argument.
 	 (setq next-file-list (eval initialize))))
@@ -1397,18 +1403,39 @@ See documentation of variable `tags-file-name'."
 				t t (list 'quote delimited)))
   (tags-loop-continue (or file-list-form t)))
 
+(defun tags-complete-tags-table-file (string predicate what)
+  (save-excursion
+    ;; If we need to ask for the tag table, allow that.
+    (let ((enable-recursive-minibuffers t))
+      (visit-tags-table-buffer))
+    (if (eq what t)
+	(all-completions string (mapcar 'list (tags-table-files))
+			 predicate)
+      (try-completion string (mapcar 'list (tags-table-files))
+		      predicate))))
+
 ;;;###autoload
-(defun list-tags (filename &optional next-match)
-  "Gives the list of functions available in file \"filename\"
-Searches only in \"tags-file-name\"."
-  (interactive "sFunctions in File: ")
-  (let (file-list)
-    (setq file-list (tags-locate-file-in-tags-table filename
-						    (if next-match next-match nil)))
-    (if file-list
-	(tags-list-functions-in-file (nth 1 (car file-list))
-				     (nth 2 (car file-list)))
-      (message (format "%s not found in tags table" filename)))))
+(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
+directory specification."
+  (interactive (list (completing-read "List tags in file: "
+				      'tags-complete-tags-table-file
+				      nil t nil)))
+  (with-output-to-temp-buffer "*Tags List*"
+    (princ "Tags in file ")
+    (princ file)
+    (terpri)
+    (save-excursion
+      (let ((first-time t)
+	    (gotany nil))
+	(while (visit-tags-table-buffer (not first-time))
+	  (setq first-time nil)
+	  (if (funcall list-tags-function file)
+	      (setq gotany t)))
+	(or gotany
+	    (error "File %s not in current tags tables" file))))))
 
 ;;;###autoload
 (defun tags-apropos (regexp)
@@ -1501,7 +1528,7 @@ see the doc of that variable if you want to add names to the list."
   (use-local-map select-tags-table-mode-map)
   (setq selective-display t
 	selective-display-ellipses nil))
-  
+
 (defun select-tags-table-select ()
   "Select the tags table named on this line."
   (interactive)
@@ -1516,12 +1543,12 @@ see the doc of that variable if you want to add names to the list."
   (interactive)
   (kill-buffer (current-buffer))
   (or (one-window-p)
-      (delete-window)))  
+      (delete-window)))
 
 ;;;###autoload
 (defun complete-tag ()
   "Perform tags completion on the text around point.
-Completes to the set of names listed in the current tags table.  
+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)."
   (interactive)
@@ -1556,76 +1583,6 @@ for \\[find-tag] (which see)."
 
 ;;;###autoload (define-key esc-map "\t" 'complete-tag)
 
-(defun tags-list-functions-in-file (pos tag-file)
-   "Lists the functions for the given file.  Backend for `list-tags'."
-   (let ((tag-buf (find-file-noselect tag-file))
-       (result-buf (get-buffer-create "*Tags Function List*"))
-       function
-       beg
-       map)
-     (save-excursion
-       (set-buffer result-buf)
-       (erase-buffer)
-       (set-buffer tag-buf)
-       (goto-char pos)
-       (forward-line 1)
-       (beginning-of-line)
-       ; C-l marks end of information of a file in TAGS.
-       (while (and (not (looking-at "^\C-l")) (not (eobp)))
-       ; skip mere #defines, typedefs and struct definitions
-       (if (not (or (looking-at "^#define\\s-+[a-zA-Z0-9_]+\\s-+")
-                    (looking-at "^typedef\\s-+")
-                    (looking-at "^\\s-*}")))
-           (progn
-             (setq beg (point))
-             (skip-chars-forward "^\C-?(")
-             (setq function (buffer-substring beg (point)))
-             (save-excursion
-               (set-buffer result-buf)
-               (insert (concat function "\n")))))
-       (forward-line 1)
-       (beginning-of-line)))
-     (switch-to-buffer "*Tags Function List*")
-     (goto-char 1)
-     (set-buffer-modified-p nil)
-     (setq buffer-read-only t)))
-
-(defun tags-locate-file-in-tags-table (filename first-search)
-  "This function is used to locate `filename' in `tags-table-list'.
- Its internally used by the functions `find-file-from-tags' and
- `tags-list-tags-in-file'.  If `first-search' is t, search continues from where 
- it left off last time.  Else, its a fresh search."
-  (let (tag-list current-tags-buffer beg file found-file-list next-tag-file)
-    (setq tag-list tags-table-list)
-    (catch 'found-file
-      (setq found-file-list nil
-	    next-tag-file nil)
-      (while tag-list
-	(setq current-tags-buffer (find-file-noselect (car tag-list)))
-	(save-excursion
-	  (set-buffer current-tags-buffer)
-	  (if (or next-tag-file
-		  (not first-search))
-	      (goto-char (point-min)))
-	  (if (search-forward filename nil t)
-	      (if (tag-filename-match-p filename)
-		  (progn
-		    (beginning-of-line)
-		    (setq beg (point))
-		    (skip-chars-forward "^,")
-		    (or (looking-at ",include$")
-			(setq file (expand-file-name (buffer-substring beg
-								       (point)))))
-		    (if (string-match filename (file-name-nondirectory file))
-			(progn
-			  (setq found-file-list (cons (list file (point)
-							    (buffer-file-name))
-						      found-file-list))
-			  (throw 'found-file found-file-list))))))
-	  (setq tag-list (cdr tag-list))
-	  (setq next-tag-file 't)))
-      (throw 'found-file found-file-list))))
-
 (provide 'etags)
 
 ;;; etags.el ends here