Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs into feature/pgtk

17 files changed, 472 insertions, 282 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f14ffb38cde..218bbb47cd5 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -972,7 +972,7 @@ comment at the start of cc-engine.el for more info."
       ;; that we've moved.
       (while (progn
                (setq pos (point))
-               (c-backward-syntactic-ws)
+               (c-backward-syntactic-ws lim)
                ;; Protect post-++/-- operators just before a virtual semicolon.
                (and (not (c-at-vsemi-p))
                     (/= (skip-chars-backward "-+!*&~@`#") 0))))
@@ -984,7 +984,7 @@ comment at the start of cc-engine.el for more info."
       (if (and (memq (char-before) delims)
                (progn (forward-char -1)
                       (setq saved (point))
-                      (c-backward-syntactic-ws)
+                      (c-backward-syntactic-ws lim)
                       (or (memq (char-before) delims)
                           (memq (char-before) '(?: nil))
                           (eq (char-syntax (char-before)) ?\()
@@ -1164,7 +1164,7 @@ comment at the start of cc-engine.el for more info."
                 ;; HERE IS THE SINGLE PLACE INSIDE THE PDA LOOP WHERE WE MOVE
                 ;; BACKWARDS THROUGH THE SOURCE.
 
-                (c-backward-syntactic-ws)
+                (c-backward-syntactic-ws lim)
                 (let ((before-sws-pos (point))
                       ;; The end position of the area to search for statement
                       ;; barriers in this round.
@@ -1174,33 +1174,35 @@ comment at the start of cc-engine.el for more info."
                   ;; Go back over exactly one logical sexp, taking proper
                   ;; account of macros and escaped EOLs.
                   (while
-                      (progn
-                        (setq comma-delimited (and (not comma-delim)
-                                                   (eq (char-before) ?\,)))
-                        (unless (c-safe (c-backward-sexp) t)
-                          ;; Give up if we hit an unbalanced block.  Since the
-                          ;; stack won't be empty the code below will report a
-                          ;; suitable error.
-                          (setq pre-stmt-found t)
-                          (throw 'loop nil))
-                        (cond
-                         ;; Have we moved into a macro?
-                         ((and (not macro-start)
-                               (c-beginning-of-macro))
-                          (save-excursion
-                            (c-backward-syntactic-ws)
-                            (setq before-sws-pos (point)))
-                          ;; Have we crossed a statement boundary?  If not,
-                          ;; keep going back until we find one or a "real" sexp.
-                          (and
+                      (and
+                       (progn
+                         (setq comma-delimited (and (not comma-delim)
+                                                    (eq (char-before) ?\,)))
+                         (unless (c-safe (c-backward-sexp) t)
+                           ;; Give up if we hit an unbalanced block.  Since the
+                           ;; stack won't be empty the code below will report a
+                           ;; suitable error.
+                           (setq pre-stmt-found t)
+                           (throw 'loop nil))
+                         (cond
+                          ;; Have we moved into a macro?
+                          ((and (not macro-start)
+                                (c-beginning-of-macro))
                            (save-excursion
-                             (c-end-of-macro)
-                             (not (c-crosses-statement-barrier-p
-                                   (point) maybe-after-boundary-pos)))
-                           (setq maybe-after-boundary-pos (point))))
-                         ;; Have we just gone back over an escaped NL?  This
-                         ;; doesn't count as a sexp.
-                         ((looking-at "\\\\$")))))
+                             (c-backward-syntactic-ws lim)
+                             (setq before-sws-pos (point)))
+                           ;; Have we crossed a statement boundary?  If not,
+                           ;; keep going back until we find one or a "real" sexp.
+                           (and
+                            (save-excursion
+                              (c-end-of-macro)
+                              (not (c-crosses-statement-barrier-p
+                                    (point) maybe-after-boundary-pos)))
+                            (setq maybe-after-boundary-pos (point))))
+                          ;; Have we just gone back over an escaped NL?  This
+                          ;; doesn't count as a sexp.
+                          ((looking-at "\\\\$"))))
+                       (>= (point) lim)))
 
                   ;; Have we crossed a statement boundary?
                   (setq boundary-pos
@@ -1413,7 +1415,7 @@ comment at the start of cc-engine.el for more info."
 
       ;; Skip over the unary operators that can start the statement.
       (while (progn
-               (c-backward-syntactic-ws)
+               (c-backward-syntactic-ws lim)
                ;; protect AWK post-inc/decrement operators, etc.
                (and (not (c-at-vsemi-p (point)))
                     (/= (skip-chars-backward "-.+!*&~@`#") 0)))
@@ -3568,15 +3570,19 @@ mhtml-mode."
   ;; Return a start position for building `c-state-cache' from
   ;; scratch.  This will be at the top level, 2 defuns back.
   (save-excursion
-    ;; Go back 2 bods, but ignore any bogus positions returned by
-    ;; beginning-of-defun (i.e. open paren in column zero).
-    (goto-char here)
-    (let ((cnt 2))
-      (while (not (or (bobp) (zerop cnt)))
-        (c-beginning-of-defun-1)        ; Pure elisp BOD.
-        (if (eq (char-after) ?\{)
-            (setq cnt (1- cnt)))))
-    (point)))
+    (save-restriction
+      (when (> here (* 10 c-state-cache-too-far))
+        (narrow-to-region (- here (* 10 c-state-cache-too-far)) here))
+      ;; Go back 2 bods, but ignore any bogus positions returned by
+      ;; beginning-of-defun (i.e. open paren in column zero).
+      (goto-char here)
+      (let ((cnt 2))
+        (while (not (or (bobp) (zerop cnt)))
+          (c-beginning-of-defun-1)      ; Pure elisp BOD.
+          (if (eq (char-after) ?\{)
+              (setq cnt (1- cnt)))))
+      (and (not (bobp))
+           (point)))))
 
 (defun c-state-balance-parens-backwards (here- here+ top)
   ;; Return the position of the opening paren/brace/bracket before HERE- which
@@ -3667,9 +3673,7 @@ mhtml-mode."
             how-far 0))
      ((<= good-pos here)
       (setq strategy 'forward
-            start-point (if changed-macro-start
-                            cache-pos
-                          (max good-pos cache-pos))
+            start-point (max good-pos cache-pos)
             how-far (- here start-point)))
      ((< (- good-pos here) (- here cache-pos)) ; FIXME!!! ; apply some sort of weighting.
       (setq strategy 'backward
@@ -3688,7 +3692,8 @@ mhtml-mode."
                ;; (not (c-major-mode-is 'c++-mode))
                (> how-far c-state-cache-too-far))
       (setq BOD-pos (c-get-fallback-scan-pos here)) ; somewhat EXPENSIVE!!!
-      (if (< (- here BOD-pos) how-far)
+      (if (and BOD-pos
+               (< (- here BOD-pos) how-far))
           (setq strategy 'BOD
                 start-point BOD-pos)))
 
@@ -4337,8 +4342,12 @@ mhtml-mode."
       (if (and dropped-cons
                (<= too-high-pa here))
           (c-append-lower-brace-pair-to-state-cache too-high-pa here here-bol))
-      (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren)
-                                       (c-state-get-min-scan-pos)))))
+      (if (and c-state-cache-good-pos (< here c-state-cache-good-pos))
+          (setq c-state-cache-good-pos
+                (or (save-excursion
+                      (goto-char here)
+                      (c-literal-start))
+                    here)))))
 
   ;; The brace-pair desert marker:
   (when (car c-state-brace-pair-desert)
@@ -4796,7 +4805,7 @@ comment at the start of cc-engine.el for more info."
 
      ;; Handle the "operator +" syntax in C++.
      (when (and c-overloadable-operators-regexp
-                (= (c-backward-token-2 0) 0))
+                (= (c-backward-token-2 0 nil (c-determine-limit 500)) 0))
 
        (cond ((and (looking-at c-overloadable-operators-regexp)
                    (or (not c-opt-op-identifier-prefix)
@@ -5065,7 +5074,8 @@ See `c-forward-token-2' for details."
           (while (and
                   (> count 0)
                   (progn
-                    (c-backward-syntactic-ws)
+                    (c-backward-syntactic-ws
+                     limit)
                     (backward-char)
                     (if (looking-at jump-syntax)
                         (goto-char (scan-sexps (1+ (point)) -1))
@@ -5402,8 +5412,12 @@ comment at the start of cc-engine.el for more info."
                ;; Optimize for, in particular, large blocks of comments from
                ;; `comment-region'.
                (progn (when opt-ws
-                        (c-backward-syntactic-ws)
-                        (setq paren-level-pos (point)))
+                        (let ((opt-pos (point)))
+                          (c-backward-syntactic-ws limit)
+                          (if (or (null limit)
+                              (> (point) limit))
+                              (setq paren-level-pos (point))
+                            (goto-char opt-pos))))
                       t)
                ;; Move back to a candidate end point which isn't in a literal
                ;; or in a macro we didn't start in.
@@ -5423,7 +5437,11 @@ comment at the start of cc-engine.el for more info."
                                      (setq macro-start (point))))
                             (goto-char macro-start))))
                    (when opt-ws
-                     (c-backward-syntactic-ws)))
+                     (let ((opt-pos (point)))
+                       (c-backward-syntactic-ws limit)
+                       (if (and limit
+                           (<= (point) limit))
+                           (goto-char opt-pos)))))
                  (< (point) pos))
 
                ;; Check whether we're at the wrong level of nesting (when
@@ -5474,7 +5492,7 @@ comment at the start of cc-engine.el for more info."
              (progn
                ;; Skip syntactic ws afterwards so that we don't stop at the
                ;; end of a comment if `skip-chars' is something like "^/".
-               (c-backward-syntactic-ws)
+               (c-backward-syntactic-ws limit)
                (point)))))
 
     ;; We might want to extend this with more useful return values in
@@ -5762,12 +5780,23 @@ comment at the start of cc-engine.el for more info."
               (t 'c)))                  ; Assuming the range is valid.
     range))
 
+(defun c-determine-limit-no-macro (here org-start)
+  ;; If HERE is inside a macro, and ORG-START is not also in the same macro,
+  ;; return the beginning of the macro.  Otherwise return HERE.  Point is not
+  ;; preserved by this function.
+  (goto-char here)
+  (let ((here-BOM (and (c-beginning-of-macro) (point))))
+    (if (and here-BOM
+             (not (eq (progn (goto-char org-start)
+                             (and (c-beginning-of-macro) (point)))
+                      here-BOM)))
+        here-BOM
+      here)))
+
 (defsubst c-determine-limit-get-base (start try-size)
   ;; Get a "safe place" approximately TRY-SIZE characters before START.
   ;; This defsubst doesn't preserve point.
   (goto-char start)
-  (c-backward-syntactic-ws)
-  (setq start (point))
   (let* ((pos (max (- start try-size) (point-min)))
          (s (c-semi-pp-to-literal pos))
          (cand (or (car (cddr s)) pos)))
@@ -5776,20 +5805,23 @@ comment at the start of cc-engine.el for more info."
       (parse-partial-sexp pos start nil nil (car s) 'syntax-table)
       (point))))
 
-(defun c-determine-limit (how-far-back &optional start try-size)
+(defun c-determine-limit (how-far-back &optional start try-size org-start)
   ;; Return a buffer position approximately HOW-FAR-BACK non-literal
   ;; characters from START (default point).  The starting position, either
   ;; point or START may not be in a comment or string.
   ;;
   ;; The position found will not be before POINT-MIN and won't be in a
-  ;; literal.
+  ;; literal.  It will also not be inside a macro, unless START/point is also
+  ;; in the same macro.
   ;;
   ;; We start searching for the sought position TRY-SIZE (default
   ;; twice HOW-FAR-BACK) bytes back from START.
   ;;
   ;; This function must be fast.  :-)
+
   (save-excursion
     (let* ((start (or start (point)))
+           (org-start (or org-start start))
            (try-size (or try-size (* 2 how-far-back)))
            (base (c-determine-limit-get-base start try-size))
            (pos base)
@@ -5842,21 +5874,27 @@ comment at the start of cc-engine.el for more info."
         (setq elt (car stack)
               stack (cdr stack))
         (setq count (+ count (cdr elt))))
-
-      ;; Have we found enough yet?
       (cond
        ((null elt)                      ; No non-literal characters found.
-        (if (> base (point-min))
-            (c-determine-limit how-far-back base (* 2 try-size))
-          (point-min)))
+        (cond
+         ((> pos start)                 ; Nothing but literals
+          base)
+         ((> base (point-min))
+          (c-determine-limit how-far-back base (* 2 try-size) org-start))
+         (t base)))
        ((>= count how-far-back)
-        (+ (car elt) (- count how-far-back)))
+        (c-determine-limit-no-macro
+        (+ (car elt) (- count how-far-back))
+        org-start))
        ((eq base (point-min))
         (point-min))
        ((> base (- start try-size)) ; Can only happen if we hit point-min.
-        (car elt))
+        (c-determine-limit-no-macro
+        (car elt)
+        org-start))
        (t
-        (c-determine-limit (- how-far-back count) base (* 2 try-size)))))))
+        (c-determine-limit (- how-far-back count) base (* 2 try-size)
+                           org-start))))))
 
 (defun c-determine-+ve-limit (how-far &optional start-pos)
   ;; Return a buffer position about HOW-FAR non-literal characters forward
@@ -6248,8 +6286,14 @@ comment at the start of cc-engine.el for more info."
        ;; preceding syntactic ws to set `cfd-match-pos' and to catch
        ;; any decl spots in the syntactic ws.
        (unless cfd-re-match
-         (c-backward-syntactic-ws)
-         (setq cfd-re-match (point))))
+         (let ((cfd-cbsw-lim
+                (max (- (point) 1000) (point-min))))
+           (c-backward-syntactic-ws cfd-cbsw-lim)
+           (setq cfd-re-match
+                 (if (or (bobp) (> (point) cfd-cbsw-lim))
+                     (point)
+                   (point-min))))  ; Set BOB case if the token's too far back.
+         ))
 
      ;; Choose whichever match is closer to the start.
      (if (< cfd-re-match cfd-prop-match)
@@ -6410,7 +6454,7 @@ comment at the start of cc-engine.el for more info."
            (while (and (not (bobp))
                        (c-got-face-at (1- (point)) c-literal-faces))
              (goto-char (previous-single-property-change
-                         (point) 'face nil (point-min))))
+                         (point) 'face nil (point-min)))) ; No limit.  FIXME, perhaps?  2020-12-07.
 
            ;; XEmacs doesn't fontify the quotes surrounding string
            ;; literals.
@@ -6482,12 +6526,15 @@ comment at the start of cc-engine.el for more info."
         (c-invalidate-find-decl-cache cfd-start-pos)
 
         (setq syntactic-pos (point))
-        (unless (eq syntactic-pos c-find-decl-syntactic-pos)
+        (unless
+            (eq syntactic-pos c-find-decl-syntactic-pos)
           ;; Don't have to do this if the cache is relevant here,
           ;; typically if the same line is refontified again.  If
           ;; we're just some syntactic whitespace further down we can
           ;; still use the cache to limit the skipping.
-          (c-backward-syntactic-ws c-find-decl-syntactic-pos))
+          (c-backward-syntactic-ws
+           (max (or c-find-decl-syntactic-pos (point-min))
+                (- (point) 10000) (point-min))))
 
         ;; If we hit `c-find-decl-syntactic-pos' and
         ;; `c-find-decl-match-pos' is set then we install the cached
@@ -6613,7 +6660,8 @@ comment at the start of cc-engine.el for more info."
           ;; syntactic ws.
           (when (and cfd-match-pos (< cfd-match-pos syntactic-pos))
             (goto-char syntactic-pos)
-            (c-forward-syntactic-ws)
+            (c-forward-syntactic-ws
+             (min (+ (point) 2000) (point-max)))
             (and cfd-continue-pos
                  (< cfd-continue-pos (point))
                  (setq cfd-token-pos (point))))
@@ -6654,7 +6702,8 @@ comment at the start of cc-engine.el for more info."
                         ;; can't be nested, and that's already been done in
                         ;; `c-find-decl-prefix-search'.
                         (when (> cfd-continue-pos cfd-token-pos)
-                          (c-forward-syntactic-ws)
+                          (c-forward-syntactic-ws
+                           (min (+ (point) 2000) (point-max)))
                           (setq cfd-token-pos (point)))
 
                         ;; Continue if the following token fails the
@@ -8262,7 +8311,8 @@ comment at the start of cc-engine.el for more info."
         ;; typically called from `c-forward-type' in this case, and
         ;; the caller only wants the top level type that it finds to
         ;; be promoted.
-        c-promote-possible-types)
+        c-promote-possible-types
+        (lim+ (c-determine-+ve-limit 500)))
     (while
         (and
          (looking-at c-identifier-key)
@@ -8292,7 +8342,7 @@ comment at the start of cc-engine.el for more info."
 
                  ;; Handle a C++ operator or template identifier.
                  (goto-char id-end)
-                 (c-forward-syntactic-ws)
+                 (c-forward-syntactic-ws lim+)
                  (cond ((eq (char-before id-end) ?e)
                         ;; Got "... ::template".
                         (let ((subres (c-forward-name)))
@@ -8322,13 +8372,13 @@ comment at the start of cc-engine.el for more info."
                                              (looking-at "::")
                                              (progn
                                                (goto-char (match-end 0))
-                                               (c-forward-syntactic-ws)
+                                               (c-forward-syntactic-ws lim+)
                                                (eq (char-after) ?*))
                                              (progn
                                                (forward-char)
                                                t))))
                             (while (progn
-                                     (c-forward-syntactic-ws)
+                                     (c-forward-syntactic-ws lim+)
                                      (setq pos (point))
                                      (looking-at c-opt-type-modifier-key))
                               (goto-char (match-end 1))))))
@@ -8338,7 +8388,7 @@ comment at the start of cc-engine.el for more info."
                         (setq c-last-identifier-range
                               (cons (point) (match-end 0)))
                         (goto-char (match-end 0))
-                        (c-forward-syntactic-ws)
+                        (c-forward-syntactic-ws lim+)
                         (setq pos (point)
                               res 'operator)))
 
@@ -8352,7 +8402,7 @@ comment at the start of cc-engine.el for more info."
                (setq c-last-identifier-range
                      (cons id-start id-end)))
              (goto-char id-end)
-             (c-forward-syntactic-ws)
+             (c-forward-syntactic-ws lim+)
              (setq pos (point)
                    res t)))
 
@@ -8368,7 +8418,7 @@ comment at the start of cc-engine.el for more info."
                ;; cases with tricky syntactic whitespace that aren't
                ;; covered in `c-identifier-key'.
                (goto-char (match-end 0))
-               (c-forward-syntactic-ws)
+               (c-forward-syntactic-ws lim+)
                t)
 
               ((and c-recognize-<>-arglists
@@ -8377,7 +8427,7 @@ comment at the start of cc-engine.el for more info."
                (when (let (c-last-identifier-range)
                        (c-forward-<>-arglist nil))
 
-                 (c-forward-syntactic-ws)
+                 (c-forward-syntactic-ws lim+)
                  (unless (eq (char-after) ?\()
                    (setq c-last-identifier-range nil)
                    (c-add-type start (1+ pos)))
@@ -8392,7 +8442,7 @@ comment at the start of cc-engine.el for more info."
                        (when (and c-record-type-identifiers id-start)
                          (c-record-ref-id (cons id-start id-end)))
                        (forward-char 2)
-                       (c-forward-syntactic-ws)
+                       (c-forward-syntactic-ws lim+)
                        t)
 
                    (when (and c-record-type-identifiers id-start
@@ -8817,7 +8867,7 @@ comment at the start of cc-engine.el for more info."
     (or res (goto-char here))
     res))
 
-(defmacro c-back-over-list-of-member-inits ()
+(defmacro c-back-over-list-of-member-inits (limit)
   ;; Go back over a list of elements, each looking like:
   ;; <symbol> (<expression>) ,
   ;; or <symbol> {<expression>} , (with possibly a <....> expressions
@@ -8826,21 +8876,21 @@ comment at the start of cc-engine.el for more info."
   ;; a comma.  If either of <symbol> or bracketed <expression> is missing,
   ;; throw nil to 'level.  If the terminating } or ) is unmatched, throw nil
   ;; to 'done.  This is not a general purpose macro!
-  '(while (eq (char-before) ?,)
+  `(while (eq (char-before) ?,)
      (backward-char)
-     (c-backward-syntactic-ws)
+     (c-backward-syntactic-ws ,limit)
      (when (not (memq (char-before) '(?\) ?})))
        (throw 'level nil))
      (when (not (c-go-list-backward))
        (throw 'done nil))
-     (c-backward-syntactic-ws)
+     (c-backward-syntactic-ws ,limit)
      (while (eq (char-before) ?>)
        (when (not (c-backward-<>-arglist nil))
          (throw 'done nil))
-       (c-backward-syntactic-ws))
+       (c-backward-syntactic-ws ,limit))
      (when (not (c-back-over-compound-identifier))
        (throw 'level nil))
-     (c-backward-syntactic-ws)))
+     (c-backward-syntactic-ws ,limit)))
 
 (defun c-back-over-member-initializers (&optional limit)
   ;; Test whether we are in a C++ member initializer list, and if so, go back
@@ -8859,14 +8909,14 @@ comment at the start of cc-engine.el for more info."
             (catch 'done
               (setq level-plausible
                     (catch 'level
-                      (c-backward-syntactic-ws)
+                      (c-backward-syntactic-ws limit)
                       (when (memq (char-before) '(?\) ?}))
                         (when (not (c-go-list-backward))
                           (throw 'done nil))
-                        (c-backward-syntactic-ws))
+                        (c-backward-syntactic-ws limit))
                       (when (c-back-over-compound-identifier)
-                        (c-backward-syntactic-ws))
-                      (c-back-over-list-of-member-inits)
+                        (c-backward-syntactic-ws limit))
+                      (c-back-over-list-of-member-inits limit)
                       (and (eq (char-before) ?:)
                            (save-excursion
                              (c-backward-token-2)
@@ -8880,14 +8930,14 @@ comment at the start of cc-engine.el for more info."
                 (setq level-plausible
                       (catch 'level
                         (goto-char pos)
-                        (c-backward-syntactic-ws)
+                        (c-backward-syntactic-ws limit)
                         (when (not (c-back-over-compound-identifier))
                           (throw 'level nil))
-                        (c-backward-syntactic-ws)
-                        (c-back-over-list-of-member-inits)
+                        (c-backward-syntactic-ws limit)
+                        (c-back-over-list-of-member-inits limit)
                         (and (eq (char-before) ?:)
                              (save-excursion
-                               (c-backward-token-2)
+                               (c-backward-token-2 nil nil limit)
                                (not (looking-at c-:$-multichar-token-regexp)))
                              (c-just-after-func-arglist-p)))))
 
@@ -12016,7 +12066,7 @@ comment at the start of cc-engine.el for more info."
         (goto-char haskell-op-pos))
 
       (while (and (eq res 'maybe)
-                  (progn (c-backward-syntactic-ws)
+                  (progn (c-backward-syntactic-ws lim)
                          (> (point) closest-lim))
                   (not (bobp))
                   (progn (backward-char)
@@ -12721,7 +12771,7 @@ comment at the start of cc-engine.el for more info."
          literal char-before-ip before-ws-ip char-after-ip macro-start
          in-macro-expr c-syntactic-context placeholder
          step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
-         containing-<
+         tmp-pos2 containing-<
          ;; The following record some positions for the containing
          ;; declaration block if we're directly within one:
          ;; `containing-decl-open' is the position of the open
@@ -12787,7 +12837,7 @@ comment at the start of cc-engine.el for more info."
                   (setq paren-state (cons containing-sexp paren-state)
                         containing-sexp nil)))
               (setq lim (1+ containing-sexp))))
-        (setq lim (point-min)))
+        (setq lim (c-determine-limit 1000)))
 
       ;; If we're in a parenthesis list then ',' delimits the
       ;; "statements" rather than being an operator (with the
@@ -13029,7 +13079,9 @@ comment at the start of cc-engine.el for more info."
        ;; CASE 4: In-expression statement.  C.f. cases 7B, 16A and
        ;; 17E.
        ((setq placeholder (c-looking-at-inexpr-block
-                           (c-safe-position containing-sexp paren-state)
+                           (or
+                            (c-safe-position containing-sexp paren-state)
+                            (c-determine-limit 1000 containing-sexp))
                            containing-sexp
                            ;; Have to turn on the heuristics after
                            ;; the point even though it doesn't work
@@ -13154,7 +13206,8 @@ comment at the start of cc-engine.el for more info."
          ;; init lists can, in practice, be very large.
          ((save-excursion
             (when (and (c-major-mode-is 'c++-mode)
-                       (setq placeholder (c-back-over-member-initializers)))
+                       (setq placeholder (c-back-over-member-initializers
+                                          lim)))
               (setq tmp-pos (point))))
           (if (= (c-point 'bosws) (1+ tmp-pos))
                 (progn
@@ -13473,7 +13526,7 @@ comment at the start of cc-engine.el for more info."
          ;; CASE 5I: ObjC method definition.
          ((and c-opt-method-key
                (looking-at c-opt-method-key))
-          (c-beginning-of-statement-1 nil t)
+          (c-beginning-of-statement-1 (c-determine-limit 1000) t)
           (if (= (point) indent-point)
               ;; Handle the case when it's the first (non-comment)
               ;; thing in the buffer.  Can't look for a 'same return
@@ -13546,7 +13599,16 @@ comment at the start of cc-engine.el for more info."
                           (if (>= (point) indent-point)
                               (throw 'not-in-directive t))
                           (setq placeholder (point)))
-                        nil)))))
+                        nil))
+                 (and macro-start
+                      (not (c-beginning-of-statement-1 lim nil nil nil t))
+                      (setq placeholder
+                            (let ((ps-top (car paren-state)))
+                              (if (consp ps-top)
+                                  (progn
+                                    (goto-char (cdr ps-top))
+                                    (c-forward-syntactic-ws indent-point))
+                                (point-min))))))))
           ;; For historic reasons we anchor at bol of the last
           ;; line of the previous declaration.  That's clearly
           ;; highly bogus and useless, and it makes our lives hard
@@ -13595,31 +13657,47 @@ comment at the start of cc-engine.el for more info."
                (eq (char-before) ?<)
                (not (and c-overloadable-operators-regexp
                          (c-after-special-operator-id lim))))
-          (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
+          (c-beginning-of-statement-1
+           (or
+            (c-safe-position (point) paren-state)
+            (c-determine-limit 1000)))
           (c-add-syntax 'template-args-cont (c-point 'boi)))
 
          ;; CASE 5Q: we are at a statement within a macro.
-         (macro-start
-          (c-beginning-of-statement-1 containing-sexp)
+         ((and
+           macro-start
+           (save-excursion
+             (prog1
+                 (not (eq (c-beginning-of-statement-1
+                           (or containing-sexp (c-determine-limit 1000))
+                           nil nil nil t)
+                          nil)))
+               (setq placeholder (point))))
+          (goto-char placeholder)
           (c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
 
-         ;;CASE 5N: We are at a topmost continuation line and the only
+         ;;CASE 5S: We are at a topmost continuation line and the only
          ;;preceding items are annotations.
          ((and (c-major-mode-is 'java-mode)
                (setq placeholder (point))
-               (c-beginning-of-statement-1)
+               (c-beginning-of-statement-1 lim)
                (progn
-                 (while (and (c-forward-annotation))
-                   (c-forward-syntactic-ws))
+                 (while (and (setq tmp-pos (point))
+                             (< (point) placeholder)
+                             (c-forward-annotation))
+                   (c-forward-syntactic-ws)
+                   (setq tmp-pos2 tmp-pos))
                  t)
                (prog1
                    (>= (point) placeholder)
                  (goto-char placeholder)))
-          (c-add-syntax 'annotation-top-cont (c-point 'boi)))
+          (c-add-syntax 'annotation-top-cont (c-point 'boi tmp-pos2)))
 
          ;; CASE 5M: we are at a topmost continuation line
          (t
-          (c-beginning-of-statement-1 (c-safe-position (point) paren-state))
+          (c-beginning-of-statement-1
+           (or (c-safe-position (point) paren-state)
+               (c-determine-limit 1000)))
           (when (c-major-mode-is 'objc-mode)
             (setq placeholder (point))
             (while (and (c-forward-objc-directive)
@@ -13675,8 +13753,9 @@ comment at the start of cc-engine.el for more info."
                    (setq tmpsymbol '(block-open . inexpr-statement)
                          placeholder
                          (cdr-safe (c-looking-at-inexpr-block
-                                    (c-safe-position containing-sexp
-                                                     paren-state)
+                                    (or
+                                     (c-safe-position containing-sexp paren-state)
+                                     (c-determine-limit 1000 containing-sexp))
                                     containing-sexp)))
                    ;; placeholder is nil if it's a block directly in
                    ;; a function arglist.  That makes us skip out of
@@ -13808,7 +13887,9 @@ comment at the start of cc-engine.el for more info."
                           (setq placeholder (c-guess-basic-syntax))))
               (setq c-syntactic-context placeholder)
             (c-beginning-of-statement-1
-             (c-safe-position (1- containing-sexp) paren-state))
+             (or
+              (c-safe-position (1- containing-sexp) paren-state)
+              (c-determine-limit 1000 (1- containing-sexp))))
             (c-forward-token-2 0)
             (while (cond
                     ((looking-at c-specifier-key)
@@ -13842,7 +13923,8 @@ comment at the start of cc-engine.el for more info."
               (c-add-syntax 'brace-list-close (point))
             (setq lim (or (save-excursion
                             (and
-                             (c-back-over-member-initializers)
+                             (c-back-over-member-initializers
+                              (c-determine-limit 1000))
                              (point)))
                           (c-most-enclosing-brace state-cache (point))))
             (c-beginning-of-statement-1 lim nil nil t)
@@ -13875,7 +13957,8 @@ comment at the start of cc-engine.el for more info."
                 (c-add-syntax 'brace-list-intro (point))
               (setq lim (or (save-excursion
                               (and
-                               (c-back-over-member-initializers)
+                               (c-back-over-member-initializers
+                                (c-determine-limit 1000))
                                (point)))
                             (c-most-enclosing-brace state-cache (point))))
               (c-beginning-of-statement-1 lim nil nil t)
@@ -13931,7 +14014,9 @@ comment at the start of cc-engine.el for more info."
          ;; CASE 16A: closing a lambda defun or an in-expression
          ;; block?  C.f. cases 4, 7B and 17E.
          ((setq placeholder (c-looking-at-inexpr-block
-                             (c-safe-position containing-sexp paren-state)
+                             (or
+                              (c-safe-position containing-sexp paren-state)
+                              (c-determine-limit 1000 containing-sexp))
                              nil))
           (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
                               'inline-close
@@ -14094,7 +14179,9 @@ comment at the start of cc-engine.el for more info."
          ;; CASE 17E: first statement in an in-expression block.
          ;; C.f. cases 4, 7B and 16A.
          ((setq placeholder (c-looking-at-inexpr-block
-                             (c-safe-position containing-sexp paren-state)
+                             (or
+                              (c-safe-position containing-sexp paren-state)
+                              (c-determine-limit 1000 containing-sexp))
                              nil))
           (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
                               'defun-block-intro
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index bb7e5bea6e6..e403c49e398 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -947,7 +947,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
     ;; closest token before the region.
     (save-excursion
       (let ((pos (point)))
-        (c-backward-syntactic-ws)
+        (c-backward-syntactic-ws (max (- (point) 500) (point-min)))
         (c-clear-char-properties
          (if (and (not (bobp))
                   (memq (c-get-char-property (1- (point)) 'c-type)
@@ -969,7 +969,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
     ;; The declared identifiers are font-locked correctly as types, if
     ;; that is what they are.
     (let ((prop (save-excursion
-                  (c-backward-syntactic-ws)
+                  (c-backward-syntactic-ws (max (- (point) 500) (point-min)))
                   (unless (bobp)
                     (c-get-char-property (1- (point)) 'c-type)))))
       (when (memq prop '(c-decl-id-start c-decl-type-start))
@@ -1008,66 +1008,75 @@ casts and declarations are fontified.  Used on level 2 and higher."
              (boundp 'parse-sexp-lookup-properties)))
           (c-parse-and-markup-<>-arglists t)
           c-restricted-<>-arglists
-          id-start id-end id-face pos kwd-sym)
+          id-start id-end id-face pos kwd-sym
+          old-pos)
 
       (while (and (< (point) limit)
-                  (re-search-forward c-opt-<>-arglist-start limit t))
-
-        (setq id-start (match-beginning 1)
-              id-end (match-end 1)
-              pos (point))
-
-        (goto-char id-start)
-        (unless (c-skip-comments-and-strings limit)
-          (setq kwd-sym nil
-                c-restricted-<>-arglists nil
-                id-face (get-text-property id-start 'face))
-
-          (if (cond
-               ((eq id-face 'font-lock-type-face)
-                ;; The identifier got the type face so it has already been
-                ;; handled in `c-font-lock-declarations'.
-                nil)
-
-               ((eq id-face 'font-lock-keyword-face)
-                (when (looking-at c-opt-<>-sexp-key)
-                  ;; There's a special keyword before the "<" that tells
-                  ;; that it's an angle bracket arglist.
-                  (setq kwd-sym (c-keyword-sym (match-string 1)))))
-
-               (t
-                ;; There's a normal identifier before the "<".  If we're not in
-                ;; a declaration context then we set `c-restricted-<>-arglists'
-                ;; to avoid recognizing templates in function calls like "foo (a
-                ;; < b, c > d)".
-                (c-backward-syntactic-ws)
-                (when (and (memq (char-before) '(?\( ?,))
-                           (not (eq (get-text-property (1- (point)) 'c-type)
-                                    'c-decl-arg-start)))
-                  (setq c-restricted-<>-arglists t))
-                t))
+                  (setq old-pos (point))
+                  (c-syntactic-re-search-forward "<" limit t nil t))
+        (setq pos (point))
+        (save-excursion
+          (backward-char)
+          (c-backward-syntactic-ws old-pos)
+          (if (re-search-backward
+               (concat "\\(\\`\\|" c-nonsymbol-key "\\)\\(" c-symbol-key"\\)\\=")
+               old-pos t)
+              (setq id-start (match-beginning 2)
+                    id-end (match-end 2))
+            (setq id-start nil id-end nil)))
+
+        (when id-start
+          (goto-char id-start)
+          (unless (c-skip-comments-and-strings limit)
+            (setq kwd-sym nil
+                  c-restricted-<>-arglists nil
+                  id-face (get-text-property id-start 'face))
+
+            (if (cond
+                 ((eq id-face 'font-lock-type-face)
+                  ;; The identifier got the type face so it has already been
+                  ;; handled in `c-font-lock-declarations'.
+                  nil)
 
-              (progn
-                (goto-char (1- pos))
-                ;; Check for comment/string both at the identifier and
-                ;; at the "<".
-                (unless (c-skip-comments-and-strings limit)
-
-                  (c-fontify-types-and-refs ()
-                    (when (c-forward-<>-arglist (c-keyword-member
-                                                 kwd-sym 'c-<>-type-kwds))
-                      (when (and c-opt-identifier-concat-key
-                                 (not (get-text-property id-start 'face)))
-                        (c-forward-syntactic-ws)
-                        (cond ((looking-at c-opt-identifier-concat-key)
-                               (c-put-font-lock-face id-start id-end
-                                                     c-reference-face-name))
-                              ((eq (char-after) ?\())
-                              (t (c-put-font-lock-face id-start id-end
-                                                       'font-lock-type-face))))))
-
-                  (goto-char pos)))
-            (goto-char pos))))))
+                 ((eq id-face 'font-lock-keyword-face)
+                  (when (looking-at c-opt-<>-sexp-key)
+                    ;; There's a special keyword before the "<" that tells
+                    ;; that it's an angle bracket arglist.
+                    (setq kwd-sym (c-keyword-sym (match-string 2)))))
+
+                 (t
+                  ;; There's a normal identifier before the "<".  If we're not in
+                  ;; a declaration context then we set `c-restricted-<>-arglists'
+                  ;; to avoid recognizing templates in function calls like "foo (a
+                  ;; < b, c > d)".
+                  (c-backward-syntactic-ws)
+                  (when (and (memq (char-before) '(?\( ?,))
+                             (not (eq (get-text-property (1- (point)) 'c-type)
+                                      'c-decl-arg-start)))
+                    (setq c-restricted-<>-arglists t))
+                  t))
+
+                (progn
+                  (goto-char (1- pos))
+                  ;; Check for comment/string both at the identifier and
+                  ;; at the "<".
+                  (unless (c-skip-comments-and-strings limit)
+
+                    (c-fontify-types-and-refs ()
+                      (when (c-forward-<>-arglist (c-keyword-member
+                                                   kwd-sym 'c-<>-type-kwds))
+                        (when (and c-opt-identifier-concat-key
+                                   (not (get-text-property id-start 'face)))
+                          (c-forward-syntactic-ws)
+                          (cond ((looking-at c-opt-identifier-concat-key)
+                                 (c-put-font-lock-face id-start id-end
+                                                       c-reference-face-name))
+                                ((eq (char-after) ?\())
+                                (t (c-put-font-lock-face id-start id-end
+                                                         'font-lock-type-face))))))
+
+                    (goto-char pos)))
+              (goto-char pos)))))))
   nil)
 
 (defun c-font-lock-declarators (limit list types not-top
@@ -1496,7 +1505,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
                  ;; Check we haven't missed a preceding "typedef".
                  (when (not (looking-at c-typedef-key))
-                   (c-backward-syntactic-ws)
+                   (c-backward-syntactic-ws
+                    (max (- (point) 1000) (point-min)))
                    (c-backward-token-2)
                    (or (looking-at c-typedef-key)
                        (goto-char start-pos)))
@@ -1536,8 +1546,10 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                      (c-backward-token-2)
                                      (and
                                       (not (looking-at c-opt-<>-sexp-key))
-                                      (progn (c-backward-syntactic-ws)
-                                             (memq (char-before) '(?\( ?,)))
+                                      (progn
+                                        (c-backward-syntactic-ws
+                                         (max (- (point) 1000) (point-min)))
+                                        (memq (char-before) '(?\( ?,)))
                                       (not (eq (c-get-char-property (1- (point))
                                                                     'c-type)
                                                'c-decl-arg-start))))))
@@ -2295,7 +2307,8 @@ need for `c-font-lock-extra-types'.")
                   (and c-colon-type-list-re
                        (c-go-up-list-backward)
                        (eq (char-after) ?{)
-                       (eq (car (c-beginning-of-decl-1)) 'same)
+                       (eq (car (c-beginning-of-decl-1
+                                 (c-determine-limit 1000))) 'same)
                        (looking-at c-colon-type-list-re)))
                 ;; Inherited protected member: leave unfontified
                 )
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index d6089ea2950..4d1aeaa5cb9 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -699,6 +699,7 @@ It's assumed to not contain any submatchers."
   ;; The same thing regarding Unicode identifiers applies here as to
   ;; `c-symbol-key'.
   t (concat "[" (c-lang-const c-nonsymbol-chars) "]"))
+(c-lang-defvar c-nonsymbol-key (c-lang-const c-nonsymbol-key))
 
 (c-lang-defconst c-identifier-ops
   "The operators that make up fully qualified identifiers.  nil in
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 5e8cf6161ef..7a111017074 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -499,11 +499,14 @@ preferably use the `c-mode-menu' language constant directly."
   (save-excursion
     (when (< beg end)
       (goto-char beg)
+      (let ((lim (c-determine-limit 1000))
+            (lim+ (c-determine-+ve-limit 1000 end)))
       (when
           (and (not (bobp))
-               (progn (c-backward-syntactic-ws) (eq (point) beg))
+               (progn (c-backward-syntactic-ws lim) (eq (point) beg))
                (/= (skip-chars-backward c-symbol-chars (1- (point))) 0)
-               (progn (goto-char beg) (c-forward-syntactic-ws) (<= (point) end))
+               (progn (goto-char beg) (c-forward-syntactic-ws lim+)
+                      (<= (point) end))
                (> (point) beg)
                (goto-char end)
                (looking-at c-symbol-char-key))
@@ -514,14 +517,14 @@ preferably use the `c-mode-menu' language constant directly."
       (goto-char end)
       (when
           (and (not (eobp))
-               (progn (c-forward-syntactic-ws) (eq (point) end))
+               (progn (c-forward-syntactic-ws lim+) (eq (point) end))
                (looking-at c-symbol-char-key)
-               (progn (c-backward-syntactic-ws) (>= (point) beg))
+               (progn (c-backward-syntactic-ws lim) (>= (point) beg))
                (< (point) end)
                (/= (skip-chars-backward c-symbol-chars (1- (point))) 0))
         (goto-char (1+ end))
         (c-end-of-current-token)
-        (c-unfind-type (buffer-substring-no-properties end (point)))))))
+        (c-unfind-type (buffer-substring-no-properties end (point))))))))
 
 ;; c-maybe-stale-found-type records a place near the region being
 ;; changed where an element of `found-types' might become stale.  It
@@ -1996,7 +1999,7 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                 ;; We search for appropriate c-type properties "near"
                 ;; the change.  First, find an appropriate boundary
                 ;; for this property search.
-                (let (lim
+                (let (lim lim-2
                       type type-pos
                       marked-id term-pos
                       (end1
@@ -2007,8 +2010,11 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                   (when (>= end1 beg) ; Don't hassle about changes entirely in
                                         ; comments.
                     ;; Find a limit for the search for a `c-type' property
+                    ;; Point is currently undefined.  A `goto-char' somewhere is needed.  (2020-12-06).
+                    (setq lim-2 (c-determine-limit 1000 (point) ; that is wrong.  FIXME!!!  (2020-12-06)
+                                                   ))
                     (while
-                        (and (/= (skip-chars-backward "^;{}") 0)
+                        (and (/= (skip-chars-backward "^;{}" lim-2) 0)
                              (> (point) (point-min))
                              (memq (c-get-char-property (1- (point)) 'face)
                                    '(font-lock-comment-face font-lock-string-face))))
@@ -2032,7 +2038,8 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                                 (buffer-substring-no-properties (point) type-pos)))
 
                         (goto-char end1)
-                        (skip-chars-forward "^;{}") ; FIXME!!!  loop for
+                        (setq lim-2 (c-determine-+ve-limit 1000))
+                        (skip-chars-forward "^;{}" lim-2) ; FIXME!!!  loop for
                                         ; comment, maybe
                         (setq lim (point))
                         (setq term-pos
@@ -2270,9 +2277,11 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
   ;; preserved.
   (goto-char pos)
   (let ((lit-start (c-literal-start))
+        (lim (c-determine-limit 1000))
         enclosing-attribute pos1)
     (unless lit-start
-      (c-backward-syntactic-ws)
+      (c-backward-syntactic-ws
+       lim)
       (when (setq enclosing-attribute (c-enclosing-c++-attribute))
         (goto-char (car enclosing-attribute))) ; Only happens in C++ Mode.
       (when (setq pos1 (c-on-identifier))
@@ -2296,14 +2305,14 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                            (setq pos1 (c-on-identifier))
                            (goto-char pos1)
                            (progn
-                             (c-backward-syntactic-ws)
+                             (c-backward-syntactic-ws lim)
                              (eq (char-before) ?\())
                            (c-fl-decl-end (1- (point))))
-                        (c-backward-syntactic-ws)
+                        (c-backward-syntactic-ws lim)
                         (point))))
                  (and (progn (c-forward-syntactic-ws lim)
                              (not (eobp)))
-                      (c-backward-syntactic-ws)
+                      (c-backward-syntactic-ws lim)
                       (point)))))))))
 
 (defun c-change-expand-fl-region (_beg _end _old-len)
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 9e6f9527ca1..8772ed06324 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -575,7 +575,8 @@ comment styles:
 
  javadoc -- Javadoc style for \"/** ... */\" comments (default in Java mode).
  autodoc -- Pike autodoc style for \"//! ...\" comments (default in Pike mode).
- gtkdoc  -- GtkDoc style for \"/** ... **/\" comments (default in C and C++ modes).
+ gtkdoc  -- GtkDoc style for \"/** ... **/\" comments
+                                                   (default in C and C++ modes).
  doxygen -- Doxygen style.
 
 The value may also be a list of doc comment styles, in which case all
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index ae839a66220..87542ea133c 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -232,7 +232,9 @@ Versions 5.2 ... 5.20 behaved as if this were nil."
   :group 'cperl-indentation-details)
 
 (defcustom cperl-indent-subs-specially t
-  "Non-nil means indent subs that are inside other blocks (hash values, for example) relative to the beginning of the \"sub\" keyword, rather than relative to the statement that contains the declaration."
+  "If non-nil, indent subs inside other blocks relative to \"sub\" keyword.
+Otherwise, indent them relative to statement that contains the declaration.
+This applies to, for example, hash values."
   :type 'boolean
   :group 'cperl-indentation-details)
 
@@ -3694,13 +3696,14 @@ the sections using `cperl-pod-head-face', `cperl-pod-face',
                ;;    ;; "\\([^= \t0-9$@%&]\\|[ \t]+[^ \t\n0-9$@%&]\\)" ; 6 + 1
                ;;    "\\(\\)"           ; To preserve count of pars :-( 6 + 1
                ;;  "\\)"
-               ((match-beginning 3)     ; 2 + 1
+               ((match-beginning 3)     ; 2 + 1: found "<<", detect its type
                 (setq b (point)
                       tb (match-beginning 0)
                       c (and            ; not HERE-DOC
                          (match-beginning 6)
                          (save-match-data
                            (or (looking-at "[ \t]*(") ; << function_call()
+                               (looking-at ">>")      ; <<>> operator
                                (save-excursion ; 1 << func_name, or $foo << 10
                                  (condition-case nil
                                      (progn
@@ -7260,6 +7263,7 @@ __DATA__	Ends program source.
 __FILE__        Current (source) filename.
 __LINE__        Current line in current source.
 __PACKAGE__     Current package.
+__SUB__ Current sub.
 ARGV    Default multi-file input filehandle.  <ARGV> is a synonym for <>.
 ARGVOUT Output filehandle with -i flag.
 BEGIN { ... }   Immediately executed (during compilation) piece of code.
@@ -7525,14 +7529,17 @@ use PACKAGE [SYMBOL1, ...]  Compile-time `require' with consequent `import'.
 prototype \\&SUB        Returns prototype of the function given a reference.
 =head1          Top-level heading.
 =head2          Second-level heading.
-=head3          Third-level heading (is there such?).
+=head3          Third-level heading.
+=head4          Fourth-level heading.
 =over [ NUMBER ]        Start list.
 =item [ TITLE ]         Start new item in the list.
 =back           End list.
 =cut            Switch from POD to Perl.
 =pod            Switch from Perl to POD.
-=begin          Switch from Perl6 to POD.
-=end            Switch from POD to Perl6.
+=begin formatname       Start directly formatted region.
+=end formatname End directly formatted region.
+=for formatname text    Paragraph in special format.
+=encoding encodingname  Encoding of the document.
 ")
 
 (defun cperl-switch-to-doc-buffer (&optional interactive)
diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index b7e0c452288..0e515530852 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -682,7 +682,7 @@ otherwise build the summary from TYPE and SYMBOL."
              (xref-make-elisp-location symbol type file)))
 
 (defvar elisp-xref-find-def-functions nil
-  "List of functions to be run from `elisp--xref-find-definitions' to add additional xrefs.
+  "List of functions run from `elisp--xref-find-definitions' to add more xrefs.
 Called with one arg; the symbol whose definition is desired.
 Each function should return a list of xrefs, or nil; the first
 non-nil result supersedes the xrefs produced by
diff --git a/lisp/progmodes/flymake-proc.el b/lisp/progmodes/flymake-proc.el
index 152dc725c74..744c110f6b0 100644
--- a/lisp/progmodes/flymake-proc.el
+++ b/lisp/progmodes/flymake-proc.el
@@ -120,8 +120,10 @@ This is an alist with elements of the form:
   REGEXP INIT [CLEANUP [NAME]]
 REGEXP is a regular expression that matches a file name.
 INIT is the init function to use.
-CLEANUP is the cleanup function to use, default `flymake-proc-simple-cleanup'.
-NAME is the file name function to use, default `flymake-proc-get-real-file-name'."
+CLEANUP is the cleanup function to use, default
+  `flymake-proc-simple-cleanup'.
+NAME is the file name function to use, default
+  `flymake-proc-get-real-file-name'."
   :group 'flymake
   :type '(alist :key-type (regexp :tag "File regexp")
                 :value-type
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index efa7b2ffbf1..40bb90d0f15 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -412,44 +412,46 @@ verify FILTER, a function, and sort them by COMPARE (using KEY)."
 (defun flymake-diag-region (buffer line &optional col)
   "Compute BUFFER's region (BEG . END) corresponding to LINE and COL.
 If COL is nil, return a region just for LINE.  Return nil if the
-region is invalid."
+region is invalid.  This function saves match data."
   (condition-case-unless-debug _err
       (with-current-buffer buffer
         (let ((line (min (max line 1)
                          (line-number-at-pos (point-max) 'absolute))))
           (save-excursion
-            (goto-char (point-min))
-            (forward-line (1- line))
-            (cl-flet ((fallback-bol
-                       ()
-                       (back-to-indentation)
-                       (if (eobp)
-                           (line-beginning-position 0)
-                         (point)))
-                      (fallback-eol
-                       (beg)
-                       (progn
-                         (end-of-line)
-                         (skip-chars-backward " \t\f\n" beg)
-                         (if (eq (point) beg)
-                             (line-beginning-position 2)
-                           (point)))))
-              (if (and col (cl-plusp col))
-                  (let* ((beg (progn (forward-char (1- col))
-                                     (point)))
-                         (sexp-end (ignore-errors (end-of-thing 'sexp)))
-                         (end (or (and sexp-end
-                                       (not (= sexp-end beg))
-                                       sexp-end)
-                                  (and (< (goto-char (1+ beg)) (point-max))
-                                       (point)))))
-                    (if end
-                        (cons beg end)
-                      (cons (setq beg (fallback-bol))
-                            (fallback-eol beg))))
-                (let* ((beg (fallback-bol))
-                       (end (fallback-eol beg)))
-                  (cons beg end)))))))
+            (save-match-data
+              (goto-char (point-min))
+              (forward-line (1- line))
+              (cl-flet ((fallback-bol
+                         ()
+                         (back-to-indentation)
+                         (if (eobp)
+                             (line-beginning-position 0)
+                           (point)))
+                        (fallback-eol
+                         (beg)
+                         (progn
+                           (end-of-line)
+                           (skip-chars-backward " \t\f\n" beg)
+                           (if (eq (point) beg)
+                               (line-beginning-position 2)
+                             (point)))))
+                (if (and col (cl-plusp col))
+                    (let* ((beg (progn (forward-char (1- col))
+                                       (point)))
+                           (sexp-end (or (ignore-errors (end-of-thing 'sexp))
+                                         (ignore-errors (end-of-thing 'symbol))))
+                           (end (or (and sexp-end
+                                         (not (= sexp-end beg))
+                                         sexp-end)
+                                    (and (< (goto-char (1+ beg)) (point-max))
+                                         (point)))))
+                      (if end
+                          (cons beg end)
+                        (cons (setq beg (fallback-bol))
+                              (fallback-eol beg))))
+                  (let* ((beg (fallback-bol))
+                         (end (fallback-eol beg)))
+                    (cons beg end))))))))
     (error (flymake-log :warning "Invalid region line=%s col=%s" line col)
            nil)))
 
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 4c248f771cd..99ca0a639a8 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -3009,7 +3009,7 @@ If NOPRESERVE is non-nil, window point is not restored after CUSTOM-DEFUN."
        (,custom-defun)
        (gdb-update-buffer-name)
        ,@(when (not nopreserve)
-          '((set-window-start window start)
+          '((set-window-start window start t)
             (set-window-point window p))))))
 
 (defmacro def-gdb-trigger-and-handler (trigger-name gdb-command
@@ -3127,24 +3127,27 @@ See `def-gdb-auto-update-handler'."
   (concat "fullname=\\(" gdb--string-regexp "\\)"))
 
 (defun gdb-get-location (bptno line flag)
-  "Find the directory containing the relevant source file.
-Put in buffer and place breakpoint icon."
+  "Glean name of source file using `gdb-source-file-regexp', and visit it.
+Place breakpoint icon in its buffer."
   (goto-char (point-min))
   (catch 'file-not-found
-    (if (re-search-forward gdb-source-file-regexp nil t)
-        (delete (cons bptno "File not found") gdb-location-alist)
-      ;; FIXME: Why/how do we use (match-string 1) when the search failed?
-      (push (cons bptno (match-string 1)) gdb-location-alist)
-      (gdb-resync)
-      (unless (assoc bptno gdb-location-alist)
-        (push (cons bptno "File not found") gdb-location-alist)
-        (message-box "Cannot find source file for breakpoint location.
+    (let (source-file)
+      (if (re-search-forward gdb-source-file-regexp nil t)
+          (progn
+            (setq source-file (gdb-mi--c-string-from-string (match-string 1)))
+            (delete (cons bptno "File not found") gdb-location-alist)
+            (push (cons bptno source-file) gdb-location-alist))
+        (gdb-resync)
+        (unless (assoc bptno gdb-location-alist)
+          (push (cons bptno "File not found") gdb-location-alist)
+          (message-box "Cannot find source file for breakpoint location.
 Add directory to search path for source files using the GDB command, dir."))
-      (throw 'file-not-found nil))
-    (with-current-buffer (find-file-noselect (match-string 1))
-      (gdb-init-buffer)
-      ;; only want one breakpoint icon at each location
-      (gdb-put-breakpoint-icon (eq flag ?y) bptno (string-to-number line)))))
+        (throw 'file-not-found nil))
+      (with-current-buffer (find-file-noselect source-file)
+        (gdb-init-buffer)
+        ;; Only want one breakpoint icon at each location.
+        (gdb-put-breakpoint-icon (string-equal flag "y") bptno
+                                 (string-to-number line))))))
 
 (add-hook 'find-file-hook 'gdb-find-file-hook)
 
diff --git a/lisp/progmodes/hideif.el b/lisp/progmodes/hideif.el
index 7cbc9708fce..fb487f7e1f2 100644
--- a/lisp/progmodes/hideif.el
+++ b/lisp/progmodes/hideif.el
@@ -153,8 +153,8 @@ The first time we visit such a file, _XXX_HEADER_FILE_INCLUDED_ is
 undefined, and so nothing is hidden.  The next time we visit it, everything will
 be hidden.
 
-This behavior is generally undesirable.  If this option is non-nil, the outermost
-#if is always visible."
+This behavior is generally undesirable.  If this option is non-nil, the
+outermost #if is always visible."
   :type 'boolean
   :version "25.1")
 
@@ -304,7 +304,7 @@ Several variables affect how the hiding is done:
         ;; (C-c @ C) every time before hiding current buffer.
 ;;      (setq-local hide-ifdef-env
 ;;           (default-value 'hide-ifdef-env))
-        (set 'hide-ifdef-env (default-value 'hide-ifdef-env))
+        (setq hide-ifdef-env (default-value 'hide-ifdef-env))
         ;; Some C/C++ headers might have other ways to prevent reinclusion and
         ;; thus would like `hide-ifdef-expand-reinclusion-protection' to be nil.
         (setq-local hide-ifdef-expand-reinclusion-protection
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
index c313ad11792..bda4e60c55c 100644
--- a/lisp/progmodes/octave.el
+++ b/lisp/progmodes/octave.el
@@ -1605,8 +1605,9 @@ code line."
 
 (defun octave-eldoc-function-signatures (fn)
   (unless (equal fn (car octave-eldoc-cache))
-    (inferior-octave-send-list-and-digest
-     (list (format "print_usage ('%s');\n" fn)))
+    (while-no-input
+      (inferior-octave-send-list-and-digest
+       (list (format "print_usage ('%s');\n" fn))))
     (let (result)
       (dolist (line inferior-octave-output-list)
         ;; The help output has changed a few times in GNU Octave.
diff --git a/lisp/progmodes/project.el b/lisp/progmodes/project.el
index 0ed5f1f907c..5b58090de02 100644
--- a/lisp/progmodes/project.el
+++ b/lisp/progmodes/project.el
@@ -631,6 +631,7 @@ DIRS must contain directory names."
     (define-key map "g" 'project-find-regexp)
     (define-key map "G" 'project-or-external-find-regexp)
     (define-key map "r" 'project-query-replace-regexp)
+    (define-key map "x" 'project-execute-extended-command)
     map)
   "Keymap for project commands.")
 
@@ -1246,31 +1247,67 @@ It's also possible to enter an arbitrary directory not in the list."
   (project--ensure-read-project-list)
   (mapcar #'car project--list))
 
+;;;###autoload
+(defun project-execute-extended-command ()
+  "Execute an extended command in project root."
+  (declare (interactive-only command-execute))
+  (interactive)
+  (let ((default-directory (project-root (project-current t))))
+    (call-interactively #'execute-extended-command)))
+
 
 ;;; Project switching
 
 ;;;###autoload
-(defvar project-switch-commands
-  '((?f "Find file" project-find-file)
-    (?g "Find regexp" project-find-regexp)
-    (?d "Dired" project-dired)
-    (?v "VC-Dir" project-vc-dir)
-    (?e "Eshell" project-eshell))
-  "Alist mapping keys to project switching menu entries.
+(defcustom project-switch-commands
+  '((project-find-file "Find file")
+    (project-find-regexp "Find regexp")
+    (project-dired "Dired")
+    (project-vc-dir "VC-Dir")
+    (project-eshell "Eshell"))
+  "Alist mapping commands to descriptions.
 Used by `project-switch-project' to construct a dispatch menu of
 commands available upon \"switching\" to another project.
 
-Each element is of the form (KEY LABEL COMMAND), where COMMAND is the
-command to run when KEY is pressed.  LABEL is used to distinguish
-the menu entries in the dispatch menu.")
+Each element is of the form (COMMAND LABEL &optional KEY) where
+COMMAND is the command to run when KEY is pressed.  LABEL is used
+to distinguish the menu entries in the dispatch menu.  If KEY is
+absent, COMMAND must be bound in `project-prefix-map', and the
+key is looked up in that map."
+  :version "28.1"
+  :package-version '(project . "0.6.0")
+  :type '(repeat
+          (list
+           (symbol :tag "Command")
+           (string :tag "Label")
+           (choice :tag "Key to press"
+            (const :tag "Infer from the keymap" nil)
+            (character :tag "Explicit key")))))
+
+(defcustom project-switch-use-entire-map nil
+  "Make `project-switch-project' use entire `project-prefix-map'.
+If nil, `project-switch-project' will only recognize commands
+listed in `project-switch-commands' and signal an error when
+others are invoked.  Otherwise, all keys in `project-prefix-map'
+are legal even if they aren't listed in the dispatch menu."
+  :type 'boolean
+  :version "28.1")
 
 (defun project--keymap-prompt ()
   "Return a prompt for the project switching dispatch menu."
   (mapconcat
-   (pcase-lambda (`(,key ,label))
-     (format "[%s] %s"
-             (propertize (key-description `(,key)) 'face 'bold)
-             label))
+   (pcase-lambda (`(,cmd ,label ,key))
+     (when (characterp cmd) ; Old format, apparently user-customized.
+       (let ((tmp cmd))
+         ;; TODO: Add a deprecation warning, probably.
+         (setq cmd key
+               key tmp)))
+     (let ((key (if key
+                    (vector key)
+                  (where-is-internal cmd project-prefix-map t))))
+       (format "[%s] %s"
+               (propertize (key-description key) 'face 'bold)
+               label)))
    project-switch-commands
    "  "))
 
@@ -1283,13 +1320,31 @@ made from `project-switch-commands'.
 When called in a program, it will use the project corresponding
 to directory DIR."
   (interactive (list (project-prompt-project-dir)))
-  (let ((choice nil))
-    (while (not choice)
-      (setq choice (assq (read-event (project--keymap-prompt))
-                         project-switch-commands)))
+  (let ((commands-menu
+         (mapcar
+          (lambda (row)
+            (if (characterp (car row))
+                ;; Deprecated format.
+                ;; XXX: Add a warning about it?
+                (reverse row)
+              row))
+          project-switch-commands))
+        command)
+    (while (not command)
+      (let ((choice (read-event (project--keymap-prompt))))
+        (when (setq command
+                    (or (car
+                         (seq-find (lambda (row) (equal choice (nth 2 row)))
+                                   commands-menu))
+                        (lookup-key project-prefix-map (vector choice))))
+          (unless (or project-switch-use-entire-map
+                      (assq command commands-menu))
+            ;; TODO: Add some hint to the prompt, like "key not
+            ;; recognized" or something.
+            (setq command nil)))))
     (let ((default-directory dir)
           (project-current-inhibit-prompt t))
-      (call-interactively (nth 2 choice)))))
+      (call-interactively command))))
 
 (provide 'project)
 ;;; project.el ends here
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index d75944a702f..d58b32f3c3c 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1404,7 +1404,7 @@ With positive ARG search backwards, else search forwards."
          (line-beg-pos (line-beginning-position))
          (line-content-start (+ line-beg-pos (current-indentation)))
          (pos (point-marker))
-         (beg-indentation
+         (body-indentation
           (and (> arg 0)
                (save-excursion
                  (while (and
@@ -1415,9 +1415,16 @@ With positive ARG search backwards, else search forwards."
                      0))))
          (found
           (progn
-            (when (and (< arg 0)
-                       (python-info-looking-at-beginning-of-defun))
+            (when (and (python-info-looking-at-beginning-of-defun)
+                       (or (< arg 0)
+                           ;; If looking at beginning of defun, and if
+                           ;; pos is > line-content-start, ensure a
+                           ;; backward re search match this defun by
+                           ;; going to end of line before calling
+                           ;; re-search-fn bug#40563
+                           (and (> arg 0) (> pos line-content-start))))
               (end-of-line 1))
+
             (while (and (funcall re-search-fn
                                  python-nav-beginning-of-defun-regexp nil t)
                         (or (python-syntax-context-type)
@@ -1425,7 +1432,7 @@ With positive ARG search backwards, else search forwards."
                             ;; backwards by checking indentation.
                             (and (> arg 0)
                                  (not (= (current-indentation) 0))
-                                 (>= (current-indentation) beg-indentation)))))
+                                 (>= (current-indentation) body-indentation)))))
             (and (python-info-looking-at-beginning-of-defun)
                  (or (not (= (line-number-at-pos pos)
                              (line-number-at-pos)))
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index fbc6e424eb1..8cb0350dc06 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -75,7 +75,7 @@
 
 (defconst ruby-block-mid-re
   (regexp-opt ruby-block-mid-keywords)
-  "Regexp to match where the indentation gets shallower in middle of block statements.")
+  "Regexp for where the indentation gets shallower in middle of block statements.")
 
 (defconst ruby-block-op-keywords
   '("and" "or" "not")
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index b1abefe534e..f6e95b9cb6a 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -10112,7 +10112,8 @@ variables to build the path."
 ;; A modi is:  [module-name-string file-name begin-point]
 
 (defvar verilog-cache-enabled t
-  "Non-nil enables caching of signals, etc.  Set to nil for debugging to make things SLOW!")
+  "Non-nil enables caching of signals, etc.
+Set to nil for debugging to make things SLOW!")
 
 (defvar verilog-modi-cache-list nil
   "Cache of ((Module Function) Buf-Tick Buf-Modtime Func-Returns)...
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index a524bbaa223..562a357a8cb 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -186,7 +186,7 @@ and you want to simplify them for the mode line
   "Non-nil means display current function name in mode line.
 This makes a difference only if `which-function-mode' is non-nil.")
 
-(add-hook 'after-change-major-mode-hook 'which-func-ff-hook t)
+(add-hook 'after-change-major-mode-hook #'which-func-ff-hook t)
 
 (defun which-func-try-to-enable ()
   (unless (or (not which-function-mode)
@@ -216,7 +216,8 @@ It creates the Imenu index for the buffer, if necessary."
 (defun which-func-update ()
   ;; "Update the Which-Function mode display for all windows."
   ;; (walk-windows 'which-func-update-1 nil 'visible))
-  (which-func-update-1 (selected-window)))
+  (let ((non-essential t))
+    (which-func-update-1 (selected-window))))
 
 (defun which-func-update-1 (window)
   "Update the Which Function mode display for window WINDOW."
@@ -356,7 +357,7 @@ This function is meant to be called from `ediff-select-hook'."
     (when ediff-window-C
       (which-func-update-1 ediff-window-C))))
 
-(add-hook 'ediff-select-hook 'which-func-update-ediff-windows)
+(add-hook 'ediff-select-hook #'which-func-update-ediff-windows)
 
 (provide 'which-func)