Enhance Java Mode to handle Java 5.0 (Tiger) and Java 6 (Mustang).

Contributed by Nathaniel Flath.

6 files changed, 248 insertions, 170 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 009eb0712c1..cba5e645f56 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,29 @@
+2010-07-31  Alan Mackenzie  <acm@muc.de>
+        Enhanced Java Mode to handle Java 5.0 (Tiger) and Java 6
+        (Mustang).  Contributed by Nathaniel Flath.  The following
+        functions were modified or created:
+
+        * progmodes/cc-vars.el (c-offsets-alist, c-inside-block-syms)
+        (objc-font-lock-extra-types):
+
+        * progmodes/cc-mode.el (c-basic-common-init):
+
+        * progmodes/cc-langs.el (c-make-mode-syntax-table)
+        (c++-make-template-syntax-table)
+        (c-identifier-syntax-modifications, c-symbol-start, c-operators)
+        (c-<-op-cont-regexp, c->-op-cont-regexp, c-class-decl-kwds)
+        (c-brace-list-decl-kwds, c-modifier-kwds, c-prefix-spec-kwds-re)
+        (c-type-list-kwds, c-decl-prefix-re, c-opt-type-suffix-key):
+
+
+        * progmodes/cc-fonts.el (c-make-inverse-face)
+        (c-basic-matchers-after):
+
+        * progmodes/cc-engine.el (c-forward-keyword-clause)
+        (c-forward-<>-arglist, c-forward-<>-arglist-recur)
+        (c-forward-name, c-forward-type, c-forward-decl-or-cast-1)
+        (c-guess-continued-construct, c-guess-basic-syntax):
+
 2010-07-31  Jan Djärv  <jan.h.d@swipnet.se>
 
         * faces.el (face-all-attributes): Improved documentation (Bug#6767).
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 9bbf82a0449..d87db0fe8b3 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -5401,6 +5401,7 @@ comment at the start of cc-engine.el for more info."
                   ;; `nconc' doesn't mind that the tail of
                   ;; `c-record-found-types' is t.
                   (nconc c-record-found-types c-record-type-identifiers)))
+            (if (c-major-mode-is 'java-mode) (c-fontify-recorded-types-and-refs))
           t)
 
       (goto-char start)
@@ -5420,7 +5421,6 @@ comment at the start of cc-engine.el for more info."
         ;; List that collects the positions after the argument
         ;; separating ',' in the arglist.
         arg-start-pos)
-
     ;; If the '<' has paren open syntax then we've marked it as an angle
     ;; bracket arglist before, so skip to the end.
     (if (and (not c-parse-and-markup-<>-arglists)
@@ -5431,7 +5431,6 @@ comment at the start of cc-engine.el for more info."
           (if (and (c-go-up-list-forward)
                    (eq (char-before) ?>))
               t
-
             ;; Got unmatched paren angle brackets.  We don't clear the paren
             ;; syntax properties and retry, on the basis that it's very
             ;; unlikely that paren angle brackets become operators by code
@@ -5441,70 +5440,51 @@ comment at the start of cc-engine.el for more info."
             nil))
 
       (forward-char)
+
       (unless (looking-at c-<-op-cont-regexp)
-        (while (and
+                (while (and
                 (progn
+                      (c-forward-syntactic-ws)
+                 (let ((orig-record-found-types c-record-found-types))
+                   (when (or (and c-record-type-identifiers all-types)
+                             (c-major-mode-is 'java-mode))
+                     ;; All encountered identifiers are types, so set the
+                     ;; promote flag and parse the type.
+                     (progn
+                       (c-forward-syntactic-ws)
+                       (if (looking-at "\\?")
+                           (forward-char)
+                         (when (looking-at c-identifier-start)
+                           (let ((c-promote-possible-types t)
+                                 (c-record-found-types t))
+                             (c-forward-type))))
 
-                  (when c-record-type-identifiers
-                    (if all-types
-
-                        ;; All encountered identifiers are types, so set the
-                        ;; promote flag and parse the type.
-                        (progn
-                          (c-forward-syntactic-ws)
-                          (when (looking-at c-identifier-start)
-                            (let ((c-promote-possible-types t))
-                              (c-forward-type))))
-
-                      ;; Check if this arglist argument is a sole type.  If
-                      ;; it's known then it's recorded in
-                      ;; `c-record-type-identifiers'.  If it only is found
-                      ;; then it's recorded in `c-record-found-types' which we
-                      ;; might roll back if it turns out that this isn't an
-                      ;; angle bracket arglist afterall.
-                      (when (memq (char-before) '(?, ?<))
-                        (let ((orig-record-found-types c-record-found-types))
-                          (c-forward-syntactic-ws)
-                          (and (memq (c-forward-type) '(known found))
-                               (not (looking-at "[,>]"))
-                               ;; A found type was recorded but it's not the
-                               ;; only thing in the arglist argument, so reset
-                               ;; `c-record-found-types'.
-                               (setq c-record-found-types
-                                     orig-record-found-types))))))
+                     (c-forward-syntactic-ws)
 
-                  (setq pos (point))
-                  (or (when (eq (char-after) ?>)
-                        ;; Must check for '>' at the very start separately,
-                        ;; since the regexp below has to avoid ">>" without
-                        ;; using \\=.
-                        (forward-char)
-                        t)
-
-                      ;; Note: These regexps exploit the match order in \| so
-                      ;; that "<>" is matched by "<" rather than "[^>:-]>".
-                      (c-syntactic-re-search-forward
-                       (if c-restricted-<>-arglists
-                           ;; Stop on ',', '|', '&', '+' and '-' to catch
-                           ;; common binary operators that could be between
-                           ;; two comparison expressions "a<b" and "c>d".
-                           "[<;{},|&+-]\\|\\([^>:-]>\\)"
-                         ;; Otherwise we still stop on ',' to find the
-                         ;; argument start positions.
-                         "[<;{},]\\|\\([^>:-]>\\)")
-                       nil 'move t t 1)
-
-                      ;; If the arglist starter has lost its open paren
-                      ;; syntax but not the closer, we won't find the
-                      ;; closer above since we only search in the
-                      ;; balanced sexp.  In that case we stop just short
-                      ;; of it so check if the following char is the closer.
-                      (when (eq (char-after) ?>)
-                        (forward-char)
-                        t)))
+                     (when (or (looking-at "extends")
+                               (looking-at "super"))
+                       (forward-word)
+                       (c-forward-syntactic-ws)
+                       (let ((c-promote-possible-types t)
+                            (c-record-found-types t))
+                         (c-forward-type)
+                         (c-forward-syntactic-ws))))))
+
+                      (setq pos (point))
+
+                      (or
+                       ;; Note: These regexps exploit the match order in \| so
+                       ;; that "<>" is matched by "<" rather than "[^>:-]>".
+                       (c-syntactic-re-search-forward
+                        ;; Stop on ',', '|', '&', '+' and '-' to catch
+                        ;; common binary operators that could be between
+                        ;; two comparison expressions "a<b" and "c>d".
+                        "[<;{},|+&-]\\|[>)]"
+                        nil t t)
+                       t))
 
-                (cond
-                 ((eq (char-before) ?>)
+                    (cond
+                     ((eq (char-before) ?>)
                   ;; Either an operator starting with '>' or the end of
                   ;; the angle bracket arglist.
 
@@ -5526,7 +5506,6 @@ comment at the start of cc-engine.el for more info."
 
                  ((eq (char-before) ?<)
                   ;; Either an operator starting with '<' or a nested arglist.
-
                   (setq pos (point))
                   (let (id-start id-end subres keyword-match)
                     (if (if (looking-at c-<-op-cont-regexp)
@@ -5546,14 +5525,14 @@ comment at the start of cc-engine.el for more info."
                               (when (or (setq keyword-match
                                               (looking-at c-opt-<>-sexp-key))
                                         (not (looking-at c-keywords-regexp)))
-                                (setq id-start (point))))
-
-                            (setq subres
-                                  (let ((c-record-type-identifiers nil)
-                                        (c-record-found-types nil))
-                                    (c-forward-<>-arglist-recur
-                                     (and keyword-match
-                                          (c-keyword-member
+                                    (setq id-start (point))))
+
+                                (setq subres
+                                      (let ((c-promote-possible-types t)
+                                            (c-record-found-types t))
+                                        (c-forward-<>-arglist-recur
+                                         (and keyword-match
+                                              (c-keyword-member
                                            (c-keyword-sym (match-string 1))
                                            'c-<>-type-kwds)))))
                             )))
@@ -5574,14 +5553,16 @@ comment at the start of cc-engine.el for more info."
                                    (c-forward-syntactic-ws)
                                    (looking-at c-opt-identifier-concat-key)))
                             (c-record-ref-id (cons id-start id-end))
-                          (c-record-type-id (cons id-start id-end))))))
-                  t)
-
-                 ((and (eq (char-before) ?,)
-                       (not c-restricted-<>-arglists))
-                  ;; Just another argument.  Record the position.  The
-                  ;; type check stuff that made us stop at it is at
-                  ;; the top of the loop.
+                              (c-record-type-id (cons id-start id-end))))))
+                      t)
+
+                ((and (not c-restricted-<>-arglists)
+                      (or (and (eq (char-before) ?&)
+                               (not (eq (char-after) ?&)))
+                          (eq (char-before) ?,)))
+                      ;; Just another argument.  Record the position.  The
+                      ;; type check stuff that made us stop at it is at
+                      ;; the top of the loop.
                   (setq arg-start-pos (cons (point) arg-start-pos)))
 
                  (t
@@ -5590,7 +5571,6 @@ comment at the start of cc-engine.el for more info."
                   ;; it's useless to try to find a surrounding arglist
                   ;; if we're nested.
                   (throw 'angle-bracket-arglist-escape nil))))))
-
       (if res
           (or c-record-found-types t)))))
 
@@ -5793,9 +5773,8 @@ comment at the start of cc-engine.el for more info."
               ((and c-recognize-<>-arglists
                     (eq (char-after) ?<))
                ;; Maybe an angle bracket arglist.
-
-               (when (let (c-record-type-identifiers
-                           c-record-found-types)
+               (when (let ((c-record-type-identifiers t)
+                           (c-record-found-types t))
                        (c-forward-<>-arglist nil))
 
                  (c-add-type start (1+ pos))
@@ -5844,6 +5823,9 @@ comment at the start of cc-engine.el for more info."
   ;; `c-record-type-identifiers' is non-nil.
   ;;
   ;; This function might do hidden buffer changes.
+  (when (looking-at "<")
+    (c-forward-<>-arglist t)
+    (c-forward-syntactic-ws))
 
   (let ((start (point)) pos res name-res id-start id-end id-range)
 
@@ -6043,6 +6025,18 @@ comment at the start of cc-engine.el for more info."
 
     res))
 
+(defun c-forward-annotation ()
+  ;; Used for Java code only at the moment.  Assumes point is on the
+  ;; @, moves forward an annotation.  returns nil if there is no
+  ;; annotation at point.
+  (and (looking-at "@")
+       (progn (forward-char) t)
+       (c-forward-type)
+       (progn (c-forward-syntactic-ws) t)
+       (if (looking-at "(")
+           (c-go-list-forward)
+         t)))
+
 
 ;; Handling of large scale constructs like statements and declarations.
 
@@ -6212,6 +6206,9 @@ comment at the start of cc-engine.el for more info."
         (save-rec-type-ids c-record-type-identifiers)
         (save-rec-ref-ids c-record-ref-identifiers))
 
+    (while (c-forward-annotation)
+      (c-forward-syntactic-ws))
+
     ;; Check for a type.  Unknown symbols are treated as possible
     ;; types, but they could also be specifiers disguised through
     ;; macros like __INLINE__, so we recognize both types and known
@@ -6545,13 +6542,14 @@ comment at the start of cc-engine.el for more info."
                 ;; CASE 3
                 (when (= (point) start)
                   ;; Got a plain list of identifiers.  If a colon follows it's
-                  ;; a valid label.  Otherwise the last one probably is the
-                  ;; declared identifier and we should back up to the previous
-                  ;; type, providing it isn't a cast.
-                  (if (eq (char-after) ?:)
-                      ;; If we've found a specifier keyword then it's a
-                      ;; declaration regardless.
-                      (throw 'at-decl-or-cast (eq at-decl-or-cast t))
+                   ;; a valid label.  Otherwise the last one probably is the
+                   ;; declared identifier and we should back up to the previous
+                   ;; type, providing it isn't a cast.
+                   (if (and (eq (char-after) ?:)
+                            (not (c-major-mode-is 'java-mode)))
+                       ;; If we've found a specifier keyword then it's a
+                       ;; declaration regardless.
+                       (throw 'at-decl-or-cast (eq at-decl-or-cast t))
                     (setq backup-if-not-cast t)
                     (throw 'at-decl-or-cast t)))
 
@@ -8512,7 +8510,7 @@ comment at the start of cc-engine.el for more info."
   ;;
   ;; This function might do hidden buffer changes.
 
-  (let (special-brace-list)
+  (let (special-brace-list placeholder)
     (goto-char indent-point)
     (skip-chars-forward " \t")
 
@@ -8619,6 +8617,22 @@ comment at the start of cc-engine.el for more info."
       (c-add-stmt-syntax 'func-decl-cont nil t
                          containing-sexp paren-state))
 
+     ;;CASE F: continued statement and the only preceding items are
+     ;;annotations.
+     ((and (c-major-mode-is 'java-mode)
+           (setq placeholder (point))
+            (c-beginning-of-statement-1)
+            (progn
+              (while (and (c-forward-annotation)
+                          (< (point) placeholder))
+                (c-forward-syntactic-ws))
+              t)
+            (prog1
+                (>= (point) placeholder)
+              (goto-char placeholder)))
+       (c-beginning-of-statement-1 containing-sexp)
+       (c-add-syntax 'annotation-var-cont (point)))
+
      ;; CASE D: continued statement.
      (t
       (c-beginning-of-statement-1 containing-sexp)
@@ -8718,7 +8732,6 @@ comment at the start of cc-engine.el for more info."
         (when (and containing-sexp
                    (eq (char-after containing-sexp) ?\())
           (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
-
         ;; cache char before and after indent point, and move point to
         ;; the most likely position to perform the majority of tests
         (goto-char indent-point)
@@ -9468,23 +9481,36 @@ comment at the start of cc-engine.el for more info."
             (c-add-syntax 'objc-method-args-cont placeholder))
 
            ;; CASE 5L: we are at the first argument of a template
-           ;; arglist that begins on the previous line.
-           ((and c-recognize-<>-arglists
-                 (eq (char-before) ?<)
-                 (setq placeholder (1- (point)))
-                 (not (and c-overloadable-operators-regexp
-                           (c-after-special-operator-id lim))))
-            (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
-            (c-add-syntax 'template-args-cont (c-point 'boi) placeholder))
-
-           ;; CASE 5Q: we are at a statement within a macro.
-           (macro-start
-            (c-beginning-of-statement-1 containing-sexp)
-            (c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
-
-           ;; CASE 5M: we are at a topmost continuation line
-           (t
-            (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
+         ;; arglist that begins on the previous line.
+         ((and c-recognize-<>-arglists
+               (eq (char-before) ?<)
+               (not (and c-overloadable-operators-regexp
+                         (c-after-special-operator-id lim))))
+          (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
+          (c-add-syntax 'template-args-cont (c-point 'boi)))
+
+         ;; CASE 5Q: we are at a statement within a macro.
+         (macro-start
+          (c-beginning-of-statement-1 containing-sexp)
+          (c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
+
+     ;;CASE 5N: We are at a tompmost continuation line and the only
+     ;;preceding items are annotations.
+         ((and (c-major-mode-is 'java-mode)
+               (setq placeholder (point))
+           (c-beginning-of-statement-1)
+           (progn
+                 (while (and (c-forward-annotation))
+               (c-forward-syntactic-ws))
+             t)
+           (prog1
+             (>= (point) placeholder)
+             (goto-char placeholder)))
+      (c-add-syntax 'annotation-top-cont (c-point 'boi)))
+
+         ;; CASE 5M: we are at a topmost continuation line
+         (t
+          (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
             (when (c-major-mode-is 'objc-mode)
               (setq placeholder (point))
               (while (and (c-forward-objc-directive)
@@ -9495,43 +9521,20 @@ comment at the start of cc-engine.el for more info."
             (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
            ))
 
-         ;; (CASE 6 has been removed.)
 
-         ;; CASE 19: line is an expression, not a statement, and is directly
-         ;; contained by a template delimiter.  Most likely, we are in a
-         ;; template arglist within a statement.  This case is based on CASE
-         ;; 7.  At some point in the future, we may wish to create more
-         ;; syntactic symbols such as `template-intro',
-         ;; `template-cont-nonempty', etc., and distinguish between them as we
-         ;; do for `arglist-intro' etc. (2009-12-07).
-         ((and c-recognize-<>-arglists
-               (setq containing-< (c-up-list-backward indent-point containing-sexp))
-               (eq (char-after containing-<) ?\<))
-          (setq placeholder (c-point 'boi containing-<))
-          (goto-char containing-sexp)   ; Most nested Lbrace/Lparen (but not
-                                        ; '<') before indent-point.
-          (if (>= (point) placeholder)
-              (progn
-                (forward-char)
-                (skip-chars-forward " \t"))
-            (goto-char placeholder))
-          (c-add-stmt-syntax 'template-args-cont (list containing-<) t
-                             (c-most-enclosing-brace c-state-cache (point))
-                             paren-state))
-                             
+       ;; (CASE 6 has been removed.)
 
-         ;; CASE 7: line is an expression, not a statement.  Most
-         ;; likely we are either in a function prototype or a function
-         ;; call argument list, or a template argument list.
-         ((not (or (and c-special-brace-lists
-                        (save-excursion
-                          (goto-char containing-sexp)
-                          (c-looking-at-special-brace-list)))
-                   (eq (char-after containing-sexp) ?{)
-                   (eq (char-after containing-sexp) ?<)))
-          (cond
+       ;; CASE 7: line is an expression, not a statement.  Most
+       ;; likely we are either in a function prototype or a function
+       ;; call argument list
+       ((not (or (and c-special-brace-lists
+                      (save-excursion
+                        (goto-char containing-sexp)
+                        (c-looking-at-special-brace-list)))
+                 (eq (char-after containing-sexp) ?{)))
+        (cond
 
-           ;; CASE 7A: we are looking at the arglist closing paren.
+         ;; CASE 7A: we are looking at the arglist closing paren.
            ;; C.f. case 7F.
            ((memq char-after-ip '(?\) ?\]))
             (goto-char containing-sexp)
@@ -9543,12 +9546,34 @@ comment at the start of cc-engine.el for more info."
                   (skip-chars-forward " \t"))
               (goto-char placeholder))
             (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
-                               (c-most-enclosing-brace paren-state (point))
-                               paren-state))
+                             (c-most-enclosing-brace paren-state (point))
+                             paren-state))
 
-           ;; CASE 7B: Looking at the opening brace of an
-           ;; in-expression block or brace list.  C.f. cases 4, 16A
-           ;; and 17E.
+        ;; CASE 19: line is an expression, not a statement, and is directly
+        ;; contained by a template delimiter.   Most likely, we are in a
+        ;; template arglist within a statement.  This case is based on CASE
+        ;; 7.   At some point in the future, we may wish to create more
+        ;; syntactic symbols such as `template-intro',
+        ;; `template-cont-nonempty', etc., and distinguish between them as we
+        ;; do for `arglist-intro' etc. (2009-12-07).
+        ((and c-recognize-<>-arglists
+             (setq containing-< (c-up-list-backward indent-point containing-sexp))
+             (eq (char-after containing-<) ?\<))
+        (setq placeholder (c-point 'boi containing-<))
+        (goto-char containing-sexp)     ; Most nested Lbrace/Lparen (but not
+                                        ; '<') before indent-point.
+        (if (>= (point) placeholder)
+            (progn
+              (forward-char)
+              (skip-chars-forward " \t"))
+          (goto-char placeholder))
+        (c-add-stmt-syntax 'template-args-cont (list containing-<) t
+                           (c-most-enclosing-brace c-state-cache (point))
+                           paren-state))
+
+         ;; CASE 7B: Looking at the opening brace of an
+         ;; in-expression block or brace list.  C.f. cases 4, 16A
+         ;; and 17E.
            ((and (eq char-after-ip ?{)
                  (progn
                    (setq placeholder (c-inside-bracelist-p (point)
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 907c308daca..219eb25368c 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -194,6 +194,10 @@
          (unless (face-property-instance oldface 'reverse)
            (invert-face newface)))))
 
+(defvar c-annotation-face (make-face 'c-annotation-face)
+  "Face used to highlight annotations in java-mode and other modes that may wish to use it.")
+(set-face-foreground 'c-annotation-face "blue")
+
 (eval-and-compile
   ;; We need the following functions during compilation since they're
   ;; called when the `c-lang-defconst' initializers are evaluated.
@@ -1538,6 +1542,9 @@ higher."
                '((c-fontify-types-and-refs ((c-promote-possible-types t))
                    (c-forward-keyword-clause 1)
                    (if (> (point) limit) (goto-char limit))))))))
+
+      ,@(when (c-major-mode-is 'java-mode)
+          `((eval . (list "\\<\\(@[a-zA-Z0-9]+\\)\\>" 1 c-annotation-face))))
       ))
 
 (c-lang-defconst c-matchers-1
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index d3669f259de..ae0ed1b928a 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -359,7 +359,7 @@ The syntax tables aren't stored directly since they're quite large."
        (let ((table (make-syntax-table)))
          (c-populate-syntax-table table)
          ;; Mode specific syntaxes.
-         ,(cond ((c-major-mode-is 'objc-mode)
+         ,(cond ((or (c-major-mode-is 'objc-mode) (c-major-mode-is 'java-mode))
                  ;; Let '@' be part of symbols in ObjC to cope with
                  ;; its compiler directives as single keyword tokens.
                  ;; This is then necessary since it's assumed that
@@ -382,7 +382,7 @@ The syntax tables aren't stored directly since they're quite large."
   ;; '<' and '>' characters.  Therefore this syntax table might go
   ;; away when CC Mode handles templates correctly everywhere.
   t   nil
-  c++ `(lambda ()
+  (java c++) `(lambda ()
          (let ((table (funcall ,(c-lang-const c-make-mode-syntax-table))))
            (modify-syntax-entry ?< "(>" table)
            (modify-syntax-entry ?> ")<" table)
@@ -425,7 +425,7 @@ the new syntax, as accepted by `modify-syntax-entry'."
   ;; it as an indentifier character since it's often used in various
   ;; machine generated identifiers.
   t    '((?_ . "w") (?$ . "w"))
-  objc (append '((?@ . "w"))
+  (objc java) (append '((?@ . "w"))
                (c-lang-const c-identifier-syntax-modifications))
   awk  '((?_ . "w")))
 (c-lang-defvar c-identifier-syntax-modifications
@@ -502,9 +502,10 @@ parameters \(point-min), \(point-max) and <buffer size>."
 
 (c-lang-defconst c-symbol-start
   "Regexp that matches the start of a symbol, i.e. any identifier or
-keyword.  It's unspecified how far it matches.  Does not contain a \\|
+keyword.  It's unspecified how far it matches.  Does not contain a \\|
 operator at the top level."
   t    (concat "[" c-alpha "_]")
+  java (concat "[" c-alpha "_@]")
   objc (concat "[" c-alpha "@]")
   pike (concat "[" c-alpha "_`]"))
 (c-lang-defvar c-symbol-start (c-lang-const c-symbol-start))
@@ -859,7 +860,7 @@ since CC Mode treats every identifier as an expression."
 
       ;; Primary.
       ,@(c-lang-const c-identifier-ops)
-      ,@(cond ((c-major-mode-is 'c++-mode)
+      ,@(cond ((or (c-major-mode-is 'c++-mode) (c-major-mode-is 'java-mode))
                `((postfix-if-paren "<" ">"))) ; Templates.
               ((c-major-mode-is 'pike-mode)
                `((prefix "global" "predef")))
@@ -1118,6 +1119,7 @@ operators."
                     t
                     "\\`<."
                     (lambda (op) (substring op 1)))))
+
 (c-lang-defvar c-<-op-cont-regexp (c-lang-const c-<-op-cont-regexp))
 
 (c-lang-defconst c->-op-cont-regexp
@@ -1127,7 +1129,13 @@ operators."
       (c-filter-ops (c-lang-const c-all-op-syntax-tokens)
                     t
                     "\\`>."
-                    (lambda (op) (substring op 1)))))
+                    (lambda (op) (substring op 1))))
+  java (c-make-keywords-re nil
+         (c-filter-ops (c-lang-const c-all-op-syntax-tokens)
+                       t
+                       "\\`>[^>]\\|\\`>>[^>]"
+                       (lambda (op) (substring op 1)))))
+
 (c-lang-defvar c->-op-cont-regexp (c-lang-const c->-op-cont-regexp))
 
 (c-lang-defconst c-stmt-delim-chars
@@ -1628,7 +1636,7 @@ following identifier as a type; the keyword must also be present on
   c++  '("class" "struct" "union")
   objc '("struct" "union"
          "@interface" "@implementation" "@protocol")
-  java '("class" "interface")
+  java '("class" "@interface" "interface")
   idl  '("component" "eventtype" "exception" "home" "interface" "struct"
          "union" "valuetype"
          ;; In CORBA PSDL:
@@ -1651,7 +1659,7 @@ If any of these also are on `c-type-list-kwds', `c-ref-list-kwds',
 `c-<>-type-kwds', or `c-<>-arglist-kwds' then the associated clauses
 will be handled."
   t    '("enum")
-  (java awk) nil)
+  (awk) nil)
 
 (c-lang-defconst c-brace-list-key
   ;; Regexp matching the start of declarations where the following
@@ -1772,7 +1780,7 @@ will be handled."
          "bindsTo" "delegatesTo" "implements" "proxy" "storedOn")
   ;; Note: "const" is not used in Java, but it's still a reserved keyword.
   java '("abstract" "const" "final" "native" "private" "protected" "public"
-         "static" "strictfp" "synchronized" "transient" "volatile")
+         "static" "strictfp" "synchronized" "transient" "volatile" "@[A-Za-z0-9]+")
   pike '("final" "inline" "local" "nomask" "optional" "private" "protected"
          "public" "static" "variant"))
 
@@ -1858,7 +1866,11 @@ one of `c-type-list-kwds', `c-ref-list-kwds',
 
 (c-lang-defconst c-prefix-spec-kwds-re
   ;; Adorned regexp of `c-prefix-spec-kwds'.
-  t (c-make-keywords-re t (c-lang-const c-prefix-spec-kwds)))
+  t (c-make-keywords-re t (c-lang-const c-prefix-spec-kwds))
+  java (replace-regexp-in-string
+     "\\\\\\[" "["
+     (replace-regexp-in-string "\\\\\\+" "+" (c-make-keywords-re t (c-lang-const c-prefix-spec-kwds)))))
+
 (c-lang-defvar c-prefix-spec-kwds-re (c-lang-const c-prefix-spec-kwds-re))
 
 (c-lang-defconst c-specifier-key
@@ -1950,7 +1962,7 @@ or variable identifier (that's being defined)."
   t    nil
   c++  '("operator")
   objc '("@class")
-  java '("import" "new" "extends" "implements" "throws")
+  java '("import" "new" "extends" "super" "implements" "throws")
   idl  '("manages" "native" "primarykey" "supports"
          ;; In CORBA PSDL:
          "as" "implements" "of" "scope")
@@ -2499,7 +2511,7 @@ more info."
   ;; in all languages except Java for when a cpp macro definition
   ;; begins with a declaration.
   t "\\([\{\}\(\);,]+\\)"
-  java "\\([\{\}\(;,]+\\)"
+  java "\\([\{\}\(;,<]+\\)"
   ;; Match "<" in C++ to get the first argument in a template arglist.
   ;; In that case there's an additional check in `c-find-decl-spots'
   ;; that it got open paren syntax.
@@ -2759,7 +2771,7 @@ It's undefined whether identifier syntax (see `c-identifier-syntax-table')
 is in effect or not."
   t nil
   (c c++ objc pike) "\\(\\.\\.\\.\\)"
-  java (concat "\\(\\[" (c-lang-const c-simple-ws) "*\\]\\)"))
+  java (concat "\\(\\[" (c-lang-const c-simple-ws) "*\\]\\|\\.\\.\\.\\)"))
 (c-lang-defvar c-opt-type-suffix-key (c-lang-const c-opt-type-suffix-key))
 
 (c-lang-defvar c-known-type-key
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 070d044c199..f9917ce406e 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -522,7 +522,7 @@ that requires a literal mode spec at compile time."
 
   (when (or c-recognize-<>-arglists
             (c-major-mode-is 'awk-mode)
-            (c-major-mode-is '(c-mode c++-mode objc-mode)))
+            (c-major-mode-is '(java-mode c-mode c++-mode objc-mode)))
     ;; We'll use the syntax-table text property to change the syntax
     ;; of some chars for this language, so do the necessary setup for
     ;; that.
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 82015687cb2..f61c2a9fd06 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1056,9 +1056,13 @@ can always override the use of `c-default-style' by making calls to
        ;; Anchor pos: Boi at the topmost intro line.
        (knr-argdecl           . 0)
        ;; Anchor pos: At the beginning of the first K&R argdecl.
-       (topmost-intro         . 0)
+       (topmost-intro         . 0)
        ;; Anchor pos: Bol at the last line of previous construct.
        (topmost-intro-cont    . c-lineup-topmost-intro-cont)
+       ;;Anchor pos: Bol at the topmost annotation line
+       (annotation-top-cont   .   0)
+       ;;Anchor pos: Bol at the topmost annotation line
+       (annotation-var-cont   .   +)
        ;; Anchor pos: Boi at the topmost intro line.
        (member-init-intro     . +)
        ;; Anchor pos: Boi at the func decl arglist open.
@@ -1285,12 +1289,16 @@ Here is the current list of valid syntactic element symbols:
                            between them; in C++ and Java, throws declarations
                            and other things can appear in this context.
  knr-argdecl-intro      -- First line of a K&R C argument declaration.
- knr-argdecl            -- Subsequent lines in a K&R C argument declaration.
- topmost-intro          -- The first line in a topmost construct definition.
- topmost-intro-cont     -- Topmost definition continuation lines.
- member-init-intro      -- First line in a member initialization list.
- member-init-cont       -- Subsequent member initialization list lines.
- inher-intro            -- First line of a multiple inheritance list.
+ knr-argdecl            -- Subsequent lines in a K&R C argument declaration.
+ topmost-intro          -- The first line in a topmost construct definition.
+ topmost-intro-cont     -- Topmost definition continuation lines.
+ annotation-top-cont    -- Topmost definition continuation line where only
+                           annotations are on previous lines.
+ annotation-var-cont    -- A continuation of a C (or like) statement where
+                           only annotations are on previous lines.
+ member-init-intro      -- First line in a member initialization list.
+ member-init-cont       -- Subsequent member initialization list lines.
+ inher-intro            -- First line of a multiple inheritance list.
  inher-cont             -- Subsequent multiple inheritance lines.
  block-open             -- Statement block open brace.
  block-close            -- Statement block close brace.
@@ -1376,7 +1384,7 @@ Here is the current list of valid syntactic element symbols:
   '(defun-block-intro block-open block-close statement statement-cont
     statement-block-intro statement-case-intro statement-case-open
     substatement substatement-open substatement-label case-label label
-    do-while-closure else-clause catch-clause inlambda))
+    do-while-closure else-clause catch-clause inlambda annotation-var-cont))
 
 (defcustom c-style-variables-are-local-p t
   "*Whether style variables should be buffer local by default.
@@ -1577,7 +1585,7 @@ names)."))
   :group 'c)
 
 (defcustom java-font-lock-extra-types
-  (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*"))
+  (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw"))
   (c-make-font-lock-extra-types-blurb "Java" "java-mode" (concat
 "For example, a value of (\"[" c-upper "]\\\\sw*[" c-lower "]\\\\sw*\") means
 capitalized words are treated as type names (the requirement for a