xemacs-beta: lisp/oobr/br-java-ft.el comparison

comparison lisp/oobr/br-java-ft.el @ 24:4103f0995bd7 r19-15b95

Import from CVS: tag r19-15b95

author	cvs
date	Mon, 13 Aug 2007 08:51:03 +0200
parents	376386a54a3c
children	131b0175ea99

comparison

equal deleted inserted replaced

-:0edd3412f124
+:4103f0995bd7
 ;;!emacs
 ;;
 ;; FILE:         br-java-ft.el
 ;; SUMMARY:      Java OO-Browser class and member functions.
 ;; USAGE:        GNU Emacs Lisp Library
-;; KEYWORDS:     java, oop, tools
+;; KEYWORDS:     c, oop, tools
 ;;
 ;; AUTHOR:       Bob Weiner
-;; ORG:          Motorola Inc.
+;; ORG:          InfoDock Associates
 ;;
 ;; ORIG-DATE:    01-Aug-95
-;; LAST-MOD:      4-Oct-95 at 13:41:34 by Bob Weiner
+;; LAST-MOD:     13-Nov-96 at 00:08:46 by Bob Weiner
 ;;
-;; Copyright (C) 1995  Free Software Foundation, Inc.
+;; Copyright (C) 1995, 1996  Free Software Foundation, Inc.
 ;; See the file BR-COPY for license information.
 ;;
 ;; This file is part of the OO-Browser.
 ;;
 ;; DESCRIPTION:
 ;;; ************************************************************************
 ;;; Public variables
 ;;; ************************************************************************
-(defvar java-cpp-include-dirs '("/usr/include/")
-"*Ordered list of include directories by default searched by C preprocessor.
-Each directory must end with a directory separator.  See also
-'java-include-dirs'.")
-(defvar java-include-dirs nil
-"*Ordered list of directories to search for java include files.
-Each directory must end with a directory separator.  Directories normally
-searched by the java pre-processor should be set instead in
-'java-cpp-include-dirs'.")
 (defconst java-return-type-identifier
-(concat "\\([\[a-zA-Z]"
+(concat "\\([\[a-zA-Z][][" java-return-type-chars "]*"
-	  "\\|[\[a-zA-Z][]" java-return-type-chars "]*"
+	  "[][" java-return-type-chars "]+\\|[\[a-zA-Z]\\)"
-	  "[]" java-return-type-chars "]+\\)"
 	  "[ \t\n\^M]*"))
 (defconst java-type-identifier
-(concat "\\([\[a-zA-Z][]" java-identifier-chars "]*[ \t\n\^M]+\\)"))
+(concat "\\([\[a-zA-Z][][" java-identifier-chars "]*[ \t\n\^M]+\\)"))
 (defconst java-type-tag-separator "@"
 "String that separates a tag's type from its normalized definition form.
 This should be a single character which is unchanged when quoted for use as a
 literal in a regular expression.")
 (defconst java-tag-fields-regexp
 ;; The \\\\? below is necessary because we sometimes use this expression to
 ;; test against a string that has been regexp-quoted and some of the
 ;; characters in br-feature-type-regexp will then be preceded by \\.
-(format "\\`\\([^%s \n]+\\)%s\\\\?\\(%s \\)\\([^%s\n]+\\)%s"
+(format "\\`\\([^%s \n]+\\)%s\\\\?\\(%s \\)\\([^%s\n]+\\)%s?"
 	  java-type-tag-separator java-type-tag-separator
 	  br-feature-type-regexp java-type-tag-separator
 	  java-type-tag-separator)
 "Regexp matching the fields of a java feature tag line.
 Group 1 is the class of the feature.  Group 2 is the prefix preceding the
 of desired search start.
 Optional REGEXP-FLAG means FEATURE-TAG is a regular expression."
 ;; Match to function definitions, not declarations, except for abstract
 ;; methods which are declared, not defined, and so end with a ';'.
 ;;
-;; First move to the proper class implementation if feature-tag does not
+;; First move to the proper class implementation if this is not a
-;; include a <class>:: part and this is not a [default-class], so that if
+;; [default-class], so that if two classes in the same file have the same
-;; two classes in the same file have the same feature signature, we still
+;; feature signature, we still end up at the right one.
-;; end up at the right one.
+(let ((found t) (start))
 (if (string-match java-tag-fields-regexp feature-tag)
-(let ((class (substring feature-tag (match-beginning 1) (match-end 1))))
+	(let ((class (substring feature-tag (match-beginning 1) (match-end 1))))
-	(setq feature-tag (substring feature-tag (match-end 0)))
+	  (setq feature-tag (substring feature-tag (match-end 0))
-	(if regexp-flag
+		found (re-search-forward
-	    (if (not (string-match "\\`\\\\\\[\\|::" feature-tag))
+		       (java-class-definition-regexp class regexp-flag) nil t))))
-		(re-search-forward (java-class-definition-regexp class t)
-				   nil t))
+;; If class was searched for and not found, return nil.
-	  (if (not (string-match "\\`\\[\\|::" feature-tag))
+(if (not found)
-	      (re-search-forward (java-class-definition-regexp class)
+	nil
-				 nil t)))))
+;; Otherwise, look for feature expression.
-;; Now look for feature expression.
+(or regexp-flag (setq feature-tag
-(let ((found) (start))
+			    (java-feature-signature-to-regexp feature-tag)))
-(or regexp-flag (setq feature-tag
+(while (and (re-search-forward feature-tag nil t)
-			  (java-feature-signature-to-regexp feature-tag)))
+		  (setq start (match-beginning 0))
-(while (and (re-search-forward feature-tag nil t)
+		  (not (setq found (not
-		(setq start (match-beginning 0))
+				    (if (c-within-comment-p)
-		(not (setq found (not
+					(progn (search-forward "*/" nil t)
-				  (if (c-within-comment-p)
+					       t)))))))
-				      (progn (search-forward "*/" nil t)
+(if found
-					     t)))))))
+	  (progn (goto-char start)
-(if found
+		 (skip-chars-forward " \t\n\^M")
-	(progn (goto-char start)
+		 (java-to-comments-begin)
-	       (skip-chars-forward " \t\n")
+		 (recenter 0)
-	       (java-to-comments-begin)
+		 (goto-char start)
-	       (recenter 0)
+		 t)))))
-	       (goto-char start)
-	       t))))
+(defun java-feature-map-class-tags (function class)
+"Apply FUNCTION to all feature tags from CLASS and return a list of the results.
+Feature tags come from the file named by br-feature-tags-file."
+(let ((obuf (current-buffer))
+	(class-tag (concat "\n" class java-type-tag-separator))
+	(results)
+	start end)
+(set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
+(goto-char 1)
+(if (not (search-forward class-tag nil t))
+	nil
+(setq start (match-beginning 0)
+	    end (if (search-forward "\^L\n" nil t)
+		    (match-beginning 0)
+		  (point-max)))
+(goto-char start)
+;; Feature defs can occur only within a single file.
+(while (search-forward class-tag end t)
+	(setq results (cons (funcall function) results))
+	;; Might have deleted current tag and would miss next tag unless point
+	;; is moved backwards.
+	(backward-char)))
+(set-buffer obuf)
+results))
 (defun java-feature-name-to-regexp (name)
 "Converts routine NAME into a regular expression matching the routine's name tag."
-(setq name (java-feature-signature-to-regexp name))
+(java-feature-signature-to-regexp name))
-(aset name (1- (length name)) ?\()  ;; Match only to functions
-name)
 (defun java-feature-signature-to-name (signature &optional with-class for-display)
 "Extracts the feature name from SIGNATURE.
 The feature's class name is dropped from signature unless optional WITH-CLASS
 is non-nil.  If optional FOR-DISPLAY is non-nil, a feature type character is
 (setq name (substring signature (match-beginning (if for-display 2 3))
 			    (match-end 3)))
 (if with-class
 	  (setq name (concat
 		      (substring signature (match-beginning 1) (match-end 1))
-		      "." name)))
+		      java-type-tag-separator name)))
 ;; Remove any trailing whitespace.
 (br-delete-space name))
 ;;
 ;; unknown
 (t ;; Remove any trailing whitespace and add display prefix.
 			(t
 			 (concat pat (char-to-string c))))
 	      i (1+ i)))
 (setq pat (concat prefix-info pat)))))
+(defun java-feature-tag-regexp (class feature-name)
+"Return a regexp that matches to the feature tag entry for CLASS' FEATURE-NAME."
+(concat "^" (regexp-quote class) java-type-tag-separator
+	  br-feature-type-regexp " "
+	  (regexp-quote feature-name) java-type-tag-separator))
 (defun java-feature-tree-command-p (class-or-signature)
 "Display definition of CLASS-OR-SIGNATURE if a signature and return t, else return nil."
-(if (java-routine-p class-or-signature)
+;; A class name won't contain a space.
+(if (string-match " " class-or-signature)
 (progn
 	(if (br-in-browser) (br-to-view-window))
 	(br-feature-found-p (br-feature-file class-or-signature)
 			    class-or-signature))))
 (defun java-list-features (class &optional indent)
-"Return sorted list of java feature tags lexically defined in CLASS."
+"Return sorted list of Java feature tags lexically defined in CLASS.
-(let ((obuf (current-buffer))
+Optional INDENT is unused but is required for multi-language OO-Browser conformance."
-	(features)
+;; Use nreverse here so that stable sort ends up leaving same named
-	(class-tag (concat "\n" class java-type-tag-separator))
+;; features in the order they were defined in the source file.
-	feature)
+(java-sort-features
-(set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
+(nreverse (java-feature-map-class-tags 'br-feature-current class))))
-(goto-char 1)
-(if (or (null indent) (<= indent 2))
+(defun java-sort-features (feature-list)
-	;; Include all features.
+(sort feature-list 'java-feature-lessp))
-	(while (search-forward class-tag nil t)
-	  (setq features (cons (br-feature-current) features)))
-(while (search-forward class-tag nil t)
-	(setq feature (br-feature-current))
-	(setq features (cons feature features))))
-(set-buffer obuf)
-(java-sort-features (nreverse features))))
-(defun java-routine-p (str)
-(string-match "([^\)]*)" str))
-(defun java-sort-features (routine-list)
-(sort routine-list 'java-feature-lessp))
 (defun java-to-definition (&optional other-win)
 "If point is within a declaration, try to move to its definition.
 With OTHER-WIN non-nil, show it in another window."
 (interactive)
 (let ((opoint (point)))
 (cond
-((java-include-file other-win))
 ((br-check-for-class (java-class-decl-p) other-win))
 ((java-feature other-win))
 ((and (goto-char opoint)
 	   (br-check-for-class (java-find-class-name) other-win)))
 (t	(beep)
 	   class))))
 (defun java-feature (&optional other-win)
 "Move point to definition of member given by declaration at point.
 Return nil if point is not within a member declaration."
-;; If '{' follows the feature declaration, then feature is defined right
-;; here, within the class definition.
 (interactive)
 (let ((feature-def) (ftr) (class) (ftr-pat))
 (cond ((java-feature-def-p)
 	   (recenter 0)
 	   t)
-	  ;; Now look for feature definition in code (non-header) files.
+	  ;; Now look for feature definition in ancestor classes.
 	  ((progn (setq feature-def (java-feature-def-pat)
 			ftr (car (cdr (cdr feature-def)))
 			class (car (cdr feature-def))
 			ftr-pat (car feature-def))
 		  (java-locate-feature ftr class ftr-pat other-win)))
 "Add a browser listing display prefix to FEATURE-NAME from CLASS based on feature's SIGNATURE."
 (concat (cond ((string-match java-native-method-regexp signature)
 		 "/ ")
 		((string-match java-abstract-method-regexp signature)
 		 "> ")
+		;; constructors and destructors
 		((or (string-equal feature-name class)
 		     (string-equal feature-name "finalize"))
 		 "+ ")
+		;; attributes
+		((string-match "[=;,]\\'" signature)
+		 "= ")
+		;; regular methods
 		(t "- "))
 	  feature-name))
 (defun java-feature-decl ()
 (if (looking-at java-class-decl)
 nil
 (looking-at java-feature-decl)))
 (defun java-feature-def-p ()
-"Return nil unless point is within a member definition.
+"Return nil unless point is within a member declaration.
-Commented member definitions also return nil.
+Commented member declarations also return nil.
 Leaves point at start of statement for visual clarity."
 (java-skip-to-statement)
-(save-excursion
+(and (not (c-within-comment-p))
-(and (not (c-within-comment-p))
+(save-excursion (beginning-of-line)
-	 (save-excursion (beginning-of-line)
+		       (not (looking-at "[ \t]*//")))
-			 (not (looking-at "[ \t]*//")))
+(not (looking-at java-class-decl))
-	 (not (looking-at java-class-decl))
+(looking-at (concat java-at-feature-regexp "[=;,{]"))
-	 (looking-at (concat java-at-feature-regexp "[{;,]"))
+(or (= ?\{ (char-after (1- (match-end 0))))
-	 (or (= ?\{
+	   (if (not (match-end java-feature-parens-grpn))
-		(save-excursion (goto-char (match-end 0))
+	       ;; This is an attribute.
-				(preceding-char)))
+	       t
-	     ;; If ends with a '[;,]' then it must be a native or abstract
+	     ;; If this is a native or abstract method, alert user that
-	     ;; method to be a definition.
+	     ;; its definition is elsewhere.
-	     (if (match-end java-feature-parens-grpn)
+	     (save-restriction
-		 (save-restriction
+	       (narrow-to-region (match-beginning 0) (match-end 0))
-		   (narrow-to-region (match-beginning 0) (match-end 0))
+	       (cond ((looking-at "\\s *\\<abstract\\>[^;{}]+;")
-		   (if (looking-at
+		      (message "(OO-Browser):  Abstract method, definition deferred to descendants.")
-			"\\(^\\|[ \t\n\^M]\\)\\(abstract\\|native\\)[ \t\n\^M][^;{}]+;")
+		      t)
-		       (progn (message "(OO-Browser):  Abstract function, definition deferred to descendants.")
+		     ((looking-at "\\s *\\<native\\>[^;{}]+;")
-			      t))))))))
+		      (message "(OO-Browser):  Native method, defined in an external language.")
+		      t)))))))
 (defun java-feature-def-pat ()
 "Return (list <feature-def-pat> <feature-class> <feature-name>) associated with declaration at point."
 (and (java-skip-to-statement)
 (java-feature-decl)
 			      (match-beginning java-feature-name-grpn)))
 			    (concat (br-quote-match
 				     java-feature-type-grpn)))))
 	      (func-args (if (match-end java-feature-parens-grpn)
 			     (cons (match-beginning java-feature-parens-grpn)
-				   (match-end java-feature-parens-grpn))))
+				   (match-end java-feature-parens-grpn)))))
-	      (base-cl-args (match-end java-feature-parens-grpn)))
 	 (and member-type (string-match "[ \t]+$" member-type)
 	      (setq member-type (substring member-type 0
 					   (match-beginning 0))))
 	 (and (stringp member-type)
 		 "[ \t\n]*"
 		 (if func-args
 		     (concat "\\(" (java-func-args-regexp func-args)
 			     "\\|" (java-func-args-string func-args)
 			     "\\)"))
-		 ;; If is a constructor member function, then can have some
+		 "[ \t\n]*")))
-		 ;; arguments for base class constructors after a ':'
-		 ;; but preceding the '{'.
-		 "[ \t\n]*"
-		 (and base-cl-args
-		      (equal member-name class)
-		      "\\(:[^;{}]*\\)?"))))
 	   (list
 	    (` (lambda (class)
 		 (concat "^" (br-regexp-quote class)
 			 (, (concat
 			     java-type-tag-separator
 			     pre-member-regexp))
 			 (br-regexp-quote class)
 			 (, post-member-regexp))))
 	    class member-name)))))
-(defun java-feature-lessp (routine1 routine2)
+(defun java-feature-display (class-list ftr-pat &optional other-win)
-(string-lessp (java-feature-signature-to-name routine1)
+"Display feature declaration derived from CLASS-LIST, matching FTR-PAT.
-		(java-feature-signature-to-name routine2)))
+Use feature tags table to locate a match.  Caller must use 'set-buffer'
-(defun java-feature-matches (regexp)
-"Return an unsorted list of feature tags whose names match in part or whole to REGEXP."
-;; Ensure match to feature names only; also handle "^" and "$" meta-chars
-(setq regexp
-	(concat (format "^[^%s \n]+%s%s "
-			java-type-tag-separator java-type-tag-separator
-			br-feature-type-regexp)
-		(if (equal (substring regexp 0 1) "^")
-		    (progn (setq regexp (substring regexp 1)) nil)
-		  java-identifier-chars)
-		(if (equal (substring regexp -1) "$")
-		    (substring regexp 0 -1)
-		  (concat regexp java-identifier-chars))
-		java-type-tag-separator))
-(save-excursion
-(set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
-(goto-char 1)
-(let ((features))
-(while (re-search-forward regexp nil t)
-	(setq features (cons (br-feature-current) features)))
-features)))
-(defun java-feature-normalize (routine class name)
-(setq class (br-delete-space class)
-	name (java-feature-add-prefix name class routine)
-	routine (concat class java-type-tag-separator
-			name java-type-tag-separator
-			(br-delete-space routine)))
-(let* ((len (length routine))
-	 (normal-feature (make-string len ?\ ))
-	 (n 0) (i 0)
-	 (space-list '(?\  ?\t ?\n ?\^M))
-	 (space-regexp "[ \t\n\^M]+")
-	 chr)
-(while (< i len)
-(setq chr (aref routine i))
-(cond
-;; Convert sequences of space characters to a single space.
-((memq chr space-list)
-	(aset normal-feature n ?\ )
-	(if (string-match space-regexp routine i)
-	    (setq i (match-end 0)
-		  n (1+ n))
-	  (setq i (1+ i)
-		n (1+ n))))
-;;
-;; Remove // style comments
-((and (= chr ?/)
-	     (< (1+ i) len)
-	     (= (aref routine (1+ i)) ?/))
-	(setq i (+ i 2))
-	(while (and (< i len) (/= (aref routine i) ?\n))
-	  (setq i (1+ i))))
-(t ;; Normal character
-	(aset normal-feature n chr)
-	(setq i (1+ i)
-	      n (1+ n)))))
-(substring normal-feature 0 n)))
-(defun java-feature-tag-class (signature)
-"Extract the class name from SIGNATURE."
-(cond ((string-match java-type-tag-separator signature)
-	 (substring signature 0 (match-beginning 0)))
-	((string-match "\\([^ \t]+\\)\." signature)
-	 (substring signature (match-beginning 1) (match-end 1)))
-	(t "")))
-(defun java-feature-tags-lookup (class-list ftr-pat &optional other-win)
-"Display routine definition derived from CLASS-LIST, matching FTR-PAT.
-Use routine tags table to locate a match.  Caller must use 'set-buffer'
 to restore prior buffer when a match is not found."
 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
 (let  ((classes class-list)
 	 (found-ftr)
 	 (ftr-regexp)
 (while (and (not found-ftr) classes)
 	(setq class (car classes)
 	      ftr-regexp (funcall ftr-pat class)
 	      ftr-path (br-feature-def-file ftr-regexp)
 	      found-ftr (if ftr-path
-			    (br-edit-feature (br-feature-current)
+			    (br-edit-feature-from-tag (br-feature-current)
-					     ftr-path other-win))
+						      ftr-path other-win))
 	      classes (if found-ftr nil (cdr classes))))
 (if found-ftr
 	  (or class t)
-	(java-feature-tags-lookup
+	(java-feature-display
 	 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl)))
 				class-list))
 	 ftr-pat)))))
+(defun java-feature-lessp (routine1 routine2)
+(string-lessp (java-feature-signature-to-name routine1)
+		(java-feature-signature-to-name routine2)))
+(defun java-feature-map-tags (function regexp)
+"Apply FUNCTION to all current feature tags that match REGEXP and return a list of the results.
+Feature tags come from the file named by br-feature-tags-file."
+;; Ensure match to feature names only; also handle "^" and "$" meta-chars
+(let ((identifier-chars (concat "[" java-identifier-chars "]*"))
+	(results))
+(setq regexp
+	  (concat (format "^[^%s \n]+%s%s "
+			  java-type-tag-separator java-type-tag-separator
+			  br-feature-type-regexp)
+		  (if (equal (substring regexp 0 1) "^")
+		      (progn (setq regexp (substring regexp 1)) nil)
+		    identifier-chars)
+		  (if (equal (substring regexp -1) "$")
+		      (substring regexp 0 -1)
+		    (concat regexp identifier-chars))
+		  java-type-tag-separator))
+(save-excursion
+(set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
+(goto-char 1)
+(while (re-search-forward regexp nil t)
+	(setq results (cons (funcall function) results))))
+results))
+(defun java-feature-matches (regexp)
+"Return an unsorted list of feature tags whose names match in part or whole to REGEXP.
+^ and $ characters may be used to match to the beginning and end of a feature name,
+respectively."
+(java-feature-map-tags 'br-feature-current regexp))
+(defun java-feature-normalize (feature class name)
+(setq class (br-delete-space class)
+	name (java-feature-add-prefix name class feature)
+	feature (concat class java-type-tag-separator
+			name java-type-tag-separator
+			(br-delete-space feature)))
+(let* ((len (length feature))
+	 (normal-feature (make-string len ?\ ))
+	 (n 0) (i 0)
+	 (space-list '(?\  ?\t ?\n ?\^M))
+	 (space-regexp "[ \t\n\^M]+")
+	 chr)
+(while (< i len)
+(setq chr (aref feature i))
+(cond
+;; Convert sequences of space characters to a single space.
+((memq chr space-list)
+	(aset normal-feature n ?\ )
+	(if (string-match space-regexp feature i)
+	    (setq i (match-end 0)
+		  n (1+ n))
+	  (setq i (1+ i)
+		n (1+ n))))
+;;
+;; Remove // style comments
+((and (= chr ?/)
+	     (< (1+ i) len)
+	     (= (aref feature (1+ i)) ?/))
+	(setq i (+ i 2))
+	(while (and (< i len) (/= (aref feature i) ?\n))
+	  (setq i (1+ i))))
+;;
+(t ;; Normal character
+	(aset normal-feature n chr)
+	(setq i (1+ i)
+	      n (1+ n)))))
+(substring normal-feature 0 n)))
+(defun java-feature-tag-class (signature)
+"Extract the class name from SIGNATURE."
+(cond ((string-match java-type-tag-separator signature)
+	 (substring signature 0 (match-beginning 0)))
+	((string-match "\\([^ \t]+\\)\." signature)
+	 (substring signature (match-beginning 1) (match-end 1)))
+	(t "")))
 (defun java-files-with-source (class)
 "Use CLASS to compute set of files that match to a java source file regexp.
 Return as a list."
 (let ((file (if class (br-class-path class) buffer-file-name)))
 (let ((obuf (current-buffer)))
 (prog1
 	(if (and br-feature-tags-file
 		 (file-exists-p br-feature-tags-file)
 		 (file-readable-p br-feature-tags-file))
-	    (java-feature-tags-lookup class-list ftr-pat other-win)
+	    (java-feature-display class-list ftr-pat other-win)
 	  ;; Only works if features are in same directory as class def.
 	  (java-scan-ancestors-feature class-list ftr-pat other-win))
 (set-buffer obuf))))
 (defun java-find-class-name ()
 	   (pat (concat "^" ignore)))
 (forward-char 1)
 (skip-chars-backward ignore)
 (skip-chars-backward pat)
 (setq start (point))
-(skip-chars-forward (concat pat ":"))
+(skip-chars-forward pat)
 (buffer-substring start (point)))))
 (defun java-func-args-regexp (func-args)
 (let* ((space "\\\\\\s-*")
 	 (obuf (current-buffer))
 		 ;; Ensure that declaration occurs within class definition.
 		 (forward-list)
 		 (and (> (point) opoint)
 		      class))))))
-(defun java-get-feature-tags (routine-file &optional routine-list)
+(defun java-get-feature-tags (feature-file &optional feature-list)
-"Scan java ROUTINE-FILE and hold routine tags in 'br-feature-tags-file'.
+"Scan java FEATURE-FILE and hold feature tags in 'br-feature-tags-file'.
-Assume ROUTINE-FILE has already been read into a buffer and that
+Assume FEATURE-FILE has already been read into a buffer and that
-'br-feature-tags-init' has been called.  Optional ROUTINE-LIST can be
+'br-feature-tags-init' has been called.  Optional FEATURE-LIST can be
 provided so that a non-standard scan function can be used before calling
 this function."
 (interactive)
 (let ((obuf (current-buffer)))
 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file))
 (goto-char 1)
-;; Delete any prior routine tags associated with routine-file
+;; Delete any prior feature tags associated with feature-file
-(if (search-forward routine-file nil 'end)
+(if (search-forward feature-file nil 'end)
 	(progn (forward-line -1)
 	       (let ((start (point)))
 		 (search-forward "\^L" nil 'end 2)
 		 (backward-char 1)
 		 (delete-region start (point))
 		 )))
-(if routine-list
+(if feature-list
-	(progn (insert "\^L\n" routine-file "\n")
+	(progn (insert "\^L\n" feature-file "\n")
 	       (mapcar (function (lambda (tag) (insert tag "\n")))
-		       routine-list)
+		       feature-list)
 	       ))
 (set-buffer obuf)))
-(defun java-include-file (&optional other-win)
-"If point is on an include file line, try to display file.
-Return non-nil iff an include file line, even if file is not found.
-Look for include file in 'java-cpp-include-dirs' and in directory list
-'java-include-dirs'."
-(let ((opoint (point)))
-(beginning-of-line)
-(if (looking-at java-include-regexp)
-	(let ((incl-type (string-to-char
-			  (buffer-substring (match-beginning 1)
-					    (1+ (match-beginning 1)))))
-	      (file (buffer-substring (match-beginning 2) (match-end 2)))
-	      (path)
-	      (dir-list java-include-dirs)
-	      (found))
-	  (goto-char opoint)
-	  (setq dir-list (if (= incl-type ?<)
-			     (append dir-list java-cpp-include-dirs)
-			   (cons (file-name-directory buffer-file-name)
-				 dir-list)))
-	  (while dir-list
-	    (setq path (concat (car dir-list) file)
-		  dir-list (if (setq found (file-exists-p path))
-			       nil
-			     (cdr dir-list))))
-	  ;;
-	  ;; If not found in normal include dirs, check all Env paths also.
-	  ;;
-	  (if (not found)
-	      (let ((paths (delq nil (hash-map 'cdr br-paths-htable))))
-		(while paths
-		  (setq path (car paths))
-		  (if (string-equal (file-name-nondirectory path) file)
-		      (setq found t paths nil)
-		    (setq paths (cdr paths))))))
-	  ;;
-	  ;; If found, display file
-	  ;;
-	  (if found
-	      (if (file-readable-p path)
-		  (progn
-		    (funcall br-edit-file-function path other-win)
-		    (if (not (fboundp 'br-lang-mode))
-			(java-mode-setup))
-		    (br-major-mode))
-		(beep)
-		(message "(OO-Browser):  Include file '%s' unreadable." path))
-	    (beep)
-	    (message "(OO-Browser):  Include file '%s' not found." file))
-	  path)
-(goto-char opoint)
-nil)))
 (defun java-locate-feature (ftr class ftr-pat &optional other-win)
 ;; 'class' may = nil, implying non-member function
 (or class (setq class "[function]"))
 (let ((def-class))
 		     "Member `%s` of class '%s' inherited from class '%s'."
 		     ftr class def-class))
 	       t))))
 (defun java-scan-ancestors-feature (class-list ftr-pat &optional other-win)
-"Display routine definition derived from CLASS-LIST, matching FTR-PAT.
+"Display feature definition derived from CLASS-LIST, matching FTR-PAT.
 Scan files with same base name as class file."
 (let  ((classes class-list)
 	 (found-ftr)
 	 (code-def-files)
 	 (file)
 	 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl)))
 				class-list))
 	 ftr-pat)))))
 (defun java-scan-features (class start end)
-"Return reverse ordered list of java routine definitions within CLASS def.
+"Return reverse ordered list of java feature declarations within CLASS def.
-START and END give buffer region to search."
+START and END give buffer region to search.
+Multiple declarations with only one type, e.g. float a, b;
+are missed, because that would require too much effort right now.
+Use the clearer style with a type keyword for each feature defined."
 (setq class (br-delete-space class))
 (save-excursion
 (save-restriction
 (narrow-to-region start end)
 (goto-char start)
-(let ((routines) rout name)
+(let ((features) ftr name)
 	;;
 	;; Get member definitions and abstract method declarations.
-	;;
+	(while (re-search-forward java-feature-decl nil t)
-	(while (re-search-forward java-routine-def nil t)
 	  (setq start (match-beginning 0)
 		name  (buffer-substring
 		       (match-beginning java-feature-name-grpn)
 		       (match-end java-feature-name-grpn))
-		rout  (buffer-substring (match-beginning 0) (match-end 0)))
+		ftr  (buffer-substring (match-beginning 0) (match-end 0)))
 	  ;; This is necessary to remove a possible double expression match
 	  ;; where there is a blank line within the match.
-	  (if (string-match "[\n\^M]\\([ \t]*[\n\^M]\\)+" rout)
+	  (if (string-match "[\n\^M]\\([ \t]*[\n\^M]\\)+" ftr)
-	      (progn (setq rout (substring rout (match-end 0)))
+	      (progn (setq ftr (substring ftr (match-end 0)))
 		     (goto-char (+ start (match-end 0))))
 	    (if (c-within-comment-p)
 		(search-forward "*/" nil t)
-	      ;; Move point to precede feature opening brace or abstract
+	      ;; Move point to precede the feature match termination character.
-	      ;; method declaration semicolon.
 	      (backward-char)
-	      (if (= (following-char) ?\{)
+	      (cond ((= (following-char) ?\{)
-		  (condition-case ()
+		     (condition-case ()
-		      ;; Move to end of feature but ignore any error if braces
+			 ;; Move to end of feature but ignore any error if braces
-		      ;; are unbalanced.  Let the compiler tell the user about
+			 ;; are unbalanced.  Let the compiler tell the user about
-		      ;; this.
+			 ;; this.
-		      (forward-sexp)
+			 (forward-sexp)
-		    (error nil)))
+		       (error nil)))
-	      (setq rout (java-feature-normalize rout class name)
+		    ((= (following-char) ?=)
-		    routines (cons rout routines)))))
+		     (skip-chars-forward "^;")))
-	routines))))
+	      (setq ftr (java-feature-normalize ftr class name)
+		    features (cons ftr features)))))
+	features))))
 (defun java-skip-to-statement ()
 (if (re-search-backward "\\(^\\|[;{}]\\)[ \t]*" nil t)
 (progn (goto-char (match-end 0))
 	     (skip-chars-forward " \t")
 ;;; ************************************************************************
 ;;; Private variables
 ;;; ************************************************************************
-(defconst java-code-file-regexp "\\.java$"
+(defconst java-code-file-regexp "\\.java?$"
-"Regular expression matching a unique part of java source (non-header) file name and no others.")
+"Regular expression matching a unique part of a Java source file name and no others.")
-(defconst java-include-regexp
-"[ \t/*]*import[ \t]+\\([^;]+\\)"
-"Regexp to match to java include file lines.  File name is grouping 2.  Type
-of include, user-specified via double quote, or system-related starting with
-'<' is given by grouping 1.")
 (defconst java-type-def-modifier
 "\\(const\\|final\\|static\\|abstract\\|public\\|protected\\|private\\)")
 (defconst java-type-modifier-keyword
 (concat "\\(\\(public\\|protected\\|private\\|const\\|abstract\\|"
-	  "synchronized\\|final\\|static\\|threadsafe\\|transient\\|"
+	  "synchronized\\|final\\|static\\|transient\\|"
-	  "native\\)[ \t\n\^M]+\\)"))
+	  "native\\|volatile\\)[ \t\n\^M]+\\)"))
 (defconst java-type-identifier-group
 (concat "\\(\\(" java-return-type-identifier "\\)[ \t\n\^M]+\\)"))
 (defconst java-function-identifier (concat
 (defconst java-feature-decl-or-def
 (concat "^[ \t]*\\(" java-type-modifier-keyword "*"
 	  java-type-identifier-group "\\)?"
 	  "\\(" java-type-identifier "[ \t\n\^M]*\\)?"
 	  "\\(" java-function-identifier "\\|" java-identifier "\\)"
-	  ;; It's hard to tell arguments from parenthesized initializing
+	  ;; It is hard to tell arguments from parenthesized initializing
 	  ;; expressions.
-	  "[ \t\n\^M]*(\\([^);{}]*\\))\\([][]*\\)"
+	  "[ \t\n\^M]*\\(([^\);{}]*)\\)?\\([][ \t]*\\)"
-	  ;; Optional exceptions that a feature can throw.
+	  ;; Optional exceptions that a method can throw.
-	  "\\([ \t\n\^M]+throws[ \t\n\^M]+\\("
+	  "\\([ \t\n\^M]*\\<throws\\>[ \t\n\^M]*\\("
 	  java-identifier  "[, \t\n\^M]*\\)+\\)?"
 	  )
 "Regexp matching a java member declaration or definition.
 Member modifier keywords are grouped expression 'java-feature-mode-grpn'.
 Member type is grouped expression 'java-feature-type-grpn'.  Member name is
 (defconst java-feature-mod-grpn 2)
 (defconst java-feature-type-grpn 5)
 (defconst java-feature-name-grpn 9)
 (defconst java-feature-parens-grpn 11)
 (defconst java-feature-exceptions-grpn 14)
+(defconst java-feature-terminator-grpn 15)
 (defconst java-at-feature-regexp
 (concat java-feature-decl-or-def "[ \t\n]*")
 "See documentation of 'java-feature-decl-or-def' for grouping expressions.")
 (defconst java-feature-decl
-(concat java-at-feature-regexp "[;{]")
+(concat java-at-feature-regexp "\\([=;{]\\)")
-"See documentation of 'java-feature-decl-or-def' for grouping expressions.")
+"See documentation of 'java-feature-decl-or-def' for grouping expressions.
+'java-feature-terminator-grpn' holds the equal-sign, semi-color or opening brace
-(defconst java-routine-def-terminator-regexp
+that triggers the end of the match.")
-;; Also matches to abstract method declarations.
-;; Only native and abstract functions end with a semi-colon.
-"\\({\\|;\\)")
 (defconst java-routine-def
-(concat java-at-feature-regexp java-routine-def-terminator-regexp)
+(concat java-at-feature-regexp "\\([;{]\\)")
-"See documentation of 'java-feature-decl-or-def' for grouping expressions.")
+"See documentation of 'java-feature-decl-or-def' for grouping expressions.
+'java-feature-terminator-grpn' holds the opening brace that terminates the
+feature declaration or the semi-colon that terminates native and abstract
+method declarations.")
 (defconst java-class-decl
 (concat java-class-modifier-keyword
 	  java-class-keyword java-identifier "[ \t]*[;,]")
 "Regexp matching a java class declaration.
 Class name is grouping 'java-class-name-grpn'.")
 (defconst java-class-name-grpn 4)
-;; Old def was: "\\(^\\|[ \t\n\^M]\\)abstract[ \t\n\^M][^;{}]+;"
+(defconst java-abstract-method-regexp "\\<abstract\\>[^;{}]+;"
-(defconst java-abstract-method-regexp ";\\'"
 "Regexp matching a Java abstract method signature.")
-(defconst java-native-method-regexp "\\(^\\|[ \t\n\^M]\\)native[ \t\n\^M][^;{}]+;"
+(defconst java-native-method-regexp   "\\<native\\>[^;{}]+;"
 "Regexp matching a Java native method signature, one implemented in another language.")
 (provide 'br-java-ft)

Mercurial > hg > xemacs-beta

comparison lisp/oobr/br-java-ft.el @ 24:4103f0995bd7 r19-15b95