xemacs-beta: lisp/hyperbole/hmouse-tag.el comparison

comparison lisp/hyperbole/hmouse-tag.el @ 100:4be1180a9e89 r20-1b2

Import from CVS: tag r20-1b2

author	cvs
date	Mon, 13 Aug 2007 09:15:11 +0200
parents	131b0175ea99
children

comparison

equal deleted inserted replaced

-:2d83cbd90d8d
+:4be1180a9e89
 ;; SUMMARY:      Smart Key support of programming language tags location.
 ;; USAGE:        GNU Emacs Lisp Library
 ;; KEYWORDS:     c, hypermedia, mouse, oop, tools
 ;;
 ;; AUTHOR:       Bob Weiner
-;; ORG:          Brown U.
+;; ORG:          InfoDock Associates
 ;;
 ;; ORIG-DATE:    24-Aug-91
-;; LAST-MOD:     11-Sep-95 at 18:19:48 by Bob Weiner
+;; LAST-MOD:     17-Feb-97 at 15:31:50 by Bob Weiner
-;;
-;; This file is part of Hyperbole.
-;; Available for use and distribution under the same terms as GNU Emacs.
-;;
-;; Copyright (C) 1991-1995, Free Software Foundation, Inc.
-;; Developed with support from Motorola Inc.
-;;
-;; DESCRIPTION:
-;;
-;;   Supports C, C++, Objective-C, Lisp, Fortran, and Assembly.
-;;   See the GNU Emacs manual for information on how to create a TAGS file
-;;     from the `etags' program.
-;;   Does not support the `ctags' tags file format.
-;;
-;;   YOU MUST APPROPRIATELY SET THE PUBLIC VARIABLES BELOW BEFORE USE.
-;;
-;; DESCRIP-END.
 ;;; ************************************************************************
 ;;; Other required Elisp libraries
 ;;; ************************************************************************
+(require 'hpath)
+(require 'hbut)
 (if (cond ((or (featurep 'etags) (featurep 'tags))
 	   nil)
 	  ((or hyperb:lemacs-p hyperb:emacs19-p)
 	   ;; Force use of .elc file here since otherwise the bin/etags
 (defvar smart-c-include-dirs nil
 "*Ordered list of directories to search for C/C++ include files.
 Each directory must end with a directory separator.  Directories normally
 searched by the C/C++ pre-processor should be set instead in
-'smart-c-cpp-include-dirs'.")
+`smart-c-cpp-include-dirs'.")
 (defvar smart-c-use-lib-man nil
-"When non-nil makes 'smart-c' and 'smart-c++' display man pages for recognized lib symbols.
+"When non-nil makes `smart-c' and `smart-c++' display man pages for recognized lib symbols.
-When nil, 'smart-c' and 'smart-c++' look up only symbols defined in an etags
+When nil, `smart-c' and `smart-c++' look up only symbols defined in an etags
 TAGS file.
 Create the file ~/.CLIBS-LIST and populate it with the full pathnames (one per
 line) of all of the C/C++ libraries whose symbols you want to match against.
 Your MANPATH environment variable must include paths for the man pages of
 (defconst smart-c-include-regexp
 "[ \t/*]*#[ \t]*\\(include\\|import\\)[ \t]+\\([\"<]\\)\\([^\">]+\\)[\">]"
 "Regexp to match to C, C++, or Objective-C include file lines.
 Include keyword matched is grouping 1.  Type of include, user-specified via
-double quote, or system-related starting with '<' is given by grouping 2.
+double quote, or system-related starting with `<' is given by grouping 2.
 File name is grouping 3.")
+(defvar smart-java-package-dirs
+(and (fboundp 'getenv) (getenv "JAVA_HOME")
+(list (expand-file-name "src/" (file-name-as-directory (getenv "JAVA_HOME")))))
+"*Ordered list of directories to search for imported Java packages.
+Each directory must end with a directory separator.")
+(defconst smart-java-package-regexp
+"[ \t/*]*\\(package\\|import\\)[ \t]+\\([^; \t\n\r\f]+\\)"
+"Regexp to match to Java `package' and `import' lines.
+Keyword matched is grouping 1.  Referent is grouping 2.")
 (defvar smart-emacs-tags-file nil
 "*Full path name of etags file for GNU Emacs source.")
 ;;; ************************************************************************
 It assumes that its caller has already checked that the key was pressed in an
 appropriate buffer and has moved the cursor to the selected buffer.
 If:
 (1) on an include statement, the include file is displayed;
-Look for include file in directory list 'smart-asm-include-dirs'.
+Look for include file in directory list `smart-asm-include-dirs'.
 (2) on an identifier, the identifier definition is displayed,
-assuming the identifier is found within an 'etags' generated tag file
+assuming the identifier is found within an `etags' generated tag file
 in the current directory or any of its ancestor directories."
 (interactive)
 (or
 (if identifier nil (smart-asm-include-file))
 (let ((tag (or identifier (smart-asm-at-tag-p))))
-;; Set free variable tags-file-name so that next 'find-tag' command uses
+;; Set free variable tags-file-name so that next `find-tag' command uses
 ;; whatever tags file is set here.
 (setq tags-file-name (smart-tags-file buffer-file-name))
-(message "Looking for '%s' in '%s'..." tag tags-file-name)
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
 (condition-case ()
 	 (progn
-	   (funcall (if (br-in-browser)
+	   (smart-tags-display tag next)
-			'find-tag 'find-tag-other-window)
+	   (message "Found definition for `%s'." tag))
-		    tag next)
+(error (message "`%s' not found in `%s'." tag tags-file-name)
-	   (message "Found definition for '%s'." tag))
-(error (message "'%s' not found in '%s'." tag tags-file-name)
 	      (beep))))))
 ;;;###autoload
 (defun smart-asm-at-tag-p ()
 "Return assembly tag name that point is within, else nil."
 (let* ((identifier-chars "_.$a-zA-Z0-9")
 	 (identifier (concat "[_.$a-zA-Z][" identifier-chars "]*")))
 (save-excursion
 (skip-chars-backward identifier-chars)
 (if (looking-at identifier)
-	  (buffer-substring (point) (match-end 0))))))
+	  (smart-flash-tag
+	   (buffer-substring (point) (match-end 0))
+	   (point) (match-end 0))))))
+(defun smart-c (&optional identifier next)
+"Jumps to the definition of optional C IDENTIFIER or the one at point.
+Optional second arg NEXT means jump to next matching C tag.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If:
+(1) on a `#include' statement, the include file is displayed;
+Look for include file in directory lists `smart-c-cpp-include-dirs'
+and `smart-c-include-dirs'.
+(2) on a C identifier, the identifier definition is displayed,
+assuming the identifier is found within an `etags' generated tag file
+in the current directory or any of its ancestor directories.
+(3) if `smart-c-use-lib-man' is non-nil, the C identifier is
+recognized as a library symbol, and a man page is found for the
+identifier, then the man page is displayed."
+(interactive)
+(or
+(if identifier nil (smart-c-include-file))
+(let ((tag (or identifier (smart-c-at-tag-p))))
+;; Set free variable tags-file-name so that next `find-tag' command uses
+;; whatever tags file is set here.
+(setq tags-file-name (smart-tags-file buffer-file-name))
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
+(condition-case ()
+	 (progn
+	   (smart-tags-display tag next)
+	   (message "Found definition for `%s'." tag))
+(error
+	(if (not smart-c-use-lib-man)
+	    (progn (message "`%s' not found in `%s'." tag tags-file-name)
+		   (beep))
+	  (message "Checking if `%s' is a C library function..." tag)
+	  (if (smart-library-symbol tag)
+	      (progn (message "Displaying C library man page for `%s'." tag)
+		     (manual-entry tag))
+	    (message "`%s' not found in `%s' or C libraries."
+		     tag tags-file-name)
+	    (beep))))))))
+;;;###autoload
+(defun smart-c-at-tag-p ()
+"Return C tag name that point is within, else nil."
+(let* ((identifier-chars "_a-zA-Z0-9")
+	 (identifier (concat "[_a-zA-Z][" identifier-chars "]*")))
+(save-excursion
+(skip-chars-backward identifier-chars)
+(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (point) (match-end 0))
+	   (point) (match-end 0))))))
+;;;###autoload
+(defun smart-c++ (&optional identifier next)
+"Jumps to the definition of optional C++ IDENTIFIER or the one at point.
+Optional second arg NEXT means jump to next matching C++ tag.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If:
+(1) on a `#include' statement, the include file is displayed;
+Look for include file in directory lists `smart-c-cpp-include-dirs'
+and `smart-c-include-dirs'.
+(2) on a C++ identifier, the identifier definition is displayed,
+assuming the identifier is found within an `etags' generated tag file
+in the current directory or any of its ancestor directories.
+(3) if `smart-c-use-lib-man' is non-nil, the C++ identifier is
+recognized as a library symbol, and a man page is found for the
+identifier, then the man page is displayed."
+(interactive)
+(if (fboundp 'c++-to-definition)
+;; Only fboundp if OO-Browser has been loaded.
+(smart-c++-oo-browser)
+(or
+(if identifier nil (smart-c-include-file))
+(let ((tag (or identifier (smart-c++-at-tag-p))))
+;; Set free variable tags-file-name so that next `find-tag' command uses
+;; whatever tags file is set here.
+(setq tags-file-name (smart-tags-file buffer-file-name))
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
+(condition-case ()
+	   (progn
+	     (smart-tags-display tag next)
+	     (message "Found definition for `%s'." tag))
+	 (error
+	  (if (not smart-c-use-lib-man)
+	      (progn (message "`%s' not found in `%s'." tag tags-file-name)
+		     (beep))
+	    (message "Checking if `%s' is a C++ library function..." tag)
+	    (if (smart-library-symbol tag)
+		(progn (message "Displaying C++ library man page for `%s'." tag)
+		       (manual-entry tag))
+	      (message "`%s' not found in `%s' or C++ libraries."
+		       tag tags-file-name)
+	      (beep)))))))))
+;;; The following should be called only if the OO-Browser is available.
+(defun smart-c++-oo-browser (&optional junk)
+"Jumps to the definition of selected C++ construct via OO-Browser support.
+Optional JUNK is ignored.  Does nothing if the OO-Browser is not available.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If key is pressed:
+(1) on a `#include' statement, the include file is displayed;
+Look for include file in directory lists `smart-c-cpp-include-dirs'
+and `smart-c-include-dirs'.
+(2) within a method declaration, its definition is displayed;
+(3) on a class name, the class definition is shown.
+(2) and (3) require that an OO-Browser Environment has been loaded with
+the {M-x br-env-load RET} command."
+(interactive)
+(c++-to-definition t))
+(defun smart-c++-at-tag-p ()
+"Return C++ tag name that point is within, else nil."
+(let* ((identifier-chars "_:~<>a-zA-Z0-9")
+	 (identifier (concat "\\([_~:<a-zA-Z][" identifier-chars "]*"
+			     "[ \t]*[^]) \t:;.,?~{}][^[( \t:;.,~^!|?{}]?[=*]?\\)[ \t\n]*(")))
+(save-excursion
+(skip-chars-backward identifier-chars)
+(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (match-beginning 1) (match-end 1))
+	   (match-beginning 1) (match-end 1))))))
+(defun smart-emacs-lisp-mode-p ()
+"Return t if in a mode which uses Emacs Lisp symbols."
+(or (memq major-mode '(emacs-lisp-mode lisp-interaction-mode debugger-mode))
+;; Emacs Lisp symbols appear in Help buffers frequently.
+(string-match "Help\\*$" (buffer-name))))
+(defun smart-fortran (&optional identifier next)
+"Jumps to the definition of optional Fortran IDENTIFIER or the one at point.
+Optional second arg NEXT means jump to next matching Fortran tag.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If on a Fortran identifier, the identifier definition is displayed,
+assuming the identifier is found within an `etags' generated tag file
+in the current directory or any of its ancestor directories."
+(interactive)
+(let ((tag (or identifier (smart-fortran-at-tag-p))))
+;; Set free variable tags-file-name so that next `find-tag' command uses
+;; whatever tags file is set here.
+(setq tags-file-name (smart-tags-file buffer-file-name))
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
+(condition-case ()
+	(progn
+	  (smart-tags-display tag next)
+	  (message "Found definition for `%s'." tag))
+(error
+(message "`%s' not found in `%s'." tag tags-file-name)
+(beep)))))
+;;;###autoload
+(defun smart-fortran-at-tag-p ()
+"Return Fortran tag name that point is within, else nil."
+(let* ((identifier-chars "_a-zA-Z0-9")
+	 (identifier (concat "[_a-zA-Z][" identifier-chars "]*")))
+(save-excursion
+(skip-chars-backward identifier-chars)
+(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (point) (match-end 0))
+	   (point) (match-end 0))))))
+;;;###autoload
+(defun smart-java (&optional identifier next)
+"Jumps to the definition of optional Java IDENTIFIER or the one at point.
+Optional second arg NEXT means jump to next matching Java tag.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If:
+(1) within a commented @see cross-reference, the referent is displayed;
+(2) on a `package' or `import' statement, the referent is displayed;
+Look for referent files in the directory list `smart-java-package-dirs'.
+(3) on an Java identifier, the identifier definition is displayed,
+assuming the identifier is found within an `etags' generated tag file
+in the current directory or any of its ancestor directories."
+(interactive)
+(if (fboundp 'java-to-definition)
+;; Only fboundp if OO-Browser has been loaded.
+(smart-java-oo-browser)
+(or
+(if identifier nil (or (smart-java-cross-reference) (smart-java-packages)))
+(let ((tag (or identifier (smart-java-at-tag-p))))
+;; Set free variable tags-file-name so that next `find-tag' command uses
+;; whatever tags file is set here.
+(setq tags-file-name (smart-tags-file buffer-file-name))
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
+(condition-case ()
+	   (progn
+	     (smart-tags-display tag next)
+	     (message "Found definition for `%s'." tag))
+	 (error (progn (message "`%s' not found in `%s'." tag tags-file-name)
+		       (beep))))))))
+;;; The following should be called only if the OO-Browser is available.
+(defun smart-java-oo-browser (&optional junk)
+"Jumps to the definition of selected Java construct via OO-Browser support.
+Optional JUNK is ignored.  Does nothing if the OO-Browser is not available.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If key is pressed:
+(1) within a commented @see cross-reference, the referent is displayed;
+(2) on a `package' or `import' statement, the referent is displayed;
+Look for referent files in the directory list `smart-java-package-dirs'.
+(3) within a method declaration, its definition is displayed;
+(4) on a class name, the class definition is shown."
+(interactive)
+(or (smart-java-cross-reference)
+(smart-java-packages)
+(java-to-definition t)))
+;;;###autoload
+(defun smart-java-at-tag-p ()
+"Return Java tag name that point is within, else nil."
+(let* ((identifier-chars "_$.a-zA-Z0-9")
+	 (identifier
+	  (concat "[_$a-zA-Z][" identifier-chars "]*")))
+(save-excursion
+(skip-chars-backward identifier-chars)
+(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (point) (match-end 0))
+	   (point) (match-end 0))))))
+(defun smart-lisp (&optional next)
+"Jumps to the definition of any selected Lisp construct.
+If on an Emacs Lisp require, load, or autoload clause and `find-library'
+from load-library package by Hallvard Furuseth (hallvard@ifi.uio.no) has
+been loaded, jumps to library source, if possible.
+Otherwise, the construct must be found within an `etags' generated tag file
+in the current directory or any of its ancestor directories in order for its
+definition to be located.
+Optional NEXT means jump to next matching Lisp tag.  When matching to an Emacs
+Lisp tag using `wtags' (Bob Weiner's personal modifications to `etags'),
+there is no next tag, so display documentation for current tag instead.
+This command assumes that its caller has already checked that the key was
+pressed in an appropriate buffer and has moved the cursor to the selected
+buffer."
+(interactive)
+;; Handle `require', `load', and `autoload' clauses in Emacs Lisp.
+(or (and (fboundp 'find-library)
+	   (smart-emacs-lisp-mode-p)
+	   (let ((req)
+		 (opoint (point)))
+	     (setq req (and (search-backward "\(" nil t)
+			    (looking-at (concat
+					 "(\\(require\\|load\\|autoload\\)"
+					 "[ \t]+.*['\"]"
+					 "\\([^][() \t\n\^M`'\"]+\\)"))))
+	     (goto-char opoint)
+	     (if req (progn
+		       (setq req (buffer-substring (match-beginning 2)
+						   (match-end 2)))
+		       (hpath:display-buffer (current-buffer))
+		       (find-library req)
+		       t))))
+(let ((tag (smart-lisp-at-tag-p)))
+	;; Set free variable tags-file-name so that next `find-tag' command
+	;; uses whatever tags file is set here.
+	(setq tags-file-name (smart-tags-file default-directory))
+	;; This part only works properly for Emacs Lisp, so is conditionalized.
+	(if (and next (smart-emacs-lisp-mode-p) (featurep 'wtags))
+	    (progn (setq tag (intern tag))
+		   (cond ((fboundp tag) (describe-function tag))
+			 ((boundp tag) (describe-variable tag))
+			 (t (error "(smart-lisp): Unbound symbol: %s" tag))))
+	  (condition-case ()
+	      (smart-tags-display tag next)
+	    (error (if (equal tags-file-name smart-emacs-tags-file)
+		       (progn (message "`%s' not found in `%s'."
+				       tag tags-file-name)
+			      (beep))
+		     (setq tags-file-name smart-emacs-tags-file)
+		     (smart-tags-display tag next))))))))
+(defun smart-lisp-at-tag-p ()
+"Returns Lisp tag name that point is within, else nil.
+Returns nil when point is within a Lisp `def' keyword."
+(let* ((identifier-chars "-_*:+%$#!<>a-zA-Z0-9")
+	 (identifier (concat "[-<*a-zA-Z][" identifier-chars "]*"))
+	 (opoint (point)))
+(save-excursion
+(beginning-of-line)
+(if (and (looking-at "\\(;*[ \t]*\\)?(def[^- \n\t]+")
+	       (< opoint (match-end 0)))
+	  nil
+	(goto-char opoint)
+	(skip-chars-backward identifier-chars)
+	(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (point) (match-end 0))
+	   (point) (match-end 0)))))))
+;;;###autoload
+(defun smart-lisp-mode-p ()
+"Return t if in a mode which uses Lisp symbols."
+(or (smart-emacs-lisp-mode-p)
+(memq major-mode '(lisp-mode scheme-mode))))
+;;;###autoload
+(defun smart-objc (&optional identifier next)
+"Jumps to the definition of optional Objective-C IDENTIFIER or the one at point.
+Optional second arg NEXT means jump to next matching Objective-C tag.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If:
+(1) on a `#include' statement, the include file is displayed;
+Look for include file in directory lists `smart-c-cpp-include-dirs'
+and `smart-c-include-dirs'.
+(2) on an Objective-C identifier, the identifier definition is displayed,
+assuming the identifier is found within an `etags' generated tag file
+in the current directory or any of its ancestor directories.
+(3) if `smart-c-use-lib-man' is non-nil, the Objective-C identifier is
+recognized as a library symbol, and a man page is found for the
+identifier, then the man page is displayed."
+(interactive)
+(if (fboundp 'objc-to-definition)
+;; Only fboundp if OO-Browser has been loaded.
+(smart-objc-oo-browser)
+(or
+(if identifier nil (smart-c-include-file))
+(let ((tag (or identifier (smart-objc-at-tag-p))))
+;; Set free variable tags-file-name so that next `find-tag' command uses
+;; whatever tags file is set here.
+(setq tags-file-name (smart-tags-file buffer-file-name))
+(message "Looking for `%s' in `%s'..." tag tags-file-name)
+(condition-case ()
+	   (progn
+	     (smart-tags-display tag next)
+	     (message "Found definition for `%s'." tag))
+	 (error
+	  (if (not smart-c-use-lib-man)
+	      (progn (message "`%s' not found in `%s'." tag tags-file-name)
+		     (beep))
+	    (message
+	     "Checking if `%s' is an Objective-C library function..." tag)
+	    (if (smart-library-symbol tag)
+		(progn
+		  (message
+		   "Displaying Objective-C library man page for `%s'." tag)
+		  (manual-entry tag))
+	      (message "`%s' not found in `%s' or Objective-C libraries."
+		       tag tags-file-name)
+	      (beep)))))))))
+;;; The following should be called only if the OO-Browser is available.
+(defun smart-objc-oo-browser (&optional junk)
+"Jumps to the definition of selected Objective-C construct via OO-Browser support.
+Optional JUNK is ignored.  Does nothing if the OO-Browser is not available.
+It assumes that its caller has already checked that the key was pressed in an
+appropriate buffer and has moved the cursor to the selected buffer.
+If key is pressed:
+(1) on a `#include' statement, the include file is displayed;
+Look for include file in directory lists `smart-c-cpp-include-dirs'
+and `smart-c-include-dirs'.
+(2) within a method declaration, its definition is displayed;
+(3) on a class name, the class definition is shown.
+(2) and (3) require that an OO-Browser Environment has been loaded with
+the {M-x br-env-load RET} command."
+(interactive)
+(objc-to-definition t))
+(defun smart-objc-at-tag-p ()
+"Return Objective-C tag name that point is within, else nil."
+(let* ((identifier-chars "_a-zA-Z0-9")
+	 (identifier
+	  (concat "\\([-+][ \t]*\\)?\\([_a-zA-Z][" identifier-chars "]*\\)")))
+(save-excursion
+(skip-chars-backward identifier-chars)
+(if (looking-at identifier)
+	  (smart-flash-tag
+	   (buffer-substring (match-beginning 2) (match-end 2))
+	   (match-beginning 2) (match-end 2))))))
+;;; ************************************************************************
+;;; Private functions
+;;; ************************************************************************
 (defun smart-asm-include-file ()
 "If point is on an include file line, tries to display file.
 Returns non-nil iff on an include file line, even if file is not found.
-Look for include file in 'smart-asm-include-dirs' and add suffix \".ins\" or
+Look for include file in `smart-asm-include-dirs' and add suffix \".ins\" or
 \".inc\" to filename if it lacks a suffix."
 (let ((opoint (point)))
 ;; Some assemblers utilize the C preprocessor, so try that first.
 (cond ((smart-c-include-file))
 	  ((progn (beginning-of-line)
 		 (setq file (regexp-quote file))
 	       (setq file (concat (regexp-quote file) "\\.in[sc]$")))
 	     (while dir-list
 	       (setq dir-list
 		     (if (setq path (car (directory-files
-					   (car dir-list) t file)))
+					  (car dir-list) t file)))
 			 nil
 		       (cdr dir-list))))
 	     ;;
 	     ;; If path exists, display file
 	     ;;
 	     (if path
 		 (if (and (file-readable-p path)
 			  (progn
-			    (if (br-in-browser)
+			    (hpath:find path)
-				(find-file path)
-			      (find-file-other-window path))
 			    (cond ((featurep 'asm-mode) t)
 				  ((load "asm-mode" nil 'nomessage)
 				   (provide 'asm-mode))
 				  (t
-				    (beep)
+				   (beep)
-				    (message
+				   (message
-				      "(smart-asm-include-file):  asm-mode undefined.")
+				    "(smart-asm-include-file):  asm-mode undefined.")
-				    nil
+				   nil
-				    ))))
+				   ))))
 		     nil
 		   (beep)
-		   (message "(smart-asm-include-file):  '%s' unreadable." path))
+		   (message "(smart-asm-include-file):  `%s' unreadable." path))
 	       (beep)
-	       (message "(smart-asm-include-file):  '%s' not found." file))
+	       (message "(smart-asm-include-file):  `%s' not found." file))
 	     path))
 	  ;; not on an include file line
 	  (t (goto-char opoint)
 	     nil))))
-(defun smart-c (&optional identifier next)
-"Jumps to the definition of optional C IDENTIFIER or the one at point.
-Optional second arg NEXT means jump to next matching C tag.
-It assumes that its caller has already checked that the key was pressed in an
-appropriate buffer and has moved the cursor to the selected buffer.
-If:
-(1) on a '#include' statement, the include file is displayed;
-Look for include file in directory lists 'smart-c-cpp-include-dirs'
-and 'smart-c-include-dirs'.
-(2) on a C identifier, the identifier definition is displayed,
-assuming the identifier is found within an 'etags' generated tag file
-in the current directory or any of its ancestor directories.
-(3) if 'smart-c-use-lib-man' is non-nil, the C identifier is
-recognized as a library symbol, and a man page is found for the
-identifier, then the man page is displayed."
-(interactive)
-(or
-(if identifier nil (smart-c-include-file))
-(let ((tag (or identifier (smart-c-at-tag-p))))
-;; Set free variable tags-file-name so that next 'find-tag' command uses
-;; whatever tags file is set here.
-(setq tags-file-name (smart-tags-file buffer-file-name))
-(message "Looking for '%s' in '%s'..." tag tags-file-name)
-(condition-case ()
-	 (progn
-	   (funcall (if (br-in-browser)
-			'find-tag 'find-tag-other-window)
-		    tag next)
-	   (message "Found definition for '%s'." tag))
-(error
-	(if (not smart-c-use-lib-man)
-	    (progn (message "'%s' not found in '%s'." tag tags-file-name)
-		   (beep))
-	  (message "Checking if '%s' is a C library function..." tag)
-	  (if (smart-library-symbol tag)
-	      (progn (message "Displaying C library man page for '%s'." tag)
-		     (manual-entry tag))
-	    (message "'%s' not found in '%s' or C libraries."
-		     tag tags-file-name)
-	    (beep))))))))
-;;;###autoload
-(defun smart-c-at-tag-p ()
-"Return C tag name that point is within, else nil."
-(let* ((identifier-chars "_a-zA-Z0-9")
-	 (identifier (concat "[_a-zA-Z][" identifier-chars "]*")))
-(save-excursion
-(skip-chars-backward identifier-chars)
-(if (looking-at identifier)
-	  (buffer-substring (point) (match-end 0))))))
 (defun smart-c-include-file ()
 "If point is on an include file line, tries to display file.
 Returns non-nil iff on an include file line, even if file is not found.
-Look for include file in 'smart-c-cpp-include-dirs' and in directory list
+Look for include file in `smart-c-cpp-include-dirs' and in directory list
-'smart-c-include-dirs'."
+`smart-c-include-dirs'."
 (let ((opoint (point)))
 (beginning-of-line)
 (if (looking-at smart-c-include-regexp)
 	(let ((incl-type (string-to-char
 			  (buffer-substring (match-beginning 2)
 	  ;; If found, display file
 	  ;;
 	  (if found
 	      (if (and (file-readable-p path)
 		       (progn
-			 (if (br-in-browser)
+			 (hpath:find path)
-			     (find-file path)
-			   (find-file-other-window path))
 			 (cond ((or (featurep 'cc-mode)
 				    (featurep 'c-mode))
 				t)
 			       ((or (load "cc-mode" 'missing-ok 'nomessage)
 				    (load "c-mode" 'missing-ok 'nomessage))
 				 "(smart-c-include-file):  c-mode undefined.")
 				nil
 				))))
 		  nil
 		(beep)
-		(message "(smart-c-include-file):  '%s' unreadable." path))
+		(message "(smart-c-include-file):  `%s' unreadable." path))
 	    (beep)
-	    (message "(smart-c-include-file):  '%s' not found." file))
+	    (message "(smart-c-include-file):  `%s' not found." file))
 	  path)
 (goto-char opoint)
 nil)))
+(defun smart-flash-tag (tag start end)
-;;;###autoload
+"Tries to flash TAG at START to END in buffer, to indicate that it is serving as a hyperlink button.
-(defun smart-c++ (&optional identifier next)
+Returns TAG."
-"Jumps to the definition of optional C++ IDENTIFIER or the one at point.
+;; Button flashing code might not yet have been loaded if the whole
-Optional second arg NEXT means jump to next matching C++ tag.
+;; Hyperbole system has not been started.
+(if (fboundp 'hui:but-flash)
-It assumes that its caller has already checked that the key was pressed in an
+(progn
-appropriate buffer and has moved the cursor to the selected buffer.
+	(ibut:label-set tag start end)
+	(hui:but-flash)))
-If:
+tag)
-(1) on a '#include' statement, the include file is displayed;
-Look for include file in directory lists 'smart-c-cpp-include-dirs'
+(defun smart-java-cross-reference ()
-and 'smart-c-include-dirs'.
+"If within a Java @see comment, displays the associated definition for editing and returns non-nil, else nil.
-(2) on a C++ identifier, the identifier definition is displayed,
+Non-nil is returned even if the @see referent cannot be found.
-assuming the identifier is found within an 'etags' generated tag file
-in the current directory or any of its ancestor directories.
+Does nothing if the `oo-browser' command is undefined, since it requires that
-(3) if 'smart-c-use-lib-man' is non-nil, the C++ identifier is
+package for class and feature lookups."
-recognized as a library symbol, and a man page is found for the
+;;
-identifier, then the man page is displayed."
+;; Valid forms of @see cross-references are:
+;;    * @see #getComponent                        - current class attribute
-(interactive)
+;;    * @see #waitForAll()                        - current class method, no arguments
-(or
+;;    * @see #checkID(int, boolean)               - current class method, with arguments
-(if identifier nil (smart-c-include-file))
+;;    * @see java.awt.ColorModel#getRGBdefault    - library class method
-(let ((tag (or identifier (smart-c++-at-tag-p))))
+;;    * @see Component#paintAll                   - class method
-;; Set free variable tags-file-name so that next 'find-tag' command uses
+;;    * @see java.awt.GridBagLayout               - library class
-;; whatever tags file is set here.
+;;    * @see Container                            - class
-(setq tags-file-name (smart-tags-file buffer-file-name))
+;;
-(message "Looking for '%s' in '%s'..." tag tags-file-name)
+;; For simplicity sake, this code ignores the library path given with any
-(condition-case ()
+;; class in favor of the OO-Browser's lookup tables.  It also ignores any
-	 (progn
+;; parameters associated with a method, and thus cannot distinguish between
-	   (funcall (if (br-in-browser)
+;; methods with the same name within a single class, which we believe to be
-			'find-tag 'find-tag-other-window)
+;; fairly bad form anyway.
-		    tag next)
+;;
-	   (message "Found definition for '%s'." tag))
+(let ((opoint (point)))
-(error
+(if (and (eq major-mode 'java-mode) buffer-file-name
-	(if (not smart-c-use-lib-man)
+	     (fboundp 'br-env-load)
-	    (progn (message "'%s' not found in '%s'." tag tags-file-name)
+	     (or (looking-at "@see[ \t]+")
-		   (beep))
+		 (and (re-search-backward "[@\n\r\f]" nil t)
-	  (message "Checking if '%s' is a C++ library function..." tag)
+		      (looking-at "@see[ \t]+"))))
-	  (if (smart-library-symbol tag)
+	(let ((class) (feature))
-	      (progn (message "Displaying C++ library man page for '%s'." tag)
+	  ;; Ignore any library path preceding a classname (grouping 1)
-		     (manual-entry tag))
+	  (cond
-	    (message "'%s' not found in '%s' or C++ libraries."
+	   ((looking-at
-		     tag tags-file-name)
+	     "@see[ \t]+\\(#\\)?\\([^][(){} \t\n\r\f#]+[.]\\)?\\([^][(){} \t\n\r\f#.]+\\)[][(){} \t\n\r\f]")
-	    (beep))))))))
+	    (if (match-beginning 1)
+		(setq class nil
-;;; The following should be called only if the OO-Browser is available.
+		      feature (buffer-substring (match-beginning 3)
-;;;###autoload
+						(match-end 3)))
-(defun smart-c++-oobr (&optional junk)
+	      (setq class (buffer-substring (match-beginning 3) (match-end 3))
-"Jumps to the definition of selected C++ construct via OO-Browser support.
+		    feature nil)))
-Optional JUNK is ignored.  Does nothing if the OO-Browser is not available.
+	   ((looking-at
+	     "@see[ \t]+\\([^][(){} \t\n\r\f#]+[.]\\)?\\([^][(){} \t\n\r\f#.]+\\)#\\([^][(){} \t\n\r\f#.]+\\)")
-It assumes that its caller has already checked that the key was pressed in an
+	    (setq class (buffer-substring (match-beginning 2)
-appropriate buffer and has moved the cursor to the selected buffer.
+					  (match-end 2))
+		  feature (buffer-substring (match-beginning 3)
-If key is pressed:
+					    (match-end 3)))))
-(1) on a '#include' statement, the include file is displayed;
+	  ;; Return to original point.
-Look for include file in directory lists 'smart-c-cpp-include-dirs'
+	  (goto-char opoint)
-and 'smart-c-include-dirs'.
+	  ;; Lookup class / feature.
-(2) within a method declaration, its definition is displayed;
+	  (cond
-(3) on a class name, the class definition is shown.
+	   ((and (null class) (null feature))
+	    ;; Invalid or unrecognized @see format, so ignore.
-(2) and (3) require that an OO-Browser Environment has been loaded with
+	    (message "(smart-java-cross-reference): Invalid @see cross-reference format.")
-the {M-x br-env-load RTN} command."
+	    (beep)
+	    t)
-(interactive)
+	   ;; Ensure that a Java OO-Browser environment has been loaded.
-(c++-to-definition 'other-win))
+	   (t (if (or (and (boundp 'br-lang-prefix)
+			   (equal br-lang-prefix "java-")
-(defun smart-c++-at-tag-p ()
+			   (boundp 'br-env-file) (stringp br-env-file)
-"Return C++ tag name that point is within, else nil."
+			   (null br-env-spec))
-(let* ((identifier-chars "_:~<>a-zA-Z0-9")
+		      ;; Load an existing Environment based on current
-	 (identifier (concat "\\([_~:<a-zA-Z][" identifier-chars "]*"
+		      ;; buffer or prompt to build one.  This also
-			     "[ \t]*[^]) \t:;.,?~{}][^[( \t:;.,~^!|?{}]?[=*]?\\)[ \t\n]*(")))
+		      ;; loads the "br-java.el" library in which the
-(save-excursion
+		      ;; `java-class-def-regexp' variable used below
-(skip-chars-backward identifier-chars)
+		      ;; is defined.
-(if (looking-at identifier)
+		      (and (br-env-load
-	  (buffer-substring (point) (match-end 1))))))
+			    (smart-tags-file
+			     buffer-file-name
-(defun smart-emacs-lisp-mode-p ()
+			     (if (boundp 'br-env-default-file)
-"Return t if in a mode which uses Emacs Lisp symbols."
+				 br-env-default-file "OOBR")))
-(or (eq major-mode 'emacs-lisp-mode)
+			   (equal br-lang-prefix "java-")))
-(eq major-mode 'lisp-interaction-mode)
+		  (cond ((null feature)
-(eq major-mode 'debugger-mode)
+			 (br-edit nil class))
-;; Emacs Lisp symbols appear in Help buffers frequently.
+			(t
-(string-match "Help\\*$" (buffer-name))))
+			 (if (null class)
+			     (if (save-excursion
-(defun smart-fortran (&optional identifier next)
+				   (or (re-search-backward java-class-def-regexp nil t)
-"Jumps to the definition of optional Fortran IDENTIFIER or the one at point.
+				       (re-search-forward java-class-def-regexp nil t)))
-Optional second arg NEXT means jump to next matching Fortran tag.
+				 (setq class (buffer-substring
+					      (match-beginning java-class-def-name-grpn)
-It assumes that its caller has already checked that the key was pressed in an
+					      (match-end java-class-def-name-grpn)))
-appropriate buffer and has moved the cursor to the selected buffer.
+			       (error "(smart-java-cross-reference): This @see must be in a class definition.")))
+			 (br-edit-feature class feature t)))
-If on a Fortran identifier, the identifier definition is displayed,
+		(error "(smart-java-cross-reference): The OO-Browser failed to load a Java environment.")))))
-assuming the identifier is found within an 'etags' generated tag file
+;; Return to original point.
-in the current directory or any of its ancestor directories."
+(goto-char opoint)
-(interactive)
+nil)))
-(let ((tag (or identifier (smart-fortran-at-tag-p))))
-;; Set free variable tags-file-name so that next 'find-tag' command uses
+(defun smart-java-library-path (library-name)
-;; whatever tags file is set here.
+"Search up directory tree from current directory for a match to LIBRARY-NAME."
-(setq tags-file-name (smart-tags-file buffer-file-name))
+(let ((path default-directory)
-(message "Looking for '%s' in '%s'..." tag tags-file-name)
+	(library-path)
-(condition-case ()
+	(library-regexp (if (string-match "\\.\\|'//" library-name)
-	(progn
+			    (regexp-quote
-	  (funcall (if (br-in-browser)
+			     (concat (file-name-as-directory "")
-		       'find-tag 'find-tag-other-window)
+				     (substring library-name 0 (match-beginning 0))
-		   tag next)
+				     (file-name-as-directory "")))))
-	  (message "Found definition for '%s'." tag))
+	(start 0))
-(error
+;; Return rightmost match to first part of library-name.
-(message "'%s' not found in '%s'." tag tags-file-name)
+(if library-regexp
-(beep)))))
+	(while (string-match library-regexp path start)
+	  (setq start (1+ (match-beginning 0))
-;;;###autoload
+		library-path (substring path 0 (match-beginning 0)))))
-(defun smart-fortran-at-tag-p ()
+library-path))
-"Return Fortran tag name that point is within, else nil."
-(let* ((identifier-chars "_a-zA-Z0-9")
+(defun smart-java-packages ()
-	 (identifier (concat "[_a-zA-Z][" identifier-chars "]*")))
+"If point is on a `package' or `import' line, this tries to display the associated referent.
-(save-excursion
+Returns non-nil iff on such a line, even if the referent is not found.
-(skip-chars-backward identifier-chars)
+Look for packages in `smart-java-package-dirs'."
-(if (looking-at identifier)
+(let ((opoint (point)))
-	  (buffer-substring (point) (match-end 0))))))
+(beginning-of-line)
+(if (looking-at smart-java-package-regexp)
-(defun smart-lisp (&optional next)
+	(let ((keyword-type (buffer-substring
-"Jumps to the definition of any selected Lisp construct.
+			     (match-beginning 1) (match-end 1)))
-If on an Emacs Lisp require, load, or autoload clause and 'find-library'
+	      (referent (buffer-substring (match-beginning 2) (match-end 2)))
-from load-library package by Hallvard Furuseth (hallvard@ifi.uio.no) has
+	      (found)
-been loaded, jumps to library source, if possible.
+	      (subpath)
+	      dir-list path subfile)
-Otherwise, the construct must be found within an 'etags' generated tag file
+	  (goto-char opoint)
-in the current directory or any of its ancestor directories in order for its
+	  (if (string-equal keyword-type "package")
-definition to be located.
+	      (let ((library-path (smart-java-library-path referent)))
+		(if library-path
-Optional NEXT means jump to next matching Lisp tag.  When matching to an Emacs
+		    (hpath:find (expand-file-name
-Lisp tag using 'wtags' (Bob Weiner's personal modifications to 'etags'),
+				 (hypb:replace-match-string
-there is no next tag, so display documentation for current tag instead.
+				  "\\." referent (file-name-as-directory "") t)
+				 library-path))
-This command assumes that its caller has already checked that the key was
+		  ;; Show the current directory, which should contain this package.
-pressed in an appropriate buffer and has moved the cursor to the selected
+		  (hpath:find default-directory)))
-buffer."
+	    ;; This is an `import' statement.  If it includes a *, show the
+	    ;; associated library directory, otherwise, show the specific
-(interactive)
+	    ;; package.
-;; Handle 'require', 'load', and 'autoload' clauses in Emacs Lisp.
+	    (if (string-match "\\.\\*" referent)
-(or (and (fboundp 'find-library)
+		(setq subfile (substring referent 0 (match-beginning 0))
-	   (smart-emacs-lisp-mode-p)
+		      subfile (hypb:replace-match-string
-	   (let ((req)
+			       "\\." subfile (file-name-as-directory "") t))
-		 (opoint (point)))
+	      (setq subpath (hypb:replace-match-string
-	     (setq req (and (search-backward "\(" nil t)
+			     "\\." referent (file-name-as-directory "") t)
-			    (looking-at (concat
+		    subfile (concat subpath ".java")))
-					 "(\\(require\\|load\\|autoload\\)"
+	    ;;
-					 "[ \t]+.*['\"]"
+	    ;; Try to find the path containing referent.
-					 "\\([^][() \t\n\^M`'\"]+\\)"))))
+	    ;;
-	     (goto-char opoint)
+	    ;; Search up the current directory tree for a possible matching
-	     (if req (progn
+	    ;; directory below which the referent library might live and add
-		       (setq req (buffer-substring (match-beginning 2)
+	    ;; this to smart-java-package-dirs for searching.
-						   (match-end 2)))
+	    (let ((library-path (smart-java-library-path referent)))
-		       (pop-to-buffer nil t)
+	      (if library-path
-		       (find-library req)
+		  (setq dir-list (cons library-path smart-java-package-dirs))))
-		       t))))
-(let ((tag (smart-lisp-at-tag-p)))
+	    (while dir-list
-	;; Set free variable tags-file-name so that next 'find-tag' command
+	      (setq path (expand-file-name subfile (car dir-list))
-	;; uses whatever tags file is set here.
+		    dir-list (if (setq found (file-exists-p path))
-	(setq tags-file-name (smart-tags-file default-directory))
+				 nil
-	;; This part only works properly for Emacs Lisp, so is conditionalized.
+			       (cdr dir-list))))
-	(if (and next (smart-emacs-lisp-mode-p) (featurep 'wtags))
+	    (if (and (not found) subpath hyperb:microcruft-os-p)
-	    (progn (setq tag (intern tag))
+		;; Try .jav suffix.
-		   (cond ((fboundp tag) (describe-function tag))
+		(progn (setq subfile (concat subpath ".jav")
-			 ((boundp tag) (describe-variable tag))
+			     dir-list smart-java-package-dirs)
-			 (t (error "(smart-lisp): Unbound symbol: %s" tag))))
+		       (while dir-list
-	  (condition-case ()
+			 (setq path (expand-file-name subfile (car dir-list))
-	      (funcall (if (br-in-browser)
+			       dir-list (if (setq found (file-exists-p path))
-			   'find-tag 'find-tag-other-window)
+					    nil
-		       tag next)
+					  (cdr dir-list))))))
-	    (error (if (equal tags-file-name smart-emacs-tags-file)
+	    ;;
-		       nil
+	    ;; If found, display file
-		     (setq tags-file-name smart-emacs-tags-file)
+	    ;;
-		     (funcall (if (br-in-browser)
+	    (if found
-				  'find-tag 'find-tag-other-window)
+		(if (file-readable-p path)
-			      tag next))))))))
+		    (hpath:find path)
+		  (beep)
-(defun smart-lisp-at-tag-p ()
+		  (message "(smart-java-packages):  `%s' unreadable." path))
-"Returns Lisp tag name that point is within, else nil.
+	      (beep)
-Returns nil when point is on the first line of a 'def' form past the first 4
+	      (message "(smart-java-packages):  `%s' not found." referent))
-characters."
+	    path))
-(let* ((identifier-chars "-_*:+%$#!<>a-zA-Z0-9")
+(goto-char opoint)
-	 (identifier (concat "[-<*a-zA-Z][" identifier-chars "]*"))
+nil)))
-	 (opoint (point)))
-(save-excursion
-(beginning-of-line)
-(if (and (looking-at "\\(;*[ \t]*\\)?(def[^- \n\t]+[ \n\t]")
-	       (> opoint (match-end 0)))
-	  nil
-	(goto-char opoint)
-	(skip-chars-backward identifier-chars)
-	(if (looking-at identifier)
-	    (buffer-substring (point) (match-end 0)))))))
-(defun smart-lisp-mode-p ()
-"Return t if in a mode which uses Lisp symbols."
-(or (smart-emacs-lisp-mode-p)
-(eq major-mode 'lisp-mode)
-(eq major-mode 'scheme-mode)))
-;;;###autoload
-(defun smart-objc (&optional identifier next)
-"Jumps to the definition of optional Objective-C IDENTIFIER or the one at point.
-Optional second arg NEXT means jump to next matching Objective-C tag.
-It assumes that its caller has already checked that the key was pressed in an
-appropriate buffer and has moved the cursor to the selected buffer.
-If:
-(1) on a '#include' statement, the include file is displayed;
-Look for include file in directory lists 'smart-c-cpp-include-dirs'
-and 'smart-c-include-dirs'.
-(2) on an Objective-C identifier, the identifier definition is displayed,
-assuming the identifier is found within an 'etags' generated tag file
-in the current directory or any of its ancestor directories.
-(3) if 'smart-c-use-lib-man' is non-nil, the Objective-C identifier is
-recognized as a library symbol, and a man page is found for the
-identifier, then the man page is displayed."
-(interactive)
-(or
-(if identifier nil (smart-c-include-file))
-(let ((tag (or identifier (smart-objc-at-tag-p))))
-;; Set free variable tags-file-name so that next 'find-tag' command uses
-;; whatever tags file is set here.
-(setq tags-file-name (smart-tags-file buffer-file-name))
-(message "Looking for '%s' in '%s'..." tag tags-file-name)
-(condition-case ()
-	 (progn
-	   (funcall (if (br-in-browser)
-			'find-tag 'find-tag-other-window)
-		    tag next)
-	   (message "Found definition for '%s'." tag))
-(error
-	(if (not smart-c-use-lib-man)
-	    (progn (message "'%s' not found in '%s'." tag tags-file-name)
-		   (beep))
-	  (message
-	   "Checking if '%s' is an Objective-C library function..." tag)
-	  (if (smart-library-symbol tag)
-	      (progn
-		(message
-		 "Displaying Objective-C library man page for '%s'." tag)
-		(manual-entry tag))
-	    (message "'%s' not found in '%s' or Objective-C libraries."
-		     tag tags-file-name)
-	    (beep))))))))
-;;; The following should be called only if the OO-Browser is available.
-;;;###autoload
-(defun smart-objc-oobr (&optional junk)
-"Jumps to the definition of selected Objective-C construct via OO-Browser support.
-Optional JUNK is ignored.  Does nothing if the OO-Browser is not available.
-It assumes that its caller has already checked that the key was pressed in an
-appropriate buffer and has moved the cursor to the selected buffer.
-If key is pressed:
-(1) on a '#include' statement, the include file is displayed;
-Look for include file in directory lists 'smart-c-cpp-include-dirs'
-and 'smart-c-include-dirs'.
-(2) within a method declaration, its definition is displayed;
-(3) on a class name, the class definition is shown.
-(2) and (3) require that an OO-Browser Environment has been loaded with
-the {M-x br-env-load RTN} command."
-(interactive)
-(objc-to-definition 'other-win))
-(defun smart-objc-at-tag-p ()
-"Return Objective-C tag name that point is within, else nil."
-(let* ((identifier-chars "_a-zA-Z0-9")
-	 (identifier
-	  (concat "\\([-+][ \t]*\\)?\\([_a-zA-Z][" identifier-chars "]*\\)")))
-(save-excursion
-(skip-chars-backward identifier-chars)
-(if (looking-at identifier)
-	  (buffer-substring (match-beginning 2) (match-end 2))))))
-;;; ************************************************************************
-;;; Private functions
-;;; ************************************************************************
 (defun smart-library-symbol (tag)
 "Return non-nil if TAG is a library symbol listed in cache of such symbols.
 See the \"${hyperb:dir}/smart-clib-sym\" script for more information."
 (let ((buf (get-buffer-create "*junk*"))
 		    nil buf nil tag)
 (setq found (string-equal (buffer-substring 1 2) "1"))
 (set-buffer-modified-p nil)
 (kill-buffer buf)
 found)))
+(defun smart-tags-display (tag next)
+(if next (setq tag nil))
+(let ((func (or (if (fboundp 'find-tag-internal) 'find-tag-internal)
+		  (if (fboundp 'find-tag-noselect) 'find-tag-noselect)))
+	;; For XEmacs
+	(tags-always-exact t)
+	;; For Emacs 19
+	(find-tag-tag-order (if (boundp 'find-tag-tag-order)
+				find-tag-tag-order)))
+(if find-tag-tag-order
+	(if next nil (setq find-tag-tag-order '(tag-exact-match-p)))
+;; For InfoDock (XEmacs may also take this branch), force exact match.
+(if (stringp tag) (setq tag (list tag))))
+(if (and func (funcall func tag))
+	(hpath:display-buffer (current-buffer)))
+;; Signals an error if tag is not found which is caught by many callers
+;; of this function.
+(find-tag tag)))
 ;;;###autoload
 (defun smart-tags-file-path (file)
 "Expand relative FILE name by looking it up in the nearest tags file.
 Return FILE unchanged if it exists relative to the current directory or
 					      (progn (beginning-of-line)
 						     (point))))))))))
 file))
 ;;;###autoload
-(defun smart-tags-file (curr-filename)
+(defun smart-tags-file (curr-filename &optional name-of-tags-file)
-"Return appropriate tags file name for CURR-FILENAME or 'tags-file-name'."
+"Return appropriate tags file name for CURR-FILENAME or `tags-file-name'.
+Optional NAME-OF-TAGS-FILE is the literal filename for which to look."
 (let ((path curr-filename)
 	(tags-file))
 (while (and
 	    (stringp path)
 	    (setq path (file-name-directory path))
 	    (setq path (directory-file-name path))
 	    ;; Not at root directory
 	    (not (string-match ":?/\\'" path))
 	    ;; No tags file
 	    (not (file-exists-p
-		  (setq tags-file (expand-file-name "TAGS" path)))))
+		  (setq tags-file (expand-file-name (or name-of-tags-file "TAGS") path)))))
 (setq tags-file nil))
 (if (and (not tags-file)
 	     (stringp curr-filename)
 	     (smart-emacs-lisp-mode-p)
 	     (let ((path (file-name-directory curr-filename)))

Mercurial > hg > xemacs-beta

comparison lisp/hyperbole/hmouse-tag.el @ 100:4be1180a9e89 r20-1b2