5 files changed, 197 insertions, 60 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f5aa4df7c2b..66b5369bbba 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -1543,7 +1543,7 @@ comment at the start of cc-engine.el for more info."
 ;;    two newlines with horizontal whitespace between them.
 ;;
 ;;    The reason to include the first following char is to cope with
-;;    "rung positions" that doesn't have any ordinary whitespace.  If
+;;    "rung positions" that don't have any ordinary whitespace.  If
 ;;    `c-is-sws' is put on a token character it does not have
 ;;    `c-in-sws' set simultaneously.  That's the only case when that
 ;;    can occur, and the reason for not extending the `c-in-sws'
@@ -1714,7 +1714,9 @@ comment at the start of cc-engine.el for more info."
     ;; if it's anything that can't start syntactic ws, so we can bail out
     ;; early in the majority of cases when there just are a few ws chars.
     (skip-chars-forward " \t\n\r\f\v")
-    (when (looking-at c-syntactic-ws-start)
+    (when (or (looking-at c-syntactic-ws-start)
+              (and c-opt-cpp-prefix
+                   (looking-at c-noise-macro-name-re)))
 
       (setq rung-end-pos (min (1+ (point)) (point-max)))
       (if (setq rung-is-marked (text-property-any rung-pos rung-end-pos
@@ -1733,6 +1735,10 @@ comment at the start of cc-engine.el for more info."
       (with-silent-modifications
       (while
           (progn
+            ;; In the following while form, we move over a "ladder" and
+            ;; following simple WS each time round the loop, appending the WS
+            ;; onto the ladder, joining adjacent ladders, and terminating when
+            ;; there is no more WS or we reach EOB.
             (while
                 (when (and rung-is-marked
                            (get-text-property (point) 'c-in-sws))
@@ -1776,6 +1782,7 @@ comment at the start of cc-engine.el for more info."
                             (setq rung-pos (point)
                                   last-put-in-sws-pos rung-pos)))
 
+            ;; Now move over any comments (x)or a CPP construct.
             (setq simple-ws-end (point))
             (c-forward-comments)
 
@@ -1801,6 +1808,13 @@ comment at the start of cc-engine.el for more info."
               (forward-line 1)
               (setq safe-start t)
               ;; Don't cache at eob in case the buffer is narrowed.
+              (not (eobp)))
+
+             ((and c-opt-cpp-prefix
+                   (looking-at c-noise-macro-name-re))
+              ;; Skip over a noise macro.
+              (goto-char (match-end 1))
+              (setq safe-start t)
               (not (eobp)))))
 
         ;; We've searched over a piece of non-white syntactic ws.  See if this
@@ -1907,8 +1921,11 @@ comment at the start of cc-engine.el for more info."
     (when (and (not (bobp))
                (save-excursion
                  (backward-char)
-                 (looking-at c-syntactic-ws-end)))
-
+                 (or (looking-at c-syntactic-ws-end)
+                     (and c-opt-cpp-prefix
+                          (looking-at c-symbol-char-key)
+                          (progn (c-beginning-of-current-token)
+                                 (looking-at c-noise-macro-name-re))))))
       ;; Try to find a rung position in the simple ws preceding point, so that
       ;; we can get a cache hit even if the last bit of the simple ws has
       ;; changed recently.
@@ -1927,6 +1944,9 @@ comment at the start of cc-engine.el for more info."
       (with-silent-modifications
       (while
           (progn
+            ;; Each time round the next while form, we move back over a ladder
+            ;; and append any simple WS preceding it, if possible joining with
+            ;; the previous ladder.
             (while
                 (when (and rung-is-marked
                            (not (bobp))
@@ -2035,6 +2055,15 @@ comment at the start of cc-engine.el for more info."
               ;; narrowed out, and we can't risk marking the simple ws
               ;; at the end of it.
               (goto-char next-rung-pos)
+              t)
+
+             ((and c-opt-cpp-prefix
+                   (save-excursion
+                     (and (< (skip-syntax-backward "w_") 0)
+                          (progn (setq next-rung-pos (point))
+                                 (looking-at c-noise-macro-name-re)))))
+              ;; Skipped over a noise macro
+              (goto-char next-rung-pos)
               t)))
 
         ;; We've searched over a piece of non-white syntactic ws.  See if this
@@ -5807,8 +5836,10 @@ comment at the start of cc-engine.el for more info."
                                `(c-forward-type)
                              `(c-forward-name)))
                 nil
-              (and (looking-at c-keywords-regexp)
-                   (c-forward-keyword-clause 1))))
+              (cond ((looking-at c-keywords-regexp)
+                     (c-forward-keyword-clause 1))
+                    ((looking-at c-noise-macro-with-parens-name-re)
+                     (c-forward-noise-clause)))))
      (when (memq res '(t known found prefix))
        ,(when (eq type 'ref)
           `(when c-record-type-identifiers
@@ -5830,6 +5861,17 @@ comment at the start of cc-engine.el for more info."
                  (c-forward-syntactic-ws)
                  (c-forward-keyword-prefixed-id ,type)))))
 
+(defun c-forward-noise-clause ()
+  ;; Point is at a c-noise-macro-with-parens-names macro identifier.  Go
+  ;; forward over this name, any parenthesis expression which follows it, and
+  ;; any syntactic WS, ending up at the next token.  If there is an unbalanced
+  ;; paren expression, leave point at it.  Always Return t.
+  (c-forward-token-2)
+  (if (and (eq (char-after) ?\()
+           (c-go-list-forward))
+      (c-forward-syntactic-ws))
+  t)
+
 (defun c-forward-keyword-clause (match)
   ;; Submatch MATCH in the current match data is assumed to surround a
   ;; token.  If it's a keyword, move over it and any immediately
@@ -6460,6 +6502,13 @@ comment at the start of cc-engine.el for more info."
                                      ; "typedef".
       (goto-char (match-end 1))
       (c-forward-syntactic-ws)
+
+      (while (cond
+              ((looking-at c-decl-hangon-key)
+               (c-forward-keyword-clause 1))
+              ((looking-at c-noise-macro-with-parens-name-re)
+               (c-forward-noise-clause))))
+
       (setq pos (point))
 
       (setq name-res (c-forward-name))
@@ -6852,31 +6901,38 @@ comment at the start of cc-engine.el for more info."
            ;; of the while.  These are, e.g. "*" in "int *foo" or "(" and
            ;; "*" in "int (*foo) (void)" (Note similar code in
            ;; `c-forward-decl-or-cast-1'.)
-           (while (and (looking-at c-type-decl-prefix-key)
-                       (if (and (c-major-mode-is 'c++-mode)
-                                (match-beginning 3))
-                           ;; If the third submatch matches in C++ then
-                           ;; we're looking at an identifier that's a
-                           ;; prefix only if it specifies a member pointer.
-                           (progn
-                             (setq id-start (point))
-                             (c-forward-name)
-                             (if (looking-at "\\(::\\)")
-                                 ;; We only check for a trailing "::" and
-                                 ;; let the "*" that should follow be
-                                 ;; matched in the next round.
-                                 t
-                               ;; It turned out to be the real identifier,
-                               ;; so flag that and stop.
-                               (setq got-identifier t)
-                               nil))
-                         t))
-             (if (eq (char-after) ?\()
-                 (progn
-                   (setq paren-depth (1+ paren-depth))
-                   (forward-char))
-               (goto-char (match-end 1)))
-             (c-forward-syntactic-ws))
+              (while
+                  (cond
+                   ((looking-at c-decl-hangon-key)
+                    (c-forward-keyword-clause 1))
+                   ((looking-at c-noise-macro-with-parens-name-re)
+                    (c-forward-noise-clause))
+                   ((and (looking-at c-type-decl-prefix-key)
+                         (if (and (c-major-mode-is 'c++-mode)
+                                  (match-beginning 3))
+                             ;; If the third submatch matches in C++ then
+                             ;; we're looking at an identifier that's a
+                             ;; prefix only if it specifies a member pointer.
+                             (progn
+                               (setq id-start (point))
+                               (c-forward-name)
+                               (if (looking-at "\\(::\\)")
+                                   ;; We only check for a trailing "::" and
+                                   ;; let the "*" that should follow be
+                                   ;; matched in the next round.
+                                   t
+                                 ;; It turned out to be the real identifier,
+                                 ;; so flag that and stop.
+                                 (setq got-identifier t)
+                                 nil))
+                           t))
+                    (if (eq (char-after) ?\()
+                        (progn
+                          (setq paren-depth (1+ paren-depth))
+                          (forward-char))
+                      (goto-char (match-end 1)))
+                    (c-forward-syntactic-ws)
+                    t)))
 
            ;; If we haven't passed the identifier already, do it now.
            (unless got-identifier
@@ -6901,9 +6957,12 @@ comment at the start of cc-engine.el for more info."
 
          ;; Skip over any trailing bit, such as "__attribute__".
          (progn
-           (when (looking-at c-decl-hangon-key)
-             (c-forward-keyword-clause 1))
-           (<= (point) limit))
+              (while (cond
+                      ((looking-at c-decl-hangon-key)
+                       (c-forward-keyword-clause 1))
+                      ((looking-at c-noise-macro-with-parens-name-re)
+                       (c-forward-noise-clause))))
+              (<= (point) limit))
 
          ;; Search syntactically to the end of the declarator (";",
          ;; ",", a closing paren, eob etc) or to the beginning of an
@@ -7082,18 +7141,24 @@ comment at the start of cc-engine.el for more info."
     ;; macros like __INLINE__, so we recognize both types and known
     ;; specifiers after them too.
     (while
-        (let* ((start (point)) kwd-sym kwd-clause-end found-type)
+        (let* ((start (point)) kwd-sym kwd-clause-end found-type noise-start)
 
+          (cond
           ;; Look for a specifier keyword clause.
-          (when (or (looking-at c-prefix-spec-kwds-re) ;FIXME!!! includes auto
-                    (and (c-major-mode-is 'java-mode)
-                         (looking-at "@[A-Za-z0-9]+")))
-            (if (save-match-data (looking-at c-typedef-key))
-                (setq at-typedef t))
+           ((or (looking-at c-prefix-spec-kwds-re)
+                (and (c-major-mode-is 'java-mode)
+                 (looking-at "@[A-Za-z0-9]+")))
+            (save-match-data
+              (if (looking-at c-typedef-key)
+                  (setq at-typedef t)))
             (setq kwd-sym (c-keyword-sym (match-string 1)))
             (save-excursion
               (c-forward-keyword-clause 1)
               (setq kwd-clause-end (point))))
+           ((looking-at c-noise-macro-with-parens-name-re)
+            (setq noise-start (point))
+            (c-forward-noise-clause)
+            (setq kwd-clause-end (point))))
 
           (when (setq found-type (c-forward-type t)) ; brace-block-too
             ;; Found a known or possible type or a prefix of a known type.
@@ -7131,16 +7196,17 @@ comment at the start of cc-engine.el for more info."
                   backup-at-type-decl nil
                   backup-maybe-typeless nil))
 
-          (if kwd-sym
+          (if (or kwd-sym noise-start)
               (progn
                 ;; Handle known specifier keywords and
                 ;; `c-decl-hangon-kwds' which can occur after known
                 ;; types.
 
-                (if (c-keyword-member kwd-sym 'c-decl-hangon-kwds)
-                    ;; It's a hang-on keyword that can occur anywhere.
+                (if (or (c-keyword-member kwd-sym 'c-decl-hangon-kwds)
+                        noise-start)
+                    ;; It's a hang-on keyword or noise clause that can occur
+                    ;; anywhere.
                     (progn
-                      (setq at-decl-or-cast t)
                       (if at-type
                           ;; Move the identifier start position if
                           ;; we've passed a type.
@@ -7192,8 +7258,11 @@ comment at the start of cc-engine.el for more info."
       ;; If a known type was found, we still need to skip over any
       ;; hangon keyword clauses after it.  Otherwise it has already
       ;; been done in the loop above.
-      (while (looking-at c-decl-hangon-key)
-        (c-forward-keyword-clause 1))
+      (while
+          (cond ((looking-at c-decl-hangon-key)
+                 (c-forward-keyword-clause 1))
+                ((looking-at c-noise-macro-with-parens-name-re)
+                 (c-forward-noise-clause))))
       (setq id-start (point)))
 
      ((eq at-type 'prefix)
@@ -8960,6 +9029,11 @@ comment at the start of cc-engine.el for more info."
            t)
           ((looking-at c-after-brace-list-key) t)
           ((looking-at c-brace-list-key) nil)
+          ((eq (char-after) ?\()
+           (and (eq (c-backward-token-2) 0)
+                (or (looking-at c-decl-hangon-key)
+                    (looking-at c-noise-macro-with-parens-name-re))))
+
           ((and c-recognize-<>-arglists
                 (eq (char-after) ?<)
                 (looking-at "\\s("))
@@ -10220,9 +10294,11 @@ comment at the start of cc-engine.el for more info."
            ;; CASE 5A.3: brace list open
            ((save-excursion
               (c-beginning-of-decl-1 lim)
-              (while (looking-at c-specifier-key)
-                (goto-char (match-end 1))
-                (c-forward-syntactic-ws indent-point))
+              (while (cond
+                      ((looking-at c-specifier-key)
+                       (c-forward-keyword-clause 1))
+                      ((looking-at c-noise-macro-with-parens-name-re)
+                       (c-forward-noise-clause))))
               (setq placeholder (c-point 'boi))
               (or (consp special-brace-list)
                   (and (or (save-excursion
@@ -10274,9 +10350,11 @@ comment at the start of cc-engine.el for more info."
            (t
             (save-excursion
               (c-beginning-of-decl-1 lim)
-              (while (looking-at c-specifier-key)
-                (goto-char (match-end 1))
-                (c-forward-syntactic-ws indent-point))
+              (while (cond
+                      ((looking-at c-specifier-key)
+                       (c-forward-keyword-clause 1))
+                      ((looking-at c-noise-macro-with-parens-name-re)
+                       (c-forward-noise-clause))))
               (c-add-syntax 'defun-open (c-point 'boi))
               ;; Bogus to use bol here, but it's the legacy.  (Resolved,
               ;; 2007-11-09)
@@ -10907,9 +10985,11 @@ comment at the start of cc-engine.el for more info."
             (c-beginning-of-statement-1
              (c-safe-position (1- containing-sexp) paren-state))
             (c-forward-token-2 0)
-            (while (looking-at c-specifier-key)
-              (goto-char (match-end 1))
-              (c-forward-syntactic-ws))
+            (while (cond
+                    ((looking-at c-specifier-key)
+                     (c-forward-keyword-clause 1))
+                    ((looking-at c-noise-macro-with-parens-name-re)
+                     (c-forward-noise-clause))))
             (c-add-syntax 'brace-list-open (c-point 'boi))))
 
          ;; CASE 9B: brace-list-close brace
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 3cc537bba3d..a7097b98c9d 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1698,10 +1698,16 @@ 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 (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))
+                          (while
+                              (or
+                               (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)
+                                 t)
+                               (when (looking-at c-noise-macro-with-parens-name-re)
+                                 (c-forward-noise-clause)
+                                 t)))
                           ,(if (c-major-mode-is 'c++-mode)
                                `(when (and (c-forward-type)
                                            (eq (char-after) ?=))
@@ -1827,7 +1833,7 @@ higher."
                 "\\)\\>"
                 ;; Disallow various common punctuation chars that can't come
                 ;; before the '{' of the enum list, to avoid searching too far.
-                "[^][{}();/#=]*"
+                "[^][{};/#=]*"
                 "{")
                '((c-font-lock-declarators limit t nil)
                  (save-match-data
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 86b6bec78a1..d212482790d 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -619,6 +619,11 @@ This is of the form that fits inside [ ] in a regexp."
   objc (concat c-alnum "_$@"))
 (c-lang-defvar c-symbol-chars (c-lang-const c-symbol-chars))
 
+(c-lang-defconst c-symbol-char-key
+  "Regexp matching a sequence of at least one identifier character."
+  t (concat "[" (c-lang-const c-symbol-chars) "]+"))
+(c-lang-defvar c-symbol-char-key (c-lang-const c-symbol-char-key))
+
 (c-lang-defconst c-symbol-key
   "Regexp matching identifiers and keywords (with submatch 0).  Assumed
 to match if `c-symbol-start' matches on the same position."
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 58aebf8b410..9ebe6f79eb3 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1493,6 +1493,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map c-mode-map)
   (c-init-language-vars-for 'c-mode)
+  (c-make-noise-macro-regexps)
   (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'c-mode)
   (easy-menu-add c-c-menu)
@@ -1548,6 +1549,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map c++-mode-map)
   (c-init-language-vars-for 'c++-mode)
+  (c-make-noise-macro-regexps)
   (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'c++-mode)
   (easy-menu-add c-c++-menu)
@@ -1601,6 +1603,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map objc-mode-map)
   (c-init-language-vars-for 'objc-mode)
+  (c-make-noise-macro-regexps)
   (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'objc-mode)
   (easy-menu-add c-objc-menu)
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 8cee733ec8e..a6957185a2b 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1619,6 +1619,49 @@ names)."))
   :type 'c-extra-types-widget
   :group 'c)
 
+(defvar c-noise-macro-with-parens-name-re nil)
+(defvar c-noise-macro-name-re nil)
+
+(defcustom c-noise-macro-names nil
+  "A list of names of macros which expand to nothing, or compiler extensions
+like \"????\" which are syntactic noise.  Such a macro/extension is complete in
+itself, never having parentheses.  All these names must be syntactically valid
+identifiers.
+
+If you change this variable's value, call the function
+`c-make-noise-macro-regexps' to set the necessary internal variables (or do
+this implicitly by reinitialising C/C++/Objc Mode on any buffer)."
+  :type '(repeat :tag "List of names" string)
+  :group 'c)
+
+(defcustom c-noise-macro-with-parens-names nil
+  "A list of names of macros \(or compiler extensions like \"__attribute__\")
+which optionally have arguments in parentheses, and which expand to nothing.
+These are recognized by CC Mode only in declarations."
+  :type '(regexp :tag "List of names (possibly empty)" string)
+  :group 'c)
+
+(defun c-make-noise-macro-regexps ()
+  ;; Convert `c-noise-macro-names' and `c-noise-macro-with-parens-names' into
+  ;; `c-noise-macro-name-re' and `c-noise-macro-with-parens-name-re'.
+  (setq c-noise-macro-with-parens-name-re
+        (cond ((null c-noise-macro-with-parens-names) "\\<\\>")
+              ((consp c-noise-macro-with-parens-names)
+               (concat (regexp-opt c-noise-macro-with-parens-names t)
+                       "\\([^[:alnum:]_$]\\|$\\)"))
+              ((stringp c-noise-macro-with-parens-names)
+               (copy-sequence c-noise-macro-with-parens-names))
+              (t (error "c-make-noise-macro-regexps: \
+c-noise-macro-with-parens-names is invalid: %s" c-noise-macro-with-parens-names))))
+  (setq c-noise-macro-name-re
+        (cond ((null c-noise-macro-names) "\\<\\>")
+              ((consp c-noise-macro-names)
+               (concat (regexp-opt c-noise-macro-names t)
+                       "\\([^[:alnum:]_$]\\|$\\)"))
+              ((stringp c-noise-macro-names)
+               (copy-sequence c-noise-macro-names))
+              (t (error "c-make-noise-macro-regexps: \
+c-noise-macro-names is invalid: %s" c-noise-macro-names)))))
 
 ;; Non-customizable variables, still part of the interface to CC Mode
 (defvar c-macro-with-semi-re nil