Fontify untyped function declarations in C Mode correctly.

Also correct two bugs where deleting WS at a BOL could leave an untyped
function declaration unfontified.

* lisp/progmodes/cc-engine.el (c-find-decl-spots): Don't set the flag
"top-level" when we're in a macro.
(c-forward-decl-or-cast-1): Recognize top-level "foo(bar)" or "foo()" in C
Mode as a implicitly typed function declaration.
(c-just-after-func-arglist-p): Don't get confused by "defined (foo)" inside a
macro.  It's not a function plus arglist.

* lisp/progmodes/cc-langs.el (c-cpp-expr-functions-key): New defconst and
defvar.

* lisp/progmodes/cc-mode.el (c-fl-decl-end): After c-forward-declarator, move
over any following parenthesis expression (i.e. parameter list).
(c-change-expand-fl-region): When c-new-END is at a BOL, include that line in
the returned region, to cope with deletions at column 0.

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 9d65383e25866c25396344bd37e4153de748888d..37928357526b419218987bc74c10317f646f1b36 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -132,7 +132,7 @@
 ;;
 ;;     'c-not-decl
 ;;       Put on the brace which introduces a brace list and on the commas
-;;       which separate the element within it.
+;;       which separate the elements within it.
 ;;
 ;; 'c-awk-NL-prop
 ;;   Used in AWK mode to mark the various kinds of newlines.  See
@@ -5403,8 +5403,8 @@ comment at the start of cc-engine.el for more info."
        (min c-bs-cache-limit pos)))
 
 (defun c-update-brace-stack (stack from to)
-  ;; Give a brace-stack which has the value STACK at position FROM, update it
-  ;; to it's value at position TO, where TO is after (or equal to) FROM.
+  ;; Given a brace-stack which has the value STACK at position FROM, update it
+  ;; to its value at position TO, where TO is after (or equal to) FROM.
   ;; Return a cons of either TO (if it is outside a literal) and this new
   ;; value, or of the next position after TO outside a literal and the new
   ;; value.
@@ -5649,11 +5649,13 @@ comment at the start of cc-engine.el for more info."
   ;; Call CFD-FUN for each possible spot for a declaration, cast or
   ;; label from the point to CFD-LIMIT.
   ;;
-  ;; CFD-FUN is called with point at the start of the spot.  It's passed two
+  ;; CFD-FUN is called with point at the start of the spot.  It's passed three
   ;; arguments: The first is the end position of the token preceding the spot,
   ;; or 0 for the implicit match at bob.  The second is a flag that is t when
-  ;; the match is inside a macro.  Point should be moved forward by at least
-  ;; one token.
+  ;; the match is inside a macro.  The third is a flag that is t when the
+  ;; match is at "top level", i.e. outside any brace block, or directly inside
+  ;; a class or namespace, etc.  Point should be moved forward by at least one
+  ;; token.
   ;;
   ;; If CFD-FUN adds `c-decl-end' properties somewhere below the current spot,
   ;; it should return non-nil to ensure that the next search will find them.
@@ -6040,6 +6042,8 @@ comment at the start of cc-engine.el for more info."
                   (setq cfd-macro-end 0)
                   nil))))              ; end of when condition
 
+       (when (> cfd-macro-end 0)
+         (setq cfd-top-level nil))     ; In a macro is "never" at top level.
        (c-debug-put-decl-spot-faces cfd-match-pos (point))
        (if (funcall cfd-fun cfd-match-pos (/= cfd-macro-end 0) cfd-top-level)
            (setq cfd-prop-match nil))
@@ -8577,7 +8581,13 @@ comment at the start of cc-engine.el for more info."
                 (looking-at c-noise-macro-with-parens-name-re))
            (c-forward-noise-clause))
 
-          ((looking-at c-type-decl-suffix-key)
+          ((and (looking-at c-type-decl-suffix-key)
+                ;; We avoid recognizing foo(bar) or foo() at top level as a
+                ;; construct here in C, since we want to recognize this as a
+                ;; typeless function declaration.
+                (not (and (c-major-mode-is 'c-mode)
+                          (eq context 'top)
+                          (eq (char-after) ?\)))))
            (if (eq (char-after) ?\))
                (when (> paren-depth 0)
                  (setq paren-depth (1- paren-depth))
@@ -8620,7 +8630,12 @@ comment at the start of cc-engine.el for more info."
                                     (save-excursion
                                       (goto-char after-paren-pos)
                                       (c-forward-syntactic-ws)
-                                      (c-forward-type)))))
+                                      (or (c-forward-type)
+                                          ;; Recognize a top-level typeless
+                                          ;; function declaration in C.
+                                          (and (c-major-mode-is 'c-mode)
+                                               (eq context 'top)
+                                               (eq (char-after) ?\))))))))
                          (setq pos (c-up-list-forward (point)))
                          (eq (char-before pos) ?\)))
                 (c-fdoc-shift-type-backward)
@@ -9037,9 +9052,12 @@ comment at the start of cc-engine.el for more info."
         ;; (in at least C++) that anything that can be parsed as a declaration
         ;; is a declaration.  Now we're being more defensive and prefer to
         ;; highlight things like "foo (bar);" as a declaration only if we're
-        ;; inside an arglist that contains declarations.
-         ;; CASE 19
-        (eq context 'decl))))
+        ;; inside an arglist that contains declarations.  Update (2017-09): We
+        ;; now recognize a top-level "foo(bar);" as a declaration in C.
+        ;; CASE 19
+        (or (eq context 'decl)
+            (and (c-major-mode-is 'c-mode)
+                 (eq context 'top))))))
 
     ;; The point is now after the type decl expression.
 
@@ -9547,6 +9565,7 @@ Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
   ;; Note to maintainers: this function consumes a great mass of CPU cycles.
   ;; Its use should thus be minimized as far as possible.
+  ;; Consider instead using `c-bs-at-toplevel-p'.
   (let ((paren-state (c-parse-state)))
     (or (not (c-most-enclosing-brace paren-state))
        (c-search-uplist-for-classkey paren-state))))
@@ -9576,8 +9595,15 @@ comment at the start of cc-engine.el for more info."
      (not (and (c-major-mode-is 'objc-mode)
               (c-forward-objc-directive)))
 
+     ;; Don't confuse #if .... defined(foo) for a function arglist.
+     (not (and (looking-at c-cpp-expr-functions-key)
+              (save-excursion
+                (save-restriction
+                  (widen)
+                  (c-beginning-of-macro lim)))))
      (setq id-start
           (car-safe (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil)))
+     (numberp id-start)
      (< id-start beg)
 
      ;; There should not be a '=' or ',' between beg and the

diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 7a285f93d34c9ed25d95806e2cf17f302fb99659..bcda093678a715621515aaaa9181a390139e70f3 100644 (file)
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -952,6 +952,11 @@ expression, or nil if there aren't any in the language."
           '("defined"))
   pike '("defined" "efun" "constant"))
 
+(c-lang-defconst c-cpp-expr-functions-key
+  ;; Matches a function in a cpp expression.
+  t (c-make-keywords-re t (c-lang-const c-cpp-expr-functions)))
+(c-lang-defvar c-cpp-expr-functions-key (c-lang-const c-cpp-expr-functions-key))
+
 (c-lang-defconst c-assignment-operators
   "List of all assignment operators."
   t    '("=" "*=" "/=" "%=" "+=" "-=" ">>=" "<<=" "&=" "^=" "|=")

diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 8867453e85c3cd827f11c402497f57a03c74319b..b0e5fe47a7c2b10ae881ab07d1990d6119b4ebb9 100644 (file)
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1571,6 +1571,8 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                   (and (c-beginning-of-macro)
                        (progn (c-end-of-macro) (point))))))
        (when (and (c-forward-declarator lim)
+                  (or (not (eq (char-after) ?\())
+                      (c-go-list-forward nil lim))
                   (eq (c-forward-token-2 1 nil lim) 0))
          (c-backward-syntactic-ws)
          (point))))))
@@ -1589,7 +1591,7 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
            (or (c-fl-decl-start c-new-BEG) (c-point 'bol c-new-BEG))
            c-new-END
            (or (c-fl-decl-end c-new-END)
-               (c-point 'bonl (max (1- c-new-END) (point-min)))))))
+               (c-point 'bonl c-new-END)))))
 
 (defun c-context-expand-fl-region (beg end)
   ;; Return a cons (NEW-BEG . NEW-END), where NEW-BEG is the beginning of a