Merge from trunk.

7 files changed, 211 insertions, 78 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 0d88f85d263..a1cbdc16560 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6325,7 +6325,9 @@ comment at the start of cc-engine.el for more info."
         (let* ((start (point)) kwd-sym kwd-clause-end found-type)
 
           ;; Look for a specifier keyword clause.
-          (when (looking-at c-prefix-spec-kwds-re)
+          (when (or (looking-at c-prefix-spec-kwds-re)
+                    (and (c-major-mode-is 'java-mode)
+                         (looking-at "@[A-Za-z0-9]+")))
             (if (looking-at c-typedef-key)
                 (setq at-typedef t))
             (setq kwd-sym (c-keyword-sym (match-string 1)))
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 2277ba760ab..3d5dc30d823 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -199,10 +199,16 @@
 (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.
-  ;; Define them at runtime too for the sake of derived modes.
-
+  ;; We need the following definitions during compilation since they're
+  ;; used when the `c-lang-defconst' initializers are evaluated.  Define
+  ;; them at runtime too for the sake of derived modes.
+
+  ;; This indicates the "font locking context", and is set just before
+  ;; fontification is done.  If non-nil, it says, e.g., point starts
+  ;; from within a #if preprocessor construct.
+  (defvar c-font-lock-context nil)
+  (make-variable-buffer-local 'c-font-lock-context)
+  
   (defmacro c-put-font-lock-face (from to face)
     ;; Put a face on a region (overriding any existing face) in the way
     ;; font-lock would do it.  In XEmacs that means putting an
@@ -283,6 +289,45 @@
                               nil)))))
           res))))
 
+  (defun c-make-font-lock-search-form (regexp highlights)
+    ;; Return a lisp form which will fontify every occurence of REGEXP
+    ;; (a regular expression, NOT a function) between POINT and `limit'
+    ;; with HIGHLIGHTS, a list of highlighters as specified on page
+    ;; "Search-based Fontification" in the elisp manual.
+    `(while (re-search-forward ,regexp limit t)
+       (unless (progn
+                 (goto-char (match-beginning 0))
+                 (c-skip-comments-and-strings limit))
+         (goto-char (match-end 0))
+         ,@(mapcar
+            (lambda (highlight)
+              (if (integerp (car highlight))
+                  ;; e.g. highlight is (1 font-lock-type-face t)
+                  (progn
+                    (unless (eq (nth 2 highlight) t)
+                      (error
+                       "The override flag must currently be t in %s"
+                       highlight))
+                    (when (nth 3 highlight)
+                      (error
+                       "The laxmatch flag may currently not be set in %s"
+                       highlight))
+                    `(save-match-data
+                       (c-put-font-lock-face
+                        (match-beginning ,(car highlight))
+                        (match-end ,(car highlight))
+                        ,(elt highlight 1))))
+                ;; highlight is an "ANCHORED HIGHLIGHER" of the form
+                ;; (ANCHORED-MATCHER PRE-FORM POST-FORM SUBEXP-HIGHLIGHTERS...)
+                (when (nth 3 highlight)
+                  (error "Match highlights currently not supported in %s"
+                         highlight))
+                `(progn
+                   ,(nth 1 highlight)
+                   (save-match-data ,(car highlight))
+                   ,(nth 2 highlight))))
+            highlights))))
+
   (defun c-make-font-lock-search-function (regexp &rest highlights)
     ;; This function makes a byte compiled function that works much like
     ;; a matcher element in `font-lock-keywords'.  It cuts out a little
@@ -313,43 +358,101 @@
     ;; lambda more easily.
     (byte-compile
      `(lambda (limit)
-        (let (;; The font-lock package in Emacs is known to clobber
+        (let ( ;; The font-lock package in Emacs is known to clobber
               ;; `parse-sexp-lookup-properties' (when it exists).
               (parse-sexp-lookup-properties
                (cc-eval-when-compile
                  (boundp 'parse-sexp-lookup-properties))))
-          (while (re-search-forward ,regexp limit t)
-            (unless (progn
-                      (goto-char (match-beginning 0))
-                      (c-skip-comments-and-strings limit))
-              (goto-char (match-end 0))
-              ,@(mapcar
-                 (lambda (highlight)
-                   (if (integerp (car highlight))
-                       (progn
-                         (unless (eq (nth 2 highlight) t)
-                           (error
-                            "The override flag must currently be t in %s"
-                            highlight))
-                         (when (nth 3 highlight)
-                           (error
-                            "The laxmatch flag may currently not be set in %s"
-                            highlight))
-                         `(save-match-data
-                            (c-put-font-lock-face
-                             (match-beginning ,(car highlight))
-                             (match-end ,(car highlight))
-                             ,(elt highlight 1))))
-                     (when (nth 3 highlight)
-                       (error "Match highlights currently not supported in %s"
-                              highlight))
-                     `(progn
-                        ,(nth 1 highlight)
-                        (save-match-data ,(car highlight))
-                        ,(nth 2 highlight))))
-                 highlights))))
+
+          ;; (while (re-search-forward ,regexp limit t)
+          ;;   (unless (progn
+          ;;          (goto-char (match-beginning 0))
+          ;;          (c-skip-comments-and-strings limit))
+          ;;     (goto-char (match-end 0))
+          ;;     ,@(mapcar
+          ;;     (lambda (highlight)
+          ;;       (if (integerp (car highlight))
+          ;;           (progn
+          ;;             (unless (eq (nth 2 highlight) t)
+          ;;               (error
+          ;;                "The override flag must currently be t in %s"
+          ;;                highlight))
+          ;;             (when (nth 3 highlight)
+          ;;               (error
+          ;;                "The laxmatch flag may currently not be set in %s"
+          ;;                highlight))
+          ;;             `(save-match-data
+          ;;                (c-put-font-lock-face
+          ;;                 (match-beginning ,(car highlight))
+          ;;                 (match-end ,(car highlight))
+          ;;                 ,(elt highlight 1))))
+          ;;         (when (nth 3 highlight)
+          ;;           (error "Match highlights currently not supported in %s"
+          ;;                  highlight))
+          ;;         `(progn
+          ;;            ,(nth 1 highlight)
+          ;;            (save-match-data ,(car highlight))
+          ;;            ,(nth 2 highlight))))
+          ;;     highlights)))
+          ,(c-make-font-lock-search-form regexp highlights))
+
         nil)))
 
+  (defun c-make-font-lock-context-search-function (normal &rest state-stanzas)
+    ;; This function makes a byte compiled function that works much like
+    ;; a matcher element in `font-lock-keywords', with the following
+    ;; enhancement: the generated function will test for particular "font
+    ;; lock contexts" at the start of the region, i.e. is this point in
+    ;; the middle of some particular construct?  if so the generated
+    ;; function will first fontify the tail of the construct, before
+    ;; going into the main loop and fontify full constructs up to limit.
+    ;;
+    ;; The generated function takes one parameter called `limit', and
+    ;; will fontify the region between POINT and LIMIT.
+    ;;
+    ;; NORMAL is a list of the form (REGEXP HIGHLIGHTS .....), and is
+    ;; used to fontify the "regular" bit of the region.
+    ;; STATE-STANZAS is list of elements of the form (STATE LIM REGEXP
+    ;; HIGHLIGHTS), each element coding one possible font lock context.
+
+    ;; o - REGEXP is a font-lock regular expression (NOT a function),
+    ;; o - HIGHLIGHTS is a list of zero or more highlighters as defined
+    ;;   on page "Search-based Fontification" in the elisp manual.  As
+    ;;   yet (2009-06), they must have OVERRIDE set, and may not have
+    ;;   LAXMATCH set.
+    ;;
+    ;; o - STATE is the "font lock context" (e.g. in-cpp-expr) and is
+    ;;   not quoted.
+    ;; o - LIM is a lisp form whose evaluation will yield the limit
+    ;;   position in the buffer for fontification by this stanza.
+    ;;
+    ;; This function does not do any hidden buffer changes, but the
+    ;; generated functions will.  (They are however used in places
+    ;; covered by the font-lock context.)
+    ;; 
+    ;; Note: Replace `byte-compile' with `eval' to debug the generated
+    ;; lambda more easily.
+    (byte-compile
+     `(lambda (limit)
+        (let ( ;; The font-lock package in Emacs is known to clobber
+              ;; `parse-sexp-lookup-properties' (when it exists).
+              (parse-sexp-lookup-properties
+               (cc-eval-when-compile
+                 (boundp 'parse-sexp-lookup-properties))))
+          ,@(mapcar
+             (lambda (stanza)
+               (let ((state (car stanza))
+                     (lim (nth 1 stanza))
+                     (regexp (nth 2 stanza))
+                     (highlights (cdr (cddr stanza))))
+                 `(if (eq c-font-lock-context ',state)
+                      (let ((limit ,lim))
+                        ,(c-make-font-lock-search-form
+                          regexp highlights)))))
+             state-stanzas)
+          ,(c-make-font-lock-search-form (car normal) (cdr normal))
+          nil))))
+
 ;  (eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
 ;    '(progn
   (def-edebug-spec c-fontify-types-and-refs let*)
@@ -494,19 +597,24 @@ stuff.  Used on level 1 and higher."
                                   (c-lang-const c-cpp-expr-directives)))
                         (cef-re (c-make-keywords-re t
                                   (c-lang-const c-cpp-expr-functions))))
-                    `((,(c-make-font-lock-search-function
-                         (concat noncontinued-line-end
-                                 (c-lang-const c-opt-cpp-prefix)
-                                 ced-re ; 1 + ncle-depth
-                                 ;; Match the whole logical line to look
-                                 ;; for the functions in.
-                                 "\\(\\\\\\(.\\|[\n\r]\\)\\|[^\n\r]\\)*")
-                         `((let ((limit (match-end 0)))
-                             (while (re-search-forward ,cef-re limit 'move)
-                               (c-put-font-lock-face (match-beginning 1)
-                                                     (match-end 1)
-                                                     c-preprocessor-face-name)))
-                           (goto-char (match-end ,(1+ ncle-depth)))))))))
+
+                    `((,(c-make-font-lock-context-search-function
+                         `(,(concat noncontinued-line-end
+                                    (c-lang-const c-opt-cpp-prefix)
+                                    ced-re ; 1 + ncle-depth
+                                    ;; Match the whole logical line to look
+                                    ;; for the functions in.
+                                    "\\(\\\\\\(.\\|[\n\r]\\)\\|[^\n\r]\\)*")
+                           ((let ((limit (match-end 0)))
+                              (while (re-search-forward ,cef-re limit 'move)
+                                (c-put-font-lock-face (match-beginning 1)
+                                                      (match-end 1)
+                                                      c-preprocessor-face-name)))
+                            (goto-char (match-end ,(1+ ncle-depth)))))
+                         `(in-cpp-expr
+                           (save-excursion (c-end-of-macro) (point))
+                           ,cef-re
+                           (1 c-preprocessor-face-name t)))))))
 
               ;; Fontify the directive names.
               (,(c-make-font-lock-search-function
@@ -759,6 +867,12 @@ casts and declarations are fontified.  Used on level 2 and higher."
       (c-forward-syntactic-ws limit)
       (c-font-lock-declarators limit t (eq prop 'c-decl-type-start))))
 
+  (setq c-font-lock-context ;; (c-guess-font-lock-context)
+        (save-excursion
+          (if (and c-cpp-expr-intro-re
+                   (c-beginning-of-macro)
+                   (looking-at c-cpp-expr-intro-re))
+              'in-cpp-expr)))
   nil)
 
 (defun c-font-lock-<>-arglists (limit)
@@ -1552,7 +1666,9 @@ on level 2 only and so aren't combined with `c-complex-decl-matchers'."
                         (unless (c-skip-comments-and-strings limit)
                           (c-forward-syntactic-ws)
                           ;; Handle prefix declaration specifiers.
-                          (when (looking-at c-prefix-spec-kwds-re)
+                          (when (or (looking-at c-prefix-spec-kwds-re)
+                                    (and (c-major-mode-is 'java-mode)
+                                         (looking-at "@[A-Za-z0-9]+")))
                             (c-forward-keyword-clause 1))
                           ,(if (c-major-mode-is 'c++-mode)
                                `(when (and (c-forward-type)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 35097242cb7..279c5e46c46 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -815,6 +815,16 @@ expression."
   t (if (c-lang-const c-opt-cpp-prefix)
         '("if" "elif")))
 
+(c-lang-defconst c-cpp-expr-intro-re
+  "Regexp which matches the start of a CPP directive which contains an
+expression, or nil if there aren't any in the language."
+  t (if (c-lang-const c-cpp-expr-directives)
+        (concat
+         (c-lang-const c-opt-cpp-prefix)
+         (c-make-keywords-re t (c-lang-const c-cpp-expr-directives)))))
+(c-lang-defvar c-cpp-expr-intro-re
+  (c-lang-const c-cpp-expr-intro-re))
+
 (c-lang-defconst c-cpp-expr-functions
   "List of functions in cpp expressions."
   t    (if (c-lang-const c-opt-cpp-prefix)
@@ -1813,7 +1823,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" "@[A-Za-z0-9]+")
+         "static" "strictfp" "synchronized" "transient" "volatile")
   pike '("final" "inline" "local" "nomask" "optional" "private" "protected"
          "public" "static" "variant"))
 
@@ -1899,10 +1909,7 @@ 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))
-  java (replace-regexp-in-string
-     "\\\\\\[" "["
-     (replace-regexp-in-string "\\\\\\+" "+" (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)))
 
 (c-lang-defvar c-prefix-spec-kwds-re (c-lang-const c-prefix-spec-kwds-re))
 
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index f3b873c8b1e..79fec080d57 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -145,7 +145,7 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
 
     (ant
      "^[ \t]*\\[[^] \n]+\\][ \t]*\\([^: \n]+\\):\\([0-9]+\\):\\(?:\\([0-9]+\\):\\([0-9]+\\):\\([0-9]+\\):\\)?\
-\\( warning\\)?" 1 (2 . 4) (3 . 5) (4))
+\\( warning\\)?" 1 (2 . 4) (3 . 5) (6))
 
     (bash
      "^\\([^: \n\t]+\\): line \\([0-9]+\\):" 1 2)
@@ -523,7 +523,7 @@ you may also want to change `compilation-page-delimiter'.")
      ;; Command output lines.  Recognize `make[n]:' lines too.
      ("^\\([[:alnum:]_/.+-]+\\)\\(\\[\\([0-9]+\\)\\]\\)?[ \t]*:"
       (1 font-lock-function-name-face) (3 compilation-line-face nil t))
-     (" -\\(?:o[= ]?\\|-\\(?:outfile\\|output\\)[= ]\\)\\(\\S +\\)" . 1)
+     (" --?o\\(?:utfile\\|utput\\)?[= ]\\(\\S +\\)" . 1)
      ("^Compilation \\(finished\\).*"
       (0 '(face nil compilation-message nil help-echo nil mouse-face nil) t)
       (1 compilation-info-face))
@@ -985,12 +985,15 @@ POS and RES.")
             (let* ((prev
                     (or (get-text-property (1- prev-pos) 'compilation-message)
                         (get-text-property prev-pos 'compilation-message)))
-                   (prev-struct
-                    (car (nth 2 (car prev)))))
+                   (prev-file-struct
+                    (and prev
+                         (compilation--loc->file-struct
+                          (compilation--message->loc prev)))))
+
               ;; Construct FILE . DIR from that.
-              (if prev-struct
-                  (setq file (cons (car prev-struct)
-                                   (cadr prev-struct))))))
+              (if prev-file-struct
+                  (setq file (cons (caar prev-file-struct)
+                                   (cadr (car prev-file-struct)))))))
         (unless file
           (setq file '("*unknown*")))))
     ;; All of these fields are optional, get them only if we have an index, and
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index 31100f3fac2..709f01444bf 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -463,9 +463,12 @@ Set up `compilation-exit-message-function' and run `grep-setup-hook'."
   (set (make-local-variable 'compilation-exit-message-function)
        (lambda (status code msg)
          (if (eq status 'exit)
-             (cond ((zerop code)
+             ;; This relies on the fact that `compilation-start'
+             ;; sets buffer-modified to nil before running the command,
+             ;; so the buffer is still unmodified if there is no output.
+             (cond ((and (zerop code) (buffer-modified-p))
                     '("finished (matches found)\n" . "matched"))
-                   ((= code 1)
+                   ((or (= code 1) (not (buffer-modified-p)))
                     '("finished with no matches found\n" . "no match"))
                    (t
                     (cons msg code)))
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index 4151e2bb79a..470b309434c 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -55,24 +55,24 @@
 (defvar scheme-mode-syntax-table
   (let ((st (make-syntax-table))
         (i 0))
-
-    ;; Default is atom-constituent.
-    (while (< i 256)
+    ;; Symbol constituents
+    ;; We used to treat chars 128-256 as symbol-constituent, but they
+    ;; should be valid word constituents (Bug#8843).  Note that valid
+    ;; identifier characters are Scheme-implementation dependent.
+    (while (< i ?0)
       (modify-syntax-entry i "_   " st)
       (setq i (1+ i)))
-
-    ;; Word components.
-    (setq i ?0)
-    (while (<= i ?9)
-      (modify-syntax-entry i "w   " st)
+    (setq i (1+ ?9))
+    (while (< i ?A)
+      (modify-syntax-entry i "_   " st)
       (setq i (1+ i)))
-    (setq i ?A)
-    (while (<= i ?Z)
-      (modify-syntax-entry i "w   " st)
+    (setq i (1+ ?Z))
+    (while (< i ?a)
+      (modify-syntax-entry i "_   " st)
       (setq i (1+ i)))
-    (setq i ?a)
-    (while (<= i ?z)
-      (modify-syntax-entry i "w   " st)
+    (setq i (1+ ?z))
+    (while (< i 128)
+      (modify-syntax-entry i "_   " st)
       (setq i (1+ i)))
 
     ;; Whitespace
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 31a4fbaef4d..7b949134c6c 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -460,6 +460,7 @@ This is buffer-local in every such buffer.")
     (define-key map "\C-c+" 'sh-add)
     (define-key map "\C-\M-x" 'sh-execute-region)
     (define-key map "\C-c\C-x" 'executable-interpret)
+    ;; FIXME: Use post-self-insert-hook.
     (define-key map "<" 'sh-maybe-here-document)
     (define-key map "(" 'skeleton-pair-insert-maybe)
     (define-key map "{" 'skeleton-pair-insert-maybe)
@@ -3659,6 +3660,7 @@ The document is bounded by `sh-here-document-word'."
       (save-excursion
         (backward-char 2)
         (sh-quoted-p))
+      (nth 8 (syntax-ppss))
       (let ((tabs (if (string-match "\\`-" sh-here-document-word)
                       (make-string (/ (current-indentation) tab-width) ?\t)
                     ""))