CC Mode: make c-display-defun-name work with a pointer return type.

Fixes bug #32403.

* lisp/progmodes/cc-cmds.el (c-in-function-trailer-p): No longer insist on
c-beginning-of-decl-1 returning 'same.
(c-where-wrt-brace-construct): Tighten up the test for looking at a symbol by
excluding keywords.  When point is after a }, do not return 'at-function-end
for a struct/union/class/...
(c-defun-name-1): Considerably simplify, by amalgamating the two cond arms
which find structs etc., and by using functions like c-forward-declarator
rather than the faulty analysis of the source by hand.

1 files changed, 30 insertions, 53 deletions

diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 31cf0b11596..478ccf18029 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1383,7 +1383,7 @@ No indentation or other \"electric\" behavior is performed."
          (let ((eo-block (point))
                bod)
            (and (eq (char-before) ?\})
-                (eq (car (c-beginning-of-decl-1 lim)) 'previous)
+                (memq (car (c-beginning-of-decl-1 lim)) '(same previous))
                 (setq bod (point))
                 ;; Look for struct or union or ...  If we find one, it might
                 ;; be the return type of a function, or the like.  Exclude
@@ -1445,10 +1445,17 @@ No indentation or other \"electric\" behavior is performed."
              (consp paren-state)
              (consp (car paren-state))
              (eq start (cdar paren-state))
-             (not
-              (progn
+             (or
+              (save-excursion
                 (c-forward-syntactic-ws)
-                (looking-at c-symbol-start))))
+                (or (not (looking-at c-symbol-start))
+                    (looking-at c-keywords-regexp)))
+              (save-excursion
+                (goto-char (caar paren-state))
+                (c-beginning-of-decl-1
+                 (and least-enclosing
+                      (c-safe-position least-enclosing paren-state)))
+                (not (looking-at c-defun-type-name-decl-key)))))
         'at-function-end)
        (t
         ;; Find the start of the current declaration.  NOTE: If we're in the
@@ -1841,7 +1848,7 @@ or NIL if there isn't one.  \"Defun\" here means a function, or
 other top level construct with a brace block."
   (c-save-buffer-state
       (beginning-of-defun-function end-of-defun-function
-       where pos decl name-start name-end case-fold-search)
+       where pos decl0 decl type-pos tag-pos case-fold-search)
 
     (save-excursion
       ;; Move back out of any macro/comment/string we happen to be in.
@@ -1861,31 +1868,10 @@ other top level construct with a brace block."
         (when (looking-at c-typedef-key)
           (goto-char (match-end 0))
           (c-forward-syntactic-ws))
+        (setq type-pos (point))
 
         ;; Pick out the defun name, according to the type of defun.
         (cond
-         ;; struct, union, enum, or similar:
-         ((save-excursion
-            (and
-             (looking-at c-defun-type-name-decl-key)
-             (consp (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil))
-             (or (not (or (eq (char-after) ?{)
-                          (and c-recognize-knr-p
-                               (c-in-knr-argdecl))))
-                 (progn (c-backward-syntactic-ws)
-                        (not (eq (char-before) ?\)))))))
-          (let ((key-pos (point)))
-            (c-forward-over-token-and-ws) ; over "struct ".
-            (cond
-             ((looking-at c-symbol-key) ; "struct foo { ..."
-              (buffer-substring-no-properties key-pos (match-end 0)))
-             ((eq (char-after) ?{)      ; "struct { ... } foo"
-              (when (c-go-list-forward)
-                (c-forward-syntactic-ws)
-                (when (looking-at c-symbol-key) ; a bit bogus - there might
-                                        ; be several identifiers.
-                  (match-string-no-properties 0)))))))
-
          ((looking-at "DEFUN\\s-*(")    ;"DEFUN\\_>") think of XEmacs!
           ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
           ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
@@ -1901,32 +1887,23 @@ other top level construct with a brace block."
              (c-backward-syntactic-ws)
              (point))))
 
-         (t
-          ;; Normal function or initializer.
-          (when
-              (and
-               (consp
-                (setq decl
-                      (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil)))
-               (setq name-start (car decl))
-               (progn (if (and (looking-at c-after-suffixed-type-decl-key)
-                               (match-beginning 1))
-                          (c-forward-keyword-clause 1))
-                      t)
-               (or (eq (char-after) ?{)
-                   (and c-recognize-knr-p
-                        (c-in-knr-argdecl)))
-               (goto-char name-start)
-               (c-forward-name)
-               (eq (char-after) ?\())
-            (c-backward-syntactic-ws)
-            (when (eq (char-before) ?\=) ; struct foo bar = {0, 0} ;
-              (c-backward-token-2)
-              (c-backward-syntactic-ws))
-            (setq name-end (point))
-            (c-back-over-compound-identifier)
-            (and (looking-at c-symbol-start)
-                 (buffer-substring-no-properties (point) name-end)))))))))
+         (t                             ; Normal function or initializer.
+          (when (looking-at c-defun-type-name-decl-key) ; struct, etc.
+            (goto-char (match-end 0))
+            (c-forward-syntactic-ws)
+            (setq tag-pos (point))
+            (goto-char type-pos))
+          (setq decl0 (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil))
+          (when (consp decl0)
+            (goto-char (car decl0))
+            (setq decl (c-forward-declarator)))
+          (and decl
+               (car decl) (cadr decl)
+               (buffer-substring-no-properties
+                (if (eq (car decl) tag-pos)
+                    type-pos
+                  (car decl))
+                (cadr decl)))))))))
 
 (defun c-defun-name ()
   "Return the name of the current defun, or NIL if there isn't one.