Mercurial > hg > xemacs-beta
comparison lisp/oobr/br-java-ft.el @ 0:376386a54a3c r19-14
Import from CVS: tag r19-14
| author | cvs |
|---|---|
| date | Mon, 13 Aug 2007 08:45:50 +0200 |
| parents | |
| children | 4103f0995bd7 |
comparison
equal
deleted
inserted
replaced
| -1:000000000000 | 0:376386a54a3c |
|---|---|
| 1 ;;!emacs | |
| 2 ;; | |
| 3 ;; FILE: br-java-ft.el | |
| 4 ;; SUMMARY: Java OO-Browser class and member functions. | |
| 5 ;; USAGE: GNU Emacs Lisp Library | |
| 6 ;; KEYWORDS: java, oop, tools | |
| 7 ;; | |
| 8 ;; AUTHOR: Bob Weiner | |
| 9 ;; ORG: Motorola Inc. | |
| 10 ;; | |
| 11 ;; ORIG-DATE: 01-Aug-95 | |
| 12 ;; LAST-MOD: 4-Oct-95 at 13:41:34 by Bob Weiner | |
| 13 ;; | |
| 14 ;; Copyright (C) 1995 Free Software Foundation, Inc. | |
| 15 ;; See the file BR-COPY for license information. | |
| 16 ;; | |
| 17 ;; This file is part of the OO-Browser. | |
| 18 ;; | |
| 19 ;; DESCRIPTION: | |
| 20 ;; DESCRIP-END. | |
| 21 | |
| 22 ;;; ************************************************************************ | |
| 23 ;;; Other required Elisp libraries | |
| 24 ;;; ************************************************************************ | |
| 25 | |
| 26 (mapcar 'require '(br-c-ft br-java)) | |
| 27 | |
| 28 ;;; ************************************************************************ | |
| 29 ;;; Public variables | |
| 30 ;;; ************************************************************************ | |
| 31 | |
| 32 (defvar java-cpp-include-dirs '("/usr/include/") | |
| 33 "*Ordered list of include directories by default searched by C preprocessor. | |
| 34 Each directory must end with a directory separator. See also | |
| 35 'java-include-dirs'.") | |
| 36 | |
| 37 (defvar java-include-dirs nil | |
| 38 "*Ordered list of directories to search for java include files. | |
| 39 Each directory must end with a directory separator. Directories normally | |
| 40 searched by the java pre-processor should be set instead in | |
| 41 'java-cpp-include-dirs'.") | |
| 42 | |
| 43 (defconst java-return-type-identifier | |
| 44 (concat "\\([\[a-zA-Z]" | |
| 45 "\\|[\[a-zA-Z][]" java-return-type-chars "]*" | |
| 46 "[]" java-return-type-chars "]+\\)" | |
| 47 "[ \t\n\^M]*")) | |
| 48 | |
| 49 (defconst java-type-identifier | |
| 50 (concat "\\([\[a-zA-Z][]" java-identifier-chars "]*[ \t\n\^M]+\\)")) | |
| 51 | |
| 52 (defconst java-type-tag-separator "@" | |
| 53 "String that separates a tag's type from its normalized definition form. | |
| 54 This should be a single character which is unchanged when quoted for use as a | |
| 55 literal in a regular expression.") | |
| 56 | |
| 57 (defconst java-tag-fields-regexp | |
| 58 ;; The \\\\? below is necessary because we sometimes use this expression to | |
| 59 ;; test against a string that has been regexp-quoted and some of the | |
| 60 ;; characters in br-feature-type-regexp will then be preceded by \\. | |
| 61 (format "\\`\\([^%s \n]+\\)%s\\\\?\\(%s \\)\\([^%s\n]+\\)%s" | |
| 62 java-type-tag-separator java-type-tag-separator | |
| 63 br-feature-type-regexp java-type-tag-separator | |
| 64 java-type-tag-separator) | |
| 65 "Regexp matching the fields of a java feature tag line. | |
| 66 Group 1 is the class of the feature. Group 2 is the prefix preceding the | |
| 67 feature when displayed within a listing buffer. Group 3 is the feature name. | |
| 68 The feature definition signature begins at the end of the regexp match, | |
| 69 i.e. (match-end 0), and goes to the end of the string or line.") | |
| 70 | |
| 71 ;;; ************************************************************************ | |
| 72 ;;; Public functions | |
| 73 ;;; ************************************************************************ | |
| 74 | |
| 75 (defun java-member-p () | |
| 76 "Prints whether entity at point is a java member definition or declaration." | |
| 77 (interactive) | |
| 78 (let ((name)) | |
| 79 (save-excursion | |
| 80 (message | |
| 81 (concat | |
| 82 "Is " (if (java-feature-def-p) | |
| 83 (progn (setq name | |
| 84 (buffer-substring (match-beginning | |
| 85 java-feature-name-grpn) | |
| 86 (match-end | |
| 87 java-feature-name-grpn))) | |
| 88 "") | |
| 89 "not ") | |
| 90 "a def. " | |
| 91 "Is " (if (and (java-skip-to-statement) (java-feature-decl)) | |
| 92 (progn (setq name | |
| 93 (buffer-substring (match-beginning | |
| 94 java-feature-name-grpn) | |
| 95 (match-end | |
| 96 java-feature-name-grpn))) | |
| 97 "") | |
| 98 "not ") | |
| 99 "a member decl. " | |
| 100 (if name (concat " Name = " name))))))) | |
| 101 | |
| 102 (defun java-feature-implementors (name) | |
| 103 "Return unsorted list of java feature tags which implement feature NAME. | |
| 104 This includes classes which declare abstract functions with NAME." | |
| 105 (java-feature-matches (concat "^" (regexp-quote name) "$"))) | |
| 106 | |
| 107 (defun java-feature-locate-p (feature-tag &optional regexp-flag) | |
| 108 "Leaves point at the start of FEATURE-TAG's definition in the current buffer. | |
| 109 Assumes caller has moved point to the beginning of the buffer or to the point | |
| 110 of desired search start. | |
| 111 Optional REGEXP-FLAG means FEATURE-TAG is a regular expression." | |
| 112 ;; Match to function definitions, not declarations, except for abstract | |
| 113 ;; methods which are declared, not defined, and so end with a ';'. | |
| 114 ;; | |
| 115 ;; First move to the proper class implementation if feature-tag does not | |
| 116 ;; include a <class>:: part and this is not a [default-class], so that if | |
| 117 ;; two classes in the same file have the same feature signature, we still | |
| 118 ;; end up at the right one. | |
| 119 (if (string-match java-tag-fields-regexp feature-tag) | |
| 120 (let ((class (substring feature-tag (match-beginning 1) (match-end 1)))) | |
| 121 (setq feature-tag (substring feature-tag (match-end 0))) | |
| 122 (if regexp-flag | |
| 123 (if (not (string-match "\\`\\\\\\[\\|::" feature-tag)) | |
| 124 (re-search-forward (java-class-definition-regexp class t) | |
| 125 nil t)) | |
| 126 (if (not (string-match "\\`\\[\\|::" feature-tag)) | |
| 127 (re-search-forward (java-class-definition-regexp class) | |
| 128 nil t))))) | |
| 129 ;; Now look for feature expression. | |
| 130 (let ((found) (start)) | |
| 131 (or regexp-flag (setq feature-tag | |
| 132 (java-feature-signature-to-regexp feature-tag))) | |
| 133 (while (and (re-search-forward feature-tag nil t) | |
| 134 (setq start (match-beginning 0)) | |
| 135 (not (setq found (not | |
| 136 (if (c-within-comment-p) | |
| 137 (progn (search-forward "*/" nil t) | |
| 138 t))))))) | |
| 139 (if found | |
| 140 (progn (goto-char start) | |
| 141 (skip-chars-forward " \t\n") | |
| 142 (java-to-comments-begin) | |
| 143 (recenter 0) | |
| 144 (goto-char start) | |
| 145 t)))) | |
| 146 | |
| 147 (defun java-feature-name-to-regexp (name) | |
| 148 "Converts routine NAME into a regular expression matching the routine's name tag." | |
| 149 (setq name (java-feature-signature-to-regexp name)) | |
| 150 (aset name (1- (length name)) ?\() ;; Match only to functions | |
| 151 name) | |
| 152 | |
| 153 (defun java-feature-signature-to-name (signature &optional with-class for-display) | |
| 154 "Extracts the feature name from SIGNATURE. | |
| 155 The feature's class name is dropped from signature unless optional WITH-CLASS | |
| 156 is non-nil. If optional FOR-DISPLAY is non-nil, a feature type character is | |
| 157 prepended to the name for display in a browser listing." | |
| 158 (let ((name)) | |
| 159 (cond | |
| 160 ;; member | |
| 161 ((string-match java-tag-fields-regexp signature) | |
| 162 (setq name (substring signature (match-beginning (if for-display 2 3)) | |
| 163 (match-end 3))) | |
| 164 (if with-class | |
| 165 (setq name (concat | |
| 166 (substring signature (match-beginning 1) (match-end 1)) | |
| 167 "." name))) | |
| 168 ;; Remove any trailing whitespace. | |
| 169 (br-delete-space name)) | |
| 170 ;; | |
| 171 ;; unknown | |
| 172 (t ;; Remove any trailing whitespace and add display prefix. | |
| 173 (setq name (br-delete-space signature)) | |
| 174 (if for-display (java-feature-add-prefix name "" signature) name))))) | |
| 175 | |
| 176 (defun java-feature-signature-to-regexp (signature) | |
| 177 "Given a java SIGNATURE, return regexp used to match to its definition." | |
| 178 (setq signature (regexp-quote signature)) | |
| 179 (let ((prefix-info | |
| 180 (if (string-match java-tag-fields-regexp signature) | |
| 181 (prog1 (substring signature (match-beginning 0) (match-end 0)) | |
| 182 (setq signature (substring signature (match-end 0))))))) | |
| 183 (let ((pat) (i 0) (c) (len (length signature))) | |
| 184 (while (< i len) | |
| 185 (setq c (aref signature i) | |
| 186 pat (cond ((= c ? ) | |
| 187 ;; Allow for possible single line comment | |
| 188 ;; following any whitespace, e.g. following | |
| 189 ;; each routine argument. | |
| 190 (concat pat "[ \t\n\^M]*\\(//.*\\)?")) | |
| 191 (t | |
| 192 (concat pat (char-to-string c)))) | |
| 193 i (1+ i))) | |
| 194 (setq pat (concat prefix-info pat))))) | |
| 195 | |
| 196 (defun java-feature-tree-command-p (class-or-signature) | |
| 197 "Display definition of CLASS-OR-SIGNATURE if a signature and return t, else return nil." | |
| 198 (if (java-routine-p class-or-signature) | |
| 199 (progn | |
| 200 (if (br-in-browser) (br-to-view-window)) | |
| 201 (br-feature-found-p (br-feature-file class-or-signature) | |
| 202 class-or-signature)))) | |
| 203 | |
| 204 (defun java-list-features (class &optional indent) | |
| 205 "Return sorted list of java feature tags lexically defined in CLASS." | |
| 206 (let ((obuf (current-buffer)) | |
| 207 (features) | |
| 208 (class-tag (concat "\n" class java-type-tag-separator)) | |
| 209 feature) | |
| 210 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file)) | |
| 211 (goto-char 1) | |
| 212 (if (or (null indent) (<= indent 2)) | |
| 213 ;; Include all features. | |
| 214 (while (search-forward class-tag nil t) | |
| 215 (setq features (cons (br-feature-current) features))) | |
| 216 (while (search-forward class-tag nil t) | |
| 217 (setq feature (br-feature-current)) | |
| 218 (setq features (cons feature features)))) | |
| 219 (set-buffer obuf) | |
| 220 (java-sort-features (nreverse features)))) | |
| 221 | |
| 222 (defun java-routine-p (str) | |
| 223 (string-match "([^\)]*)" str)) | |
| 224 | |
| 225 (defun java-sort-features (routine-list) | |
| 226 (sort routine-list 'java-feature-lessp)) | |
| 227 | |
| 228 (defun java-to-definition (&optional other-win) | |
| 229 "If point is within a declaration, try to move to its definition. | |
| 230 With OTHER-WIN non-nil, show it in another window." | |
| 231 (interactive) | |
| 232 (let ((opoint (point))) | |
| 233 (cond | |
| 234 ((java-include-file other-win)) | |
| 235 ((br-check-for-class (java-class-decl-p) other-win)) | |
| 236 ((java-feature other-win)) | |
| 237 ((and (goto-char opoint) | |
| 238 (br-check-for-class (java-find-class-name) other-win))) | |
| 239 (t (beep) | |
| 240 (message | |
| 241 "(OO-Browser): Select a java declaration to move to its definition.") | |
| 242 nil)))) | |
| 243 | |
| 244 ;;; ************************************************************************ | |
| 245 ;;; Private functions | |
| 246 ;;; ************************************************************************ | |
| 247 | |
| 248 (defun java-class-decl-p () | |
| 249 "Return nil unless point is within a class declaration, referenced by another | |
| 250 class. Commented declarations also return nil. When value is non-nil, it is | |
| 251 the class name from the declaration. Leave point at start of statement for | |
| 252 visual clarity." | |
| 253 (java-skip-to-statement) | |
| 254 (save-excursion | |
| 255 (let ((class)) | |
| 256 (and (looking-at java-class-decl) | |
| 257 (setq class (buffer-substring | |
| 258 (match-beginning java-class-name-grpn) | |
| 259 (match-end java-class-name-grpn))) | |
| 260 (not (c-within-comment-p)) | |
| 261 (progn (beginning-of-line) | |
| 262 (not (looking-at "[ \t]*//"))) | |
| 263 class)))) | |
| 264 | |
| 265 (defun java-feature (&optional other-win) | |
| 266 "Move point to definition of member given by declaration at point. | |
| 267 Return nil if point is not within a member declaration." | |
| 268 ;; If '{' follows the feature declaration, then feature is defined right | |
| 269 ;; here, within the class definition. | |
| 270 (interactive) | |
| 271 (let ((feature-def) (ftr) (class) (ftr-pat)) | |
| 272 (cond ((java-feature-def-p) | |
| 273 (recenter 0) | |
| 274 t) | |
| 275 ;; Now look for feature definition in code (non-header) files. | |
| 276 ((progn (setq feature-def (java-feature-def-pat) | |
| 277 ftr (car (cdr (cdr feature-def))) | |
| 278 class (car (cdr feature-def)) | |
| 279 ftr-pat (car feature-def)) | |
| 280 (java-locate-feature ftr class ftr-pat other-win))) | |
| 281 ((java-feature-decl) | |
| 282 (beep) | |
| 283 (message "(OO-Browser): '%s' feature definition not found." ftr) | |
| 284 t)))) | |
| 285 | |
| 286 (defun java-feature-add-prefix (feature-name class signature) | |
| 287 "Add a browser listing display prefix to FEATURE-NAME from CLASS based on feature's SIGNATURE." | |
| 288 (concat (cond ((string-match java-native-method-regexp signature) | |
| 289 "/ ") | |
| 290 ((string-match java-abstract-method-regexp signature) | |
| 291 "> ") | |
| 292 ((or (string-equal feature-name class) | |
| 293 (string-equal feature-name "finalize")) | |
| 294 "+ ") | |
| 295 (t "- ")) | |
| 296 feature-name)) | |
| 297 | |
| 298 (defun java-feature-decl () | |
| 299 (if (looking-at java-class-decl) | |
| 300 nil | |
| 301 (looking-at java-feature-decl))) | |
| 302 | |
| 303 (defun java-feature-def-p () | |
| 304 "Return nil unless point is within a member definition. | |
| 305 Commented member definitions also return nil. | |
| 306 Leaves point at start of statement for visual clarity." | |
| 307 (java-skip-to-statement) | |
| 308 (save-excursion | |
| 309 (and (not (c-within-comment-p)) | |
| 310 (save-excursion (beginning-of-line) | |
| 311 (not (looking-at "[ \t]*//"))) | |
| 312 (not (looking-at java-class-decl)) | |
| 313 (looking-at (concat java-at-feature-regexp "[{;,]")) | |
| 314 (or (= ?\{ | |
| 315 (save-excursion (goto-char (match-end 0)) | |
| 316 (preceding-char))) | |
| 317 ;; If ends with a '[;,]' then it must be a native or abstract | |
| 318 ;; method to be a definition. | |
| 319 (if (match-end java-feature-parens-grpn) | |
| 320 (save-restriction | |
| 321 (narrow-to-region (match-beginning 0) (match-end 0)) | |
| 322 (if (looking-at | |
| 323 "\\(^\\|[ \t\n\^M]\\)\\(abstract\\|native\\)[ \t\n\^M][^;{}]+;") | |
| 324 (progn (message "(OO-Browser): Abstract function, definition deferred to descendants.") | |
| 325 t)))))))) | |
| 326 | |
| 327 (defun java-feature-def-pat () | |
| 328 "Return (list <feature-def-pat> <feature-class> <feature-name>) associated with declaration at point." | |
| 329 (and (java-skip-to-statement) | |
| 330 (java-feature-decl) | |
| 331 ;; Don't regexp-quote member-name yet | |
| 332 (let* ((member-name (buffer-substring | |
| 333 (match-beginning java-feature-name-grpn) | |
| 334 (match-end java-feature-name-grpn))) | |
| 335 (member-modifiers (if (match-end java-feature-mod-grpn) | |
| 336 (br-quote-match java-feature-mod-grpn))) | |
| 337 (class) | |
| 338 (member-type | |
| 339 (concat (and (match-end java-feature-type-grpn) | |
| 340 ;; Handle possible regexp bug | |
| 341 (not | |
| 342 (equal | |
| 343 (match-beginning java-feature-type-grpn) | |
| 344 (match-beginning java-feature-name-grpn))) | |
| 345 (concat (br-quote-match | |
| 346 java-feature-type-grpn))))) | |
| 347 (func-args (if (match-end java-feature-parens-grpn) | |
| 348 (cons (match-beginning java-feature-parens-grpn) | |
| 349 (match-end java-feature-parens-grpn)))) | |
| 350 (base-cl-args (match-end java-feature-parens-grpn))) | |
| 351 | |
| 352 (and member-type (string-match "[ \t]+$" member-type) | |
| 353 (setq member-type (substring member-type 0 | |
| 354 (match-beginning 0)))) | |
| 355 (and (stringp member-type) | |
| 356 (not (equal member-type "")) | |
| 357 (setq member-type (concat member-type "[ \t\n]*"))) | |
| 358 | |
| 359 (let ((pre-member-regexp | |
| 360 (concat | |
| 361 java-type-modifier-keyword | |
| 362 (if member-modifiers | |
| 363 (let ((def-mods "") (mod)) | |
| 364 (while (string-match "\\([a-z]+\\)[ \t\n]+" | |
| 365 member-modifiers) | |
| 366 (setq mod (substring member-modifiers | |
| 367 (match-beginning 1) | |
| 368 (match-end 1)) | |
| 369 member-modifiers (substring member-modifiers | |
| 370 (match-end 0))) | |
| 371 (if (equal (string-match | |
| 372 java-type-def-modifier mod) 0) | |
| 373 (setq def-mods (concat def-mods "\\(" mod | |
| 374 "[ \t\n]+\\)?")))) | |
| 375 def-mods)) | |
| 376 )) | |
| 377 (post-member-regexp | |
| 378 (concat | |
| 379 ;; Point at beginning of line may imply a non-member func. | |
| 380 (progn | |
| 381 ;; Class name is not part of declaration | |
| 382 ;; so look for declaration within a | |
| 383 ;; class definition and locate the class | |
| 384 ;; name. If not within a class, assume | |
| 385 ;; declaration is global. | |
| 386 (setq class (java-get-class-name-from-source)) | |
| 387 (br-regexp-quote member-name)) | |
| 388 "[ \t\n]*" | |
| 389 (if func-args | |
| 390 (concat "\\(" (java-func-args-regexp func-args) | |
| 391 "\\|" (java-func-args-string func-args) | |
| 392 "\\)")) | |
| 393 ;; If is a constructor member function, then can have some | |
| 394 ;; arguments for base class constructors after a ':' | |
| 395 ;; but preceding the '{'. | |
| 396 "[ \t\n]*" | |
| 397 (and base-cl-args | |
| 398 (equal member-name class) | |
| 399 "\\(:[^;{}]*\\)?")))) | |
| 400 (list | |
| 401 (` (lambda (class) | |
| 402 (concat "^" (br-regexp-quote class) | |
| 403 (, (concat | |
| 404 java-type-tag-separator | |
| 405 br-feature-type-regexp " " | |
| 406 (br-regexp-quote member-name) | |
| 407 java-type-tag-separator | |
| 408 pre-member-regexp)) | |
| 409 (br-regexp-quote class) | |
| 410 (, post-member-regexp)))) | |
| 411 class member-name))))) | |
| 412 | |
| 413 (defun java-feature-lessp (routine1 routine2) | |
| 414 (string-lessp (java-feature-signature-to-name routine1) | |
| 415 (java-feature-signature-to-name routine2))) | |
| 416 | |
| 417 (defun java-feature-matches (regexp) | |
| 418 "Return an unsorted list of feature tags whose names match in part or whole to REGEXP." | |
| 419 ;; Ensure match to feature names only; also handle "^" and "$" meta-chars | |
| 420 (setq regexp | |
| 421 (concat (format "^[^%s \n]+%s%s " | |
| 422 java-type-tag-separator java-type-tag-separator | |
| 423 br-feature-type-regexp) | |
| 424 (if (equal (substring regexp 0 1) "^") | |
| 425 (progn (setq regexp (substring regexp 1)) nil) | |
| 426 java-identifier-chars) | |
| 427 (if (equal (substring regexp -1) "$") | |
| 428 (substring regexp 0 -1) | |
| 429 (concat regexp java-identifier-chars)) | |
| 430 java-type-tag-separator)) | |
| 431 (save-excursion | |
| 432 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file)) | |
| 433 (goto-char 1) | |
| 434 (let ((features)) | |
| 435 (while (re-search-forward regexp nil t) | |
| 436 (setq features (cons (br-feature-current) features))) | |
| 437 features))) | |
| 438 | |
| 439 (defun java-feature-normalize (routine class name) | |
| 440 (setq class (br-delete-space class) | |
| 441 name (java-feature-add-prefix name class routine) | |
| 442 routine (concat class java-type-tag-separator | |
| 443 name java-type-tag-separator | |
| 444 (br-delete-space routine))) | |
| 445 (let* ((len (length routine)) | |
| 446 (normal-feature (make-string len ?\ )) | |
| 447 (n 0) (i 0) | |
| 448 (space-list '(?\ ?\t ?\n ?\^M)) | |
| 449 (space-regexp "[ \t\n\^M]+") | |
| 450 chr) | |
| 451 (while (< i len) | |
| 452 (setq chr (aref routine i)) | |
| 453 (cond | |
| 454 ;; Convert sequences of space characters to a single space. | |
| 455 ((memq chr space-list) | |
| 456 (aset normal-feature n ?\ ) | |
| 457 (if (string-match space-regexp routine i) | |
| 458 (setq i (match-end 0) | |
| 459 n (1+ n)) | |
| 460 (setq i (1+ i) | |
| 461 n (1+ n)))) | |
| 462 ;; | |
| 463 ;; Remove // style comments | |
| 464 ((and (= chr ?/) | |
| 465 (< (1+ i) len) | |
| 466 (= (aref routine (1+ i)) ?/)) | |
| 467 (setq i (+ i 2)) | |
| 468 (while (and (< i len) (/= (aref routine i) ?\n)) | |
| 469 (setq i (1+ i)))) | |
| 470 (t ;; Normal character | |
| 471 (aset normal-feature n chr) | |
| 472 (setq i (1+ i) | |
| 473 n (1+ n))))) | |
| 474 (substring normal-feature 0 n))) | |
| 475 | |
| 476 (defun java-feature-tag-class (signature) | |
| 477 "Extract the class name from SIGNATURE." | |
| 478 (cond ((string-match java-type-tag-separator signature) | |
| 479 (substring signature 0 (match-beginning 0))) | |
| 480 ((string-match "\\([^ \t]+\\)\." signature) | |
| 481 (substring signature (match-beginning 1) (match-end 1))) | |
| 482 (t ""))) | |
| 483 | |
| 484 (defun java-feature-tags-lookup (class-list ftr-pat &optional other-win) | |
| 485 "Display routine definition derived from CLASS-LIST, matching FTR-PAT. | |
| 486 Use routine tags table to locate a match. Caller must use 'set-buffer' | |
| 487 to restore prior buffer when a match is not found." | |
| 488 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file)) | |
| 489 (let ((classes class-list) | |
| 490 (found-ftr) | |
| 491 (ftr-regexp) | |
| 492 (class) | |
| 493 (ftr-path)) | |
| 494 (if (or (null class-list) (equal class-list '(nil))) | |
| 495 nil | |
| 496 (while (and (not found-ftr) classes) | |
| 497 (setq class (car classes) | |
| 498 ftr-regexp (funcall ftr-pat class) | |
| 499 ftr-path (br-feature-def-file ftr-regexp) | |
| 500 found-ftr (if ftr-path | |
| 501 (br-edit-feature (br-feature-current) | |
| 502 ftr-path other-win)) | |
| 503 classes (if found-ftr nil (cdr classes)))) | |
| 504 (if found-ftr | |
| 505 (or class t) | |
| 506 (java-feature-tags-lookup | |
| 507 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl))) | |
| 508 class-list)) | |
| 509 ftr-pat))))) | |
| 510 | |
| 511 (defun java-files-with-source (class) | |
| 512 "Use CLASS to compute set of files that match to a java source file regexp. | |
| 513 Return as a list." | |
| 514 (let ((file (if class (br-class-path class) buffer-file-name))) | |
| 515 (and file | |
| 516 (let* ((src-file-regexp (concat "^" (br-filename-head file) | |
| 517 java-code-file-regexp)) | |
| 518 (dir (file-name-directory file)) | |
| 519 (files (directory-files dir nil src-file-regexp))) | |
| 520 (mapcar (function (lambda (f) (concat dir f))) | |
| 521 files))))) | |
| 522 | |
| 523 (defun java-find-ancestors-feature (class-list ftr-pat &optional other-win) | |
| 524 "Scan ancestors of CLASS-LIST and show routine definition matching FTR-PAT." | |
| 525 ;; If no class, search for non-member function. | |
| 526 (or class-list (setq class-list '(nil))) | |
| 527 (let ((obuf (current-buffer))) | |
| 528 (prog1 | |
| 529 (if (and br-feature-tags-file | |
| 530 (file-exists-p br-feature-tags-file) | |
| 531 (file-readable-p br-feature-tags-file)) | |
| 532 (java-feature-tags-lookup class-list ftr-pat other-win) | |
| 533 ;; Only works if features are in same directory as class def. | |
| 534 (java-scan-ancestors-feature class-list ftr-pat other-win)) | |
| 535 (set-buffer obuf)))) | |
| 536 | |
| 537 (defun java-find-class-name () | |
| 538 "Return current word as a potential class name." | |
| 539 (save-excursion | |
| 540 (let* ((start) | |
| 541 (ignore "\]\[ \t\n;,.\(\){}-") | |
| 542 (pat (concat "^" ignore))) | |
| 543 (forward-char 1) | |
| 544 (skip-chars-backward ignore) | |
| 545 (skip-chars-backward pat) | |
| 546 (setq start (point)) | |
| 547 (skip-chars-forward (concat pat ":")) | |
| 548 (buffer-substring start (point))))) | |
| 549 | |
| 550 (defun java-func-args-regexp (func-args) | |
| 551 (let* ((space "\\\\\\s-*") | |
| 552 (obuf (current-buffer)) | |
| 553 (tmp-buf-nm "*br-java-tmp*") | |
| 554 (tmp-buf (progn (if (get-buffer tmp-buf-nm) | |
| 555 (kill-buffer tmp-buf-nm)) | |
| 556 (get-buffer-create tmp-buf-nm)))) | |
| 557 (or tmp-buf (error "OO-Browser: (java-func-args-regexp) - Can't create tmp-buf.")) | |
| 558 ;; Fill tmp-buffer with all func-args, including parens. | |
| 559 (copy-to-buffer tmp-buf (car func-args) (cdr func-args)) | |
| 560 | |
| 561 (set-buffer tmp-buf) | |
| 562 (let ((quoted-args (br-regexp-quote (buffer-substring | |
| 563 (point-min) (point-max))))) | |
| 564 (erase-buffer) | |
| 565 (insert quoted-args)) | |
| 566 | |
| 567 (goto-char (point-min)) | |
| 568 (if (looking-at "(\\s-*)") | |
| 569 (replace-match "(\\\\s-*)" t) | |
| 570 | |
| 571 ;; Replace all "\( +" with "\(" temporarily | |
| 572 (br-buffer-replace "\\(^\\|[^\\]\\)\([ \t\n]+" "\\1\(") | |
| 573 | |
| 574 ;; Replace all "+ \)" with "\)" temporarily | |
| 575 (br-buffer-replace "[ \t\n]+\)" "\)") | |
| 576 | |
| 577 ;; Replace all "...\)" with "...@" temporarily | |
| 578 (br-buffer-replace "\\\\\\.\\\\\\.\\\\\\.\)" "@@@") | |
| 579 | |
| 580 ;; Optionalize right hand side of argument assignments. | |
| 581 (br-buffer-replace "\\([^=,\( \t\n]+\\)\\([ \t\n]*=[^,\)]+\\)" | |
| 582 (concat "\\1\\\\( " | |
| 583 (br-regexp-quote java-arg-identifier) | |
| 584 "\\\\)? \\\\(\\2\\\\)?")) | |
| 585 | |
| 586 ;; Replace all "\)" with "optional <java-identifier> \)" | |
| 587 (br-buffer-replace | |
| 588 "\\([\(,][^=\)]+\\)\)" | |
| 589 (concat "\\1\\\\( " (br-regexp-quote java-arg-identifier) | |
| 590 "\\\\)?\)")) | |
| 591 | |
| 592 ;; Replace all "," with "optional <java-identifier>," | |
| 593 (br-buffer-replace | |
| 594 "\\([\(,][^=,]+\\)," | |
| 595 (concat "\\1\\\\( " (br-regexp-quote java-arg-identifier) "\\\\)?,")) | |
| 596 | |
| 597 ;; Replace all " *, *" with "<spc>,<spc>" | |
| 598 (br-buffer-replace "[ \t\n]*,[ \t\n]*" (concat space "," space)) | |
| 599 | |
| 600 ;; Replace all " +" with "<spc>" | |
| 601 (br-buffer-replace "[ \t\n]+" space) | |
| 602 | |
| 603 ;; Replace all "\(" with "\(<spc>" | |
| 604 (br-buffer-replace "\\(^\\|[^\\]\\)\(" (concat "\\1\(" space)) | |
| 605 | |
| 606 ;; Replace all "\)" with "<spc>\)" | |
| 607 (br-buffer-replace "\\([^\\]\\)\)" (concat "\\1" space "\)")) | |
| 608 | |
| 609 ;; Replace all & and quoted \\* with "<spc>[*&]+<spc>" | |
| 610 (br-buffer-replace "\\(&\\|\\\\\\*\\)+" (concat space "\\1" space)) | |
| 611 | |
| 612 ;; Replace all "<spc>" with "[ \t\n]*" | |
| 613 (br-buffer-replace "\\\\s-\\*" "[ \t\n]*") | |
| 614 | |
| 615 ;; Replace all "@@@" with any # of args | |
| 616 (br-buffer-replace "@@@" "[^\)]*\)") | |
| 617 ) | |
| 618 | |
| 619 ;; Return final buffer as a string. | |
| 620 (prog1 (buffer-substring (point-min) (point-max)) | |
| 621 (kill-buffer tmp-buf-nm) | |
| 622 (set-buffer obuf)))) | |
| 623 | |
| 624 (defun java-func-args-string (func-args) | |
| 625 (let* ((space "\\\\\\s-*") | |
| 626 (obuf (current-buffer)) | |
| 627 (tmp-buf-nm "*br-java-tmp*") | |
| 628 (tmp-buf (progn (if (get-buffer tmp-buf-nm) | |
| 629 (kill-buffer tmp-buf-nm)) | |
| 630 (get-buffer-create tmp-buf-nm)))) | |
| 631 (or tmp-buf (error "OO-Browser: (java-func-args-string) - Can't create tmp-buf.")) | |
| 632 ;; Fill tmp-buffer with all func-args, including parens. | |
| 633 (copy-to-buffer tmp-buf (car func-args) (cdr func-args)) | |
| 634 | |
| 635 (set-buffer tmp-buf) | |
| 636 (let ((quoted-args (br-regexp-quote (buffer-substring | |
| 637 (point-min) (point-max))))) | |
| 638 (erase-buffer) | |
| 639 (insert quoted-args)) | |
| 640 | |
| 641 (goto-char (point-min)) | |
| 642 (if (looking-at "(\\s-*)") | |
| 643 (replace-match "(\\\\s-*)" t) | |
| 644 | |
| 645 ;; Replace all "\( +" with "\(" temporarily | |
| 646 (br-buffer-replace "\\(^\\|[^\\]\\)\([ \t\n]+" "\\1\(") | |
| 647 | |
| 648 ;; Replace all "+ \)" with "\)" temporarily | |
| 649 (br-buffer-replace "[ \t\n]+\)" "\)") | |
| 650 | |
| 651 ;; Replace all "...\)" with "@@@" temporarily | |
| 652 (br-buffer-replace "\\\\\\.\\\\\\.\\\\\\.\)" "@@@") | |
| 653 | |
| 654 ;; Optionalize right hand side of argument assignments. | |
| 655 (br-buffer-replace "\\([^=,\( \t\n]+\\)\\([ \t\n]+=[^,\)]+\\)" | |
| 656 (concat "\\1\\\\(\\2\\\\)?")) | |
| 657 | |
| 658 ;; If an arg consists of 2 or more words, replace last with <identifier> | |
| 659 (br-buffer-replace | |
| 660 "\\([\(,][^=,\)]*[^ \t\n=,\)]+[ \t\n]+\\)[^ \t\n=,\)]+\\([ \t\n]*[,\)]\\)" | |
| 661 (concat "\\1" (br-regexp-quote java-arg-identifier) "\\2")) | |
| 662 | |
| 663 ;; If an arg consists of only 1 word, add a second | |
| 664 (br-buffer-replace | |
| 665 "\\([\(,][ \t\n]*\\)\\([^ \t\n=,\)]+\\)\\([ \t\n]*[,\)]\\)" | |
| 666 (concat "\\1\\2 " (br-regexp-quote java-arg-identifier) "\\3")) | |
| 667 | |
| 668 ;; Replace all " *, *" with "<spc>,<spc>" | |
| 669 (br-buffer-replace "[ \t\n]*,[ \t\n]*" (concat space "," space)) | |
| 670 | |
| 671 ;; Replace all " +" with "<spc>" | |
| 672 (br-buffer-replace "[ \t\n]+" space) | |
| 673 | |
| 674 ;; Replace all "\(" with "\(<spc>" | |
| 675 (br-buffer-replace "\\(^\\|[^\\]\\)\(" (concat "\\1\(" space)) | |
| 676 | |
| 677 ;; Replace all "\)" with "<spc>\)" | |
| 678 (br-buffer-replace "\\([^\\]\\)\)" (concat "\\1" space "\)")) | |
| 679 | |
| 680 ;; Replace all "<spc>" with "[ \t\n]*" | |
| 681 (br-buffer-replace "\\\\s-\\*" "[ \t\n]*") | |
| 682 | |
| 683 ;; Replace all "@@@" with any # of args | |
| 684 (br-buffer-replace "@@@" "[^\)]*\)") | |
| 685 ) | |
| 686 | |
| 687 ;; Return final buffer as a string. | |
| 688 (prog1 (buffer-substring (point-min) (point-max)) | |
| 689 (kill-buffer tmp-buf-nm) | |
| 690 (set-buffer obuf)))) | |
| 691 | |
| 692 (defun java-get-class-name-from-source () | |
| 693 "Return class name from closest class definition preceding point or nil." | |
| 694 (let ((opoint (point)) | |
| 695 (class)) | |
| 696 (save-excursion | |
| 697 (if (re-search-backward java-class-def-regexp nil t) | |
| 698 (progn (goto-char (match-beginning java-class-def-derived-grpn)) | |
| 699 (setq class (java-normalize-class-match)) | |
| 700 ;; Ensure that declaration occurs within class definition. | |
| 701 (forward-list) | |
| 702 (and (> (point) opoint) | |
| 703 class)))))) | |
| 704 | |
| 705 (defun java-get-feature-tags (routine-file &optional routine-list) | |
| 706 "Scan java ROUTINE-FILE and hold routine tags in 'br-feature-tags-file'. | |
| 707 Assume ROUTINE-FILE has already been read into a buffer and that | |
| 708 'br-feature-tags-init' has been called. Optional ROUTINE-LIST can be | |
| 709 provided so that a non-standard scan function can be used before calling | |
| 710 this function." | |
| 711 (interactive) | |
| 712 (let ((obuf (current-buffer))) | |
| 713 (set-buffer (funcall br-find-file-noselect-function br-feature-tags-file)) | |
| 714 (goto-char 1) | |
| 715 ;; Delete any prior routine tags associated with routine-file | |
| 716 (if (search-forward routine-file nil 'end) | |
| 717 (progn (forward-line -1) | |
| 718 (let ((start (point))) | |
| 719 (search-forward "\^L" nil 'end 2) | |
| 720 (backward-char 1) | |
| 721 (delete-region start (point)) | |
| 722 ))) | |
| 723 (if routine-list | |
| 724 (progn (insert "\^L\n" routine-file "\n") | |
| 725 (mapcar (function (lambda (tag) (insert tag "\n"))) | |
| 726 routine-list) | |
| 727 )) | |
| 728 (set-buffer obuf))) | |
| 729 | |
| 730 (defun java-include-file (&optional other-win) | |
| 731 "If point is on an include file line, try to display file. | |
| 732 Return non-nil iff an include file line, even if file is not found. | |
| 733 Look for include file in 'java-cpp-include-dirs' and in directory list | |
| 734 'java-include-dirs'." | |
| 735 (let ((opoint (point))) | |
| 736 (beginning-of-line) | |
| 737 (if (looking-at java-include-regexp) | |
| 738 (let ((incl-type (string-to-char | |
| 739 (buffer-substring (match-beginning 1) | |
| 740 (1+ (match-beginning 1))))) | |
| 741 (file (buffer-substring (match-beginning 2) (match-end 2))) | |
| 742 (path) | |
| 743 (dir-list java-include-dirs) | |
| 744 (found)) | |
| 745 (goto-char opoint) | |
| 746 (setq dir-list (if (= incl-type ?<) | |
| 747 (append dir-list java-cpp-include-dirs) | |
| 748 (cons (file-name-directory buffer-file-name) | |
| 749 dir-list))) | |
| 750 (while dir-list | |
| 751 (setq path (concat (car dir-list) file) | |
| 752 dir-list (if (setq found (file-exists-p path)) | |
| 753 nil | |
| 754 (cdr dir-list)))) | |
| 755 ;; | |
| 756 ;; If not found in normal include dirs, check all Env paths also. | |
| 757 ;; | |
| 758 (if (not found) | |
| 759 (let ((paths (delq nil (hash-map 'cdr br-paths-htable)))) | |
| 760 (while paths | |
| 761 (setq path (car paths)) | |
| 762 (if (string-equal (file-name-nondirectory path) file) | |
| 763 (setq found t paths nil) | |
| 764 (setq paths (cdr paths)))))) | |
| 765 ;; | |
| 766 ;; If found, display file | |
| 767 ;; | |
| 768 (if found | |
| 769 (if (file-readable-p path) | |
| 770 (progn | |
| 771 (funcall br-edit-file-function path other-win) | |
| 772 (if (not (fboundp 'br-lang-mode)) | |
| 773 (java-mode-setup)) | |
| 774 (br-major-mode)) | |
| 775 (beep) | |
| 776 (message "(OO-Browser): Include file '%s' unreadable." path)) | |
| 777 (beep) | |
| 778 (message "(OO-Browser): Include file '%s' not found." file)) | |
| 779 path) | |
| 780 (goto-char opoint) | |
| 781 nil))) | |
| 782 | |
| 783 (defun java-locate-feature (ftr class ftr-pat &optional other-win) | |
| 784 ;; 'class' may = nil, implying non-member function | |
| 785 (or class (setq class "[function]")) | |
| 786 (let ((def-class)) | |
| 787 (if (and ftr-pat | |
| 788 (setq def-class | |
| 789 (java-find-ancestors-feature (list class) | |
| 790 ftr-pat other-win))) | |
| 791 (progn (if (and class (not (equal class def-class))) | |
| 792 (message | |
| 793 "Member `%s` of class '%s' inherited from class '%s'." | |
| 794 ftr class def-class)) | |
| 795 t)))) | |
| 796 | |
| 797 (defun java-scan-ancestors-feature (class-list ftr-pat &optional other-win) | |
| 798 "Display routine definition derived from CLASS-LIST, matching FTR-PAT. | |
| 799 Scan files with same base name as class file." | |
| 800 (let ((classes class-list) | |
| 801 (found-ftr) | |
| 802 (code-def-files) | |
| 803 (file) | |
| 804 (ftr-regexp) | |
| 805 (class)) | |
| 806 (if (null class-list) | |
| 807 nil | |
| 808 (while (and (not found-ftr) classes) | |
| 809 (setq class (car classes) | |
| 810 code-def-files (java-files-with-source class) | |
| 811 ftr-regexp (funcall ftr-pat class)) | |
| 812 (while (and (setq file (car code-def-files)) | |
| 813 (not (setq found-ftr | |
| 814 (br-feature-found-p file ftr-regexp | |
| 815 nil other-win t)))) | |
| 816 (setq code-def-files (cdr code-def-files))) | |
| 817 (setq classes (if found-ftr nil (cdr classes)))) | |
| 818 (if found-ftr | |
| 819 (or class t) | |
| 820 (java-scan-ancestors-feature | |
| 821 (apply 'append (mapcar (function (lambda (cl) (br-get-parents cl))) | |
| 822 class-list)) | |
| 823 ftr-pat))))) | |
| 824 | |
| 825 (defun java-scan-features (class start end) | |
| 826 "Return reverse ordered list of java routine definitions within CLASS def. | |
| 827 START and END give buffer region to search." | |
| 828 (setq class (br-delete-space class)) | |
| 829 (save-excursion | |
| 830 (save-restriction | |
| 831 (narrow-to-region start end) | |
| 832 (goto-char start) | |
| 833 (let ((routines) rout name) | |
| 834 ;; | |
| 835 ;; Get member definitions and abstract method declarations. | |
| 836 ;; | |
| 837 (while (re-search-forward java-routine-def nil t) | |
| 838 (setq start (match-beginning 0) | |
| 839 name (buffer-substring | |
| 840 (match-beginning java-feature-name-grpn) | |
| 841 (match-end java-feature-name-grpn)) | |
| 842 rout (buffer-substring (match-beginning 0) (match-end 0))) | |
| 843 ;; This is necessary to remove a possible double expression match | |
| 844 ;; where there is a blank line within the match. | |
| 845 (if (string-match "[\n\^M]\\([ \t]*[\n\^M]\\)+" rout) | |
| 846 (progn (setq rout (substring rout (match-end 0))) | |
| 847 (goto-char (+ start (match-end 0)))) | |
| 848 (if (c-within-comment-p) | |
| 849 (search-forward "*/" nil t) | |
| 850 ;; Move point to precede feature opening brace or abstract | |
| 851 ;; method declaration semicolon. | |
| 852 (backward-char) | |
| 853 (if (= (following-char) ?\{) | |
| 854 (condition-case () | |
| 855 ;; Move to end of feature but ignore any error if braces | |
| 856 ;; are unbalanced. Let the compiler tell the user about | |
| 857 ;; this. | |
| 858 (forward-sexp) | |
| 859 (error nil))) | |
| 860 (setq rout (java-feature-normalize rout class name) | |
| 861 routines (cons rout routines))))) | |
| 862 routines)))) | |
| 863 | |
| 864 (defun java-skip-to-statement () | |
| 865 (if (re-search-backward "\\(^\\|[;{}]\\)[ \t]*" nil t) | |
| 866 (progn (goto-char (match-end 0)) | |
| 867 (skip-chars-forward " \t") | |
| 868 t))) | |
| 869 | |
| 870 ;;; ************************************************************************ | |
| 871 ;;; Private variables | |
| 872 ;;; ************************************************************************ | |
| 873 | |
| 874 (defconst java-code-file-regexp "\\.java$" | |
| 875 "Regular expression matching a unique part of java source (non-header) file name and no others.") | |
| 876 | |
| 877 (defconst java-include-regexp | |
| 878 "[ \t/*]*import[ \t]+\\([^;]+\\)" | |
| 879 "Regexp to match to java include file lines. File name is grouping 2. Type | |
| 880 of include, user-specified via double quote, or system-related starting with | |
| 881 '<' is given by grouping 1.") | |
| 882 | |
| 883 (defconst java-type-def-modifier | |
| 884 "\\(const\\|final\\|static\\|abstract\\|public\\|protected\\|private\\)") | |
| 885 | |
| 886 (defconst java-type-modifier-keyword | |
| 887 (concat "\\(\\(public\\|protected\\|private\\|const\\|abstract\\|" | |
| 888 "synchronized\\|final\\|static\\|threadsafe\\|transient\\|" | |
| 889 "native\\)[ \t\n\^M]+\\)")) | |
| 890 | |
| 891 (defconst java-type-identifier-group | |
| 892 (concat "\\(\\(" java-return-type-identifier "\\)[ \t\n\^M]+\\)")) | |
| 893 | |
| 894 (defconst java-function-identifier (concat | |
| 895 "[_a-zA-Z][^][ \t:;.,{}()=]*") | |
| 896 "Regular expression matching a Java function name.") | |
| 897 | |
| 898 (defconst java-arg-identifier | |
| 899 (concat "[_a-zA-Z][" java-identifier-chars "]*") | |
| 900 "Regular expression matching a Java function argument identifier.") | |
| 901 | |
| 902 (defconst java-feature-decl-or-def | |
| 903 (concat "^[ \t]*\\(" java-type-modifier-keyword "*" | |
| 904 java-type-identifier-group "\\)?" | |
| 905 "\\(" java-type-identifier "[ \t\n\^M]*\\)?" | |
| 906 "\\(" java-function-identifier "\\|" java-identifier "\\)" | |
| 907 ;; It's hard to tell arguments from parenthesized initializing | |
| 908 ;; expressions. | |
| 909 "[ \t\n\^M]*(\\([^);{}]*\\))\\([][]*\\)" | |
| 910 ;; Optional exceptions that a feature can throw. | |
| 911 "\\([ \t\n\^M]+throws[ \t\n\^M]+\\(" | |
| 912 java-identifier "[, \t\n\^M]*\\)+\\)?" | |
| 913 ) | |
| 914 "Regexp matching a java member declaration or definition. | |
| 915 Member modifier keywords are grouped expression 'java-feature-mode-grpn'. | |
| 916 Member type is grouped expression 'java-feature-type-grpn'. Member name is | |
| 917 group 'java-feature-name-grpn'. Function parentheses, if any, are group | |
| 918 'java-feature-parens-grpn'. Comma separated list of exceptions that can be | |
| 919 thrown by a function are group 'java-feature-exceptions-grpn'.") | |
| 920 | |
| 921 (defconst java-feature-mod-grpn 2) | |
| 922 (defconst java-feature-type-grpn 5) | |
| 923 (defconst java-feature-name-grpn 9) | |
| 924 (defconst java-feature-parens-grpn 11) | |
| 925 (defconst java-feature-exceptions-grpn 14) | |
| 926 | |
| 927 (defconst java-at-feature-regexp | |
| 928 (concat java-feature-decl-or-def "[ \t\n]*") | |
| 929 "See documentation of 'java-feature-decl-or-def' for grouping expressions.") | |
| 930 | |
| 931 (defconst java-feature-decl | |
| 932 (concat java-at-feature-regexp "[;{]") | |
| 933 "See documentation of 'java-feature-decl-or-def' for grouping expressions.") | |
| 934 | |
| 935 (defconst java-routine-def-terminator-regexp | |
| 936 ;; Also matches to abstract method declarations. | |
| 937 ;; Only native and abstract functions end with a semi-colon. | |
| 938 "\\({\\|;\\)") | |
| 939 | |
| 940 (defconst java-routine-def | |
| 941 (concat java-at-feature-regexp java-routine-def-terminator-regexp) | |
| 942 "See documentation of 'java-feature-decl-or-def' for grouping expressions.") | |
| 943 | |
| 944 (defconst java-class-decl | |
| 945 (concat java-class-modifier-keyword | |
| 946 java-class-keyword java-identifier "[ \t]*[;,]") | |
| 947 "Regexp matching a java class declaration. | |
| 948 Class name is grouping 'java-class-name-grpn'.") | |
| 949 | |
| 950 (defconst java-class-name-grpn 4) | |
| 951 | |
| 952 ;; Old def was: "\\(^\\|[ \t\n\^M]\\)abstract[ \t\n\^M][^;{}]+;" | |
| 953 (defconst java-abstract-method-regexp ";\\'" | |
| 954 "Regexp matching a Java abstract method signature.") | |
| 955 | |
| 956 (defconst java-native-method-regexp "\\(^\\|[ \t\n\^M]\\)native[ \t\n\^M][^;{}]+;" | |
| 957 "Regexp matching a Java native method signature, one implemented in another language.") | |
| 958 | |
| 959 (provide 'br-java-ft) |