CC Mode: Handle noise clauses, template arglists in any order

This fixes the first part of bug#66911.

* lisp/progmodes/cc-engine.el (c-looking-at-decl-block): Skip
back over template arglists and noise clauses in any order, no
longer assuming the noise clauses are before the template
arglist in the buffer.  When scanning forward, take noise
clauses into account.  Refactor a collection of nested `if'
forms as a cond form.

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f5e0d21108f12bf884e36012cd98bb0b14f118f9..1fc02d1ad075f672dc1a6455d3cc02291995003f 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -12617,31 +12617,27 @@ comment at the start of cc-engine.el for more info."
   (let ((open-brace (point)) kwd-start first-specifier-pos)
     (c-syntactic-skip-backward c-block-prefix-charset limit t)
 
-    (when (and c-recognize-<>-arglists
-              (eq (char-before) ?>))
-      ;; Could be at the end of a template arglist.
-      (let ((c-parse-and-markup-<>-arglists t))
-       (while (and
-               (c-backward-<>-arglist nil limit)
-               (progn
-                 (c-syntactic-skip-backward c-block-prefix-charset limit t)
-                 (eq (char-before) ?>))))))
-
-    ;; Skip back over noise clauses.
-    (while (and
-           c-opt-cpp-prefix
-           (eq (char-before) ?\))
-           (let ((after-paren (point)))
-             (if (and (c-go-list-backward)
-                      (progn (c-backward-syntactic-ws)
-                             (c-simple-skip-symbol-backward))
-                      (or (looking-at c-paren-nontype-key)
-                          (looking-at c-noise-macro-with-parens-name-re)))
-                 (progn
-                   (c-syntactic-skip-backward c-block-prefix-charset limit t)
-                   t)
-               (goto-char after-paren)
-               nil))))
+    (while
+       (or 
+        ;; Could be after a template arglist....
+        (and c-recognize-<>-arglists
+             (eq (char-before) ?>)
+             (let ((c-parse-and-markup-<>-arglists t))
+               (c-backward-<>-arglist nil limit)))
+        ;; .... or after a noise clause with parens.
+        (and c-opt-cpp-prefix
+             (let ((after-paren (point)))
+               (if (eq (char-before) ?\))
+                   (and
+                    (c-go-list-backward)
+                    (eq (char-after) ?\()
+                    (progn (c-backward-syntactic-ws)
+                           (c-simple-skip-symbol-backward))
+                    (or (looking-at c-paren-nontype-key) ; e.g. __attribute__
+                        (looking-at c-noise-macro-with-parens-name-re)))
+                 (goto-char after-paren)
+                 nil))))
+      (c-syntactic-skip-backward c-block-prefix-charset limit t))
 
     ;; Note: Can't get bogus hits inside template arglists below since they
     ;; have gotten paren syntax above.
@@ -12651,10 +12647,18 @@ comment at the start of cc-engine.el for more info."
           ;; The `c-decl-block-key' search continues from there since
           ;; we know it can't match earlier.
           (if goto-start
-              (when (c-syntactic-re-search-forward c-symbol-start
-                                                   open-brace t t)
-                (goto-char (setq first-specifier-pos (match-beginning 0)))
-                t)
+              (progn
+                (while
+                    (and
+                     (c-syntactic-re-search-forward c-symbol-start
+                                                    open-brace t t)
+                     (goto-char (match-beginning 0))
+                     (if (or (looking-at c-noise-macro-name-re)
+                             (looking-at c-noise-macro-with-parens-name-re))
+                         (c-forward-noise-clause)
+                       (setq first-specifier-pos (match-beginning 0))
+                       nil)))
+                first-specifier-pos)
             t)
 
           (cond
@@ -12723,34 +12727,39 @@ comment at the start of cc-engine.el for more info."
            (goto-char first-specifier-pos)
 
            (while (< (point) kwd-start)
-             (if (looking-at c-symbol-key)
-                 ;; Accept any plain symbol token on the ground that
-                 ;; it's a specifier masked through a macro (just
-                 ;; like `c-forward-decl-or-cast-1' skip forward over
-                 ;; such tokens).
-                 ;;
-                 ;; Could be more restrictive wrt invalid keywords,
-                 ;; but that'd only occur in invalid code so there's
-                 ;; no use spending effort on it.
-                 (let ((end (match-end 0))
-                       (kwd-sym (c-keyword-sym (match-string 0))))
-                   (unless
-                       (and kwd-sym
-                            ;; Moving over a protection kwd and the following
-                            ;; ":" (in C++ Mode) to the next token could take
-                            ;; us all the way up to `kwd-start', leaving us
-                            ;; no chance to update `first-specifier-pos'.
-                            (not (c-keyword-member kwd-sym 'c-protection-kwds))
-                            (c-forward-keyword-clause 0))
-                     (goto-char end)
-                     (c-forward-syntactic-ws)))
-
+             (cond
+              ((or (looking-at c-noise-macro-name-re)
+                   (looking-at c-noise-macro-with-parens-name-re))
+               (c-forward-noise-clause))
+              ((looking-at c-symbol-key)
+               ;; Accept any plain symbol token on the ground that
+               ;; it's a specifier masked through a macro (just
+               ;; like `c-forward-decl-or-cast-1' skips forward over
+               ;; such tokens).
+               ;;
+               ;; Could be more restrictive wrt invalid keywords,
+               ;; but that'd only occur in invalid code so there's
+               ;; no use spending effort on it.
+               (let ((end (match-end 0))
+                     (kwd-sym (c-keyword-sym (match-string 0))))
+                 (unless
+                     (and kwd-sym
+                          ;; Moving over a protection kwd and the following
+                          ;; ":" (in C++ Mode) to the next token could take
+                          ;; us all the way up to `kwd-start', leaving us
+                          ;; no chance to update `first-specifier-pos'.
+                          (not (c-keyword-member kwd-sym 'c-protection-kwds))
+                          (c-forward-keyword-clause 0))
+                   (goto-char end)
+                   (c-forward-syntactic-ws))))
+
+              ((c-syntactic-re-search-forward c-symbol-start
+                                              kwd-start 'move t)
                ;; Can't parse a declaration preamble and is still
                ;; before `kwd-start'.  That means `first-specifier-pos'
                ;; was in some earlier construct.  Search again.
-               (if (c-syntactic-re-search-forward c-symbol-start
-                                                  kwd-start 'move t)
-                   (goto-char (setq first-specifier-pos (match-beginning 0)))
+               (goto-char (setq first-specifier-pos (match-beginning 0))))
+              (t
                  ;; Got no preamble before the block declaration keyword.
                  (setq first-specifier-pos kwd-start))))