8 files changed, 342 insertions, 130 deletions

diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index c05200b3898..de2543951b9 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1915,7 +1915,7 @@ with a brace block."
     (save-restriction
       (let ((start (point))
             (paren-state (c-parse-state))
-            lim pos end-pos encl-decl-block where)
+            lim pos end-pos where)
         ;; Narrow enclosing brace blocks out, as required by the values of
         ;; `c-defun-tactic', `near', and the position of point.
         (when (eq c-defun-tactic 'go-outward)
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index dd8f8afc6a3..85a4085e490 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -44,19 +44,12 @@
     (load "cc-bytecomp" nil t)))
 
 (eval-and-compile
-  (defvar c--mapcan-status
-    (cond ((and (fboundp 'mapcan)
-                (subrp (symbol-function 'mapcan)))
-           ;; XEmacs
-           'mapcan)
-          ((locate-file "cl-lib.elc" load-path)
-           ;; Emacs >= 24.3
-           'cl-mapcan)
-          (t
-           ;; Emacs <= 24.2
-           nil))))
-
-(cc-external-require (if (eq c--mapcan-status 'cl-mapcan) 'cl-lib 'cl))
+  (defvar c--cl-library
+    (if (locate-library "cl-lib")
+        'cl-lib
+      'cl)))
+
+(cc-external-require c--cl-library)
 ; was (cc-external-require 'cl).  ACM 2005/11/29.
 ; Changed from (eval-when-compile (require 'cl)) back to
 ; cc-external-require, 2015-08-12.
@@ -182,9 +175,12 @@ This variant works around bugs in `eval-when-compile' in various
   ;; The motivation for this macro is to avoid the irritating message
   ;; "function `mapcan' from cl package called at runtime" produced by Emacs.
   (cond
-   ((eq c--mapcan-status 'mapcan)
+   ((and (fboundp 'mapcan)
+         (subrp (symbol-function 'mapcan)))
+    ;; XEmacs and Emacs >= 26.
     `(mapcan ,fun ,liszt))
-   ((eq c--mapcan-status 'cl-mapcan)
+   ((eq c--cl-library 'cl-lib)
+    ;; Emacs >= 24.3, < 26.
     `(cl-mapcan ,fun ,liszt))
    (t
     ;; Emacs <= 24.2.  It would be nice to be able to distinguish between
@@ -193,13 +189,13 @@ This variant works around bugs in `eval-when-compile' in various
 
 (defmacro c--set-difference (liszt1 liszt2 &rest other-args)
   ;; Macro to smooth out the renaming of `set-difference' in Emacs 24.3.
-  (if (eq c--mapcan-status 'cl-mapcan)
+  (if (eq c--cl-library 'cl-lib)
       `(cl-set-difference ,liszt1 ,liszt2 ,@other-args)
     `(set-difference ,liszt1 ,liszt2 ,@other-args)))
 
 (defmacro c--intersection (liszt1 liszt2 &rest other-args)
   ;; Macro to smooth out the renaming of `intersection' in Emacs 24.3.
-  (if (eq c--mapcan-status 'cl-mapcan)
+  (if (eq c--cl-library 'cl-lib)
       `(cl-intersection ,liszt1 ,liszt2 ,@other-args)
     `(intersection ,liszt1 ,liszt2 ,@other-args)))
 
@@ -212,7 +208,7 @@ This variant works around bugs in `eval-when-compile' in various
 
   (defmacro c--delete-duplicates (cl-seq &rest cl-keys)
     ;; Macro to smooth out the renaming of `delete-duplicates' in Emacs 24.3.
-    (if (eq c--mapcan-status 'cl-mapcan)
+    (if (eq c--cl-library 'cl-lib)
         `(cl-delete-duplicates ,cl-seq ,@cl-keys)
       `(delete-duplicates ,cl-seq ,@cl-keys))))
 
@@ -1175,6 +1171,63 @@ been put there by c-put-char-property.  POINT remains unchanged."
                       nil ,from ,to ,value nil -property-))
     ;; GNU Emacs
     `(c-clear-char-property-with-value-function ,from ,to ,property ,value)))
+
+(defun c-clear-char-property-with-value-on-char-function (from to property
+                                                               value char)
+  "Remove all text-properties PROPERTY with value VALUE on
+characters with value CHAR from the region [FROM, TO), as tested
+by `equal'.  These properties are assumed to be over individual
+characters, having been put there by c-put-char-property.  POINT
+remains unchanged."
+  (let ((place from)
+        )
+    (while                        ; loop round occurrences of (PROPERTY VALUE)
+        (progn
+          (while           ; loop round changes in PROPERTY till we find VALUE
+              (and
+               (< place to)
+               (not (equal (get-text-property place property) value)))
+            (setq place (c-next-single-property-change place property nil to)))
+          (< place to))
+      (if (eq (char-after place) char)
+          (remove-text-properties place (1+ place) (cons property nil)))
+      ;; Do we have to do anything with stickiness here?
+      (setq place (1+ place)))))
+
+(defmacro c-clear-char-property-with-value-on-char (from to property value char)
+  "Remove all text-properties PROPERTY with value VALUE on
+characters with value CHAR from the region [FROM, TO), as tested
+by `equal'.  These properties are assumed to be over individual
+characters, having been put there by c-put-char-property.  POINT
+remains unchanged."
+  (if c-use-extents
+      ;; XEmacs
+      `(let ((-property- ,property)
+             (-char- ,char))
+         (map-extents (lambda (ext val)
+                        (if (and (equal (extent-property ext -property-) val)
+                                 (eq (char-after
+                                      (extent-start-position ext))
+                                     -char-))
+                            (delete-extent ext)))
+                      nil ,from ,to ,value nil -property-))
+    ;; Gnu Emacs
+    `(c-clear-char-property-with-value-on-char-function ,from ,to ,property
+                                                        ,value ,char)))
+
+(defmacro c-put-char-properties-on-char (from to property value char)
+  ;; This needs to be a macro because `property' passed to
+  ;; `c-put-char-property' must be a constant.
+  "Put the text property PROPERTY with value VALUE on characters
+with value CHAR in the region [FROM to)."
+  `(let ((skip-string (concat "^" (list ,char)))
+         (-to- ,to))
+     (save-excursion
+       (goto-char ,from)
+       (while (progn (skip-chars-forward skip-string -to-)
+                     (< (point) -to-))
+           (c-put-char-property (point) ,property ,value)
+           (forward-char)))))
 
 ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text.
 ;; For our purposes, these are characterized by being possible to
@@ -1232,6 +1285,8 @@ been put there by c-put-char-property.  POINT remains unchanged."
 (def-edebug-spec c-put-char-property t)
 (def-edebug-spec c-get-char-property t)
 (def-edebug-spec c-clear-char-property t)
+(def-edebug-spec c-clear-char-property-with-value-on-char t)
+(def-edebug-spec c-put-char-properties-on-char t)
 (def-edebug-spec c-clear-char-properties t)
 (def-edebug-spec c-put-overlay t)
 (def-edebug-spec c-delete-overlay t)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index aa84ade083c..955e1ebb08d 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -4809,7 +4809,6 @@ comment at the start of cc-engine.el for more info."
 
   (c-self-bind-state-cache
    (let ((start (point))
-         state-2
          ;; A list of syntactically relevant positions in descending
          ;; order.  It's used to avoid scanning repeatedly over
          ;; potentially large regions with `parse-partial-sexp' to verify
@@ -7809,8 +7808,7 @@ comment at the start of cc-engine.el for more info."
   ;; looking (in C++) like this "FQN::of::base::Class".  Move to the start of
   ;; this construct and return t.  If the parsing fails, return nil, leaving
   ;; point unchanged.
-  (let ((here (point))
-        end)
+  (let (end)
     (if (not (c-on-identifier))
         nil
       (c-simple-skip-symbol-backward)
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 9bae7d9aa2f..66f2575f49f 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -702,6 +702,36 @@ stuff.  Used on level 1 and higher."
              t)
            (c-put-font-lock-face start (1+ start) 'font-lock-warning-face)))))
 
+(defun c-font-lock-invalid-single-quotes (limit)
+  ;; This function will be called from font-lock for a region bounded by POINT
+  ;; and LIMIT, as though it were to identify a keyword for
+  ;; font-lock-keyword-face.  It always returns NIL to inhibit this and
+  ;; prevent a repeat invocation.  See elisp/lispref page "Search-based
+  ;; Fontification".
+  ;;
+  ;; This function fontifies invalid single quotes with
+  ;; `font-lock-warning-face'.  These are the single quotes which
+  ;; o - aren't inside a literal;
+  ;; o - are marked with a syntax-table text property value '(1); and
+  ;; o - are NOT marked with a non-null c-digit-separator property.
+  (let ((limits (c-literal-limits))
+        state beg end)
+    (if limits
+        (goto-char (cdr limits)))       ; Even for being in a ' '
+    (while (< (point) limit)
+      (setq beg (point))
+      (setq state (parse-partial-sexp (point) limit nil nil nil 'syntax-table))
+      (setq end (point))
+      (goto-char beg)
+      (while (progn (skip-chars-forward "^'" end)
+                    (< (point) end))
+        (if (and (equal (c-get-char-property (point) 'syntax-table) '(1))
+                 (not (c-get-char-property (point) 'c-digit-separator)))
+            (c-put-font-lock-face (point) (1+ (point)) font-lock-warning-face))
+        (forward-char))
+      (parse-partial-sexp end limit nil nil state 'syntax-table)))
+    nil)
+
 (c-lang-defconst c-basic-matchers-before
   "Font lock matchers for basic keywords, labels, references and various
 other easily recognizable things that should be fontified before generic
@@ -723,6 +753,9 @@ casts and declarations are fontified.  Used on level 2 and higher."
         (concat ".\\(" c-string-limit-regexp "\\)")
         '((c-font-lock-invalid-string)))
 
+      ;; Invalid single quotes.
+      c-font-lock-invalid-single-quotes
+
       ;; Fontify C++ raw strings.
       ,@(when (c-major-mode-is 'c++-mode)
           '(c-font-lock-raw-strings))
@@ -777,7 +810,8 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                     (c-backward-syntactic-ws)
                                     (setq id-end (point))
                                     (< (skip-chars-backward
-                                        ,(c-lang-const c-symbol-chars)) 0))
+                                        ,(c-lang-const c-symbol-chars))
+                                       0))
                                   (not (get-text-property (point) 'face)))
                         (c-put-font-lock-face (point) id-end
                                               c-reference-face-name)
@@ -1013,13 +1047,11 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
   ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
   (c-fontify-types-and-refs
-      ((pos (point)) next-pos id-start id-end
+      ((pos (point)) next-pos id-start
        decl-res
-       paren-depth
        id-face got-type got-init
        c-last-identifier-range
-       (separator-prop (if types 'c-decl-type-start 'c-decl-id-start))
-       brackets-after-id)
+       (separator-prop (if types 'c-decl-type-start 'c-decl-id-start)))
 
     ;; The following `while' fontifies a single declarator id each time round.
     ;; It loops only when LIST is non-nil.
@@ -1036,7 +1068,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
                                    (forward-char)
                                    (c-forward-syntactic-ws)
                                    (looking-at "[*&]")))
-                             (not (car (cddr decl-res))) ; brackets-after-id
+                             (not (car (cddr decl-res)))
                              (or (not (c-major-mode-is 'c++-mode))
                                  (save-excursion
                                    (let (c-last-identifier-range)
@@ -1375,7 +1407,6 @@ casts and declarations are fontified.  Used on level 2 and higher."
           ;; it finds any.  That's necessary so that we later will
           ;; stop inside them to fontify types there.
           (c-parse-and-markup-<>-arglists t)
-          lbrace ; position of some {.
           ;; The font-lock package in Emacs is known to clobber
           ;; `parse-sexp-lookup-properties' (when it exists).
           (parse-sexp-lookup-properties
@@ -2503,7 +2534,7 @@ need for `c++-font-lock-extra-types'.")
      limit
      "[-+]"
      nil
-     (lambda (match-pos inside-macro &optional top-level)
+     (lambda (_match-pos _inside-macro &optional _top-level)
        (forward-char)
        (c-font-lock-objc-method))))
   nil)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index a9d5ac34ad4..8be806094cd 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -130,7 +130,7 @@
 
 
 ;; This file is not always loaded.  See note above.
-(cc-external-require (if (eq c--mapcan-status 'cl-mapcan) 'cl-lib 'cl))
+(cc-external-require (if (eq c--cl-library 'cl-lib) 'cl-lib 'cl))
 
 
 ;;; Setup for the `c-lang-defvar' system.
@@ -474,18 +474,19 @@ so that all identifiers are recognized as words.")
   ;; The value here may be a list of functions or a single function.
   t nil
   c++ '(c-extend-region-for-CPP
-;       c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed.
         c-before-change-check-raw-strings
         c-before-change-check-<>-operators
         c-depropertize-CPP
-        c-before-after-change-digit-quote
         c-invalidate-macro-cache
-        c-truncate-bs-cache)
+        c-truncate-bs-cache
+        c-parse-quotes-before-change)
   (c objc) '(c-extend-region-for-CPP
              c-depropertize-CPP
              c-invalidate-macro-cache
-             c-truncate-bs-cache)
-  ;; java 'c-before-change-check-<>-operators
+             c-truncate-bs-cache
+             c-parse-quotes-before-change)
+  java 'c-parse-quotes-before-change
+       ;; 'c-before-change-check-<>-operators
   awk 'c-awk-record-region-clear-NL)
 (c-lang-defvar c-get-state-before-change-functions
                (let ((fs (c-lang-const c-get-state-before-change-functions)))
@@ -515,18 +516,19 @@ parameters \(point-min) and \(point-max).")
   t '(c-depropertize-new-text
       c-change-expand-fl-region)
   (c objc) '(c-depropertize-new-text
+             c-parse-quotes-after-change
              c-extend-font-lock-region-for-macros
              c-neutralize-syntax-in-and-mark-CPP
              c-change-expand-fl-region)
   c++ '(c-depropertize-new-text
+        c-parse-quotes-after-change
         c-extend-font-lock-region-for-macros
-;       c-before-after-change-extend-region-for-lambda-capture ; doesn't seem needed.
-        c-before-after-change-digit-quote
         c-after-change-re-mark-raw-strings
         c-neutralize-syntax-in-and-mark-CPP
         c-restore-<>-properties
         c-change-expand-fl-region)
   java '(c-depropertize-new-text
+         c-parse-quotes-after-change
          c-restore-<>-properties
          c-change-expand-fl-region)
   awk '(c-depropertize-new-text
@@ -609,6 +611,12 @@ EOL terminated statements."
   (c c++ objc) t)
 (c-lang-defvar c-has-bitfields (c-lang-const c-has-bitfields))
 
+(c-lang-defconst c-has-quoted-numbers
+  "Whether the language has numbers quoted like 4'294'967'295."
+  t nil
+  c++ t)
+(c-lang-defvar c-has-quoted-numbers (c-lang-const c-has-quoted-numbers))
+
 (c-lang-defconst c-modified-constant
   "Regexp that matches a “modified” constant literal such as \"L\\='a\\='\",
 a “long character”.  In particular, this recognizes forms of constant
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index a501ebba256..ef93f75c5f3 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1083,101 +1083,219 @@ Note that the style variables are always made local to the buffer."
             (forward-line))           ; no infinite loop with, e.g., "#//"
           )))))
 
-(defun c-before-after-change-digit-quote (beg end &optional old-len)
-  ;; This function either removes or applies the punctuation value ('(1)) of
-  ;; the `syntax-table' text property on single quote marks which are
-  ;; separator characters in long integer literals, e.g. "4'294'967'295".  It
-  ;; applies to both decimal/octal and hex literals.  (FIXME (2016-06-10): it
-  ;; should also apply to binary literals.)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Parsing of quotes.
+;;
+;; Valid digit separators in numbers will get the syntax-table "punctuation"
+;; property, '(1), and also the text property `c-digit-separator' value t.
+;;
+;; Invalid other quotes (i.e. those not validly bounding a single character,
+;; or escaped character) will get the syntax-table "punctuation" property,
+;; '(1), too.
+;;
+;; Note that, for convenience, these properties are applied even inside
+;; comments and strings.
+
+(defconst c-maybe-quoted-number-head
+  (concat
+   "\\(0\\("
+       "\\([Xx]\\([0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*'?\\)?\\)"
+       "\\|"
+       "\\([Bb]\\([01]\\('[01]\\|[01]\\)*'?\\)?\\)"
+       "\\|"
+       "\\('[0-7]\\|[0-7]\\)*'?"
+       "\\)"
+   "\\|"
+       "[1-9]\\('[0-9]\\|[0-9]\\)*'?"
+   "\\)")
+  "Regexp matching the head of a numeric literal, including with digit separators.")
+
+(defun c-quoted-number-head-before-point ()
+  ;; Return non-nil when the head of a possibly quoted number is found
+  ;; immediately before point.  The value returned in this case is the buffer
+  ;; position of the start of the head.  That position is also in
+  ;; (match-beginning 0).
+  (when c-has-quoted-numbers
+    (save-excursion
+      (let ((here (point))
+            found)
+        (skip-chars-backward "0-9a-fA-F'")
+        (if (and (memq (char-before) '(?x ?X))
+                 (eq (char-before (1- (point))) ?0))
+            (backward-char 2))
+        (while
+            (and
+             (setq found
+                   (search-forward-regexp c-maybe-quoted-number-head here t))
+             (< found here)))
+        (and (eq found here) (match-beginning 0))))))
+
+(defconst c-maybe-quoted-number-tail
+  (concat
+   "\\("
+       "\\([xX']?[0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)"
+   "\\|"
+       "\\([bB']?[01]\\('[01]\\|[01]\\)*\\)"
+   "\\|"
+       "\\('?[0-9]\\('[0-9]\\|[0-9]\\)*\\)"
+   "\\)")
+  "Regexp matching the tail of a numeric literal, including with digit separators.
+Note that this is a strict tail, so won't match, e.g. \"0x....\".")
+
+(defun c-quoted-number-tail-after-point ()
+  ;; Return non-nil when a proper tail of a possibly quoted number is found
+  ;; immediately after point.  The value returned in this case is the buffer
+  ;; position of the end of the tail.  That position is also in (match-end 0).
+  (when c-has-quoted-numbers
+    (and (looking-at c-maybe-quoted-number-tail)
+         (match-end 0))))
+
+(defconst c-maybe-quoted-number
+  (concat
+   "\\(0\\("
+       "\\([Xx][0-9a-fA-F]\\('[0-9a-fA-F]\\|[0-9a-fA-F]\\)*\\)"
+       "\\|"
+       "\\([Bb][01]\\('[01]\\|[01]\\)*\\)"
+       "\\|"
+       "\\('[0-7]\\|[0-7]\\)*"
+       "\\)"
+   "\\|"
+       "[1-9]\\('[0-9]\\|[0-9]\\)*"
+   "\\)")
+  "Regexp matching a numeric literal, including with digit separators.")
+
+(defun c-quoted-number-straddling-point ()
+  ;; Return non-nil if a definitely quoted number starts before point and ends
+  ;; after point.  In this case the number is bounded by (match-beginning 0)
+  ;; and (match-end 0).
+  (when c-has-quoted-numbers
+    (save-excursion
+      (let ((here (point))
+            (bound (progn (skip-chars-forward "0-9a-fA-F'") (point))))
+        (goto-char here)
+        (when (< (skip-chars-backward "0-9a-fA-F'") 0)
+          (if (and (memq (char-before) '(?x ?X))
+                   (eq (char-before (1- (point))) ?0))
+              (backward-char 2))
+          (while (and (search-forward-regexp c-maybe-quoted-number bound t)
+                      (<= (match-end 0) here)))
+          (and (< (match-beginning 0) here)
+               (> (match-end 0) here)
+               (save-match-data
+                 (goto-char (match-beginning 0))
+                 (save-excursion (search-forward "'" (match-end 0) t)))))))))
+
+(defun c-parse-quotes-before-change (beg end)
+  ;; This function analyzes 's near the region (c-new-BEG c-new-END), amending
+  ;; those two variables as needed to include 's into that region when they
+  ;; might be syntactically relevant to the change in progress.
   ;;
-  ;; In both uses of the function, the `syntax-table' properties are
-  ;; removed/applied only on quote marks which appear to be digit separators.
+  ;; Having amended that region, the function removes pertinent text
+  ;; properties (syntax-table properties with value '(1) and c-digit-separator
+  ;; props with value t) from 's in it.  This operation is performed even
+  ;; within strings and comments.
   ;;
-  ;; Point is undefined on both entry and exit to this function, and the
-  ;; return value has no significance.  The function is called solely as a
-  ;; before-change function (see `c-get-state-before-change-functions') and as
-  ;; an after change function (see `c-before-font-lock-functions', with the
-  ;; parameters BEG, END, and (optionally) OLD-LEN being given the standard
-  ;; values for before/after-change functions.
-  (c-save-buffer-state ((num-begin c-new-BEG) digit-re try-end)
+  ;; This function is called exclusively as a before-change function via the
+  ;; variable `c-get-state-before-change-functions'.
+  (c-save-buffer-state (p-limit limits found)
+    ;; Special consideraton for deleting \ from '\''.
+    (if (and (> end beg)
+             (eq (char-before end) ?\\)
+             (<= c-new-END end))
+        (setq c-new-END (min (1+ end) (point-max))))
+
+    ;; Do we have a ' (or something like ',',',',',') within range of
+    ;; c-new-BEG?
+    (goto-char c-new-BEG)
+    (setq p-limit (max (- (point) 2) (point-min)))
+    (while (and (skip-chars-backward "^\\\\'" p-limit)
+                (> (point) p-limit))
+      (when (eq (char-before) ?\\)
+        (setq p-limit (max (1- p-limit) (point-min))))
+      (backward-char)
+      (setq c-new-BEG (point)))
+    (beginning-of-line)
+    (while (and
+            (setq found (search-forward-regexp "\\('\\([^'\\]\\|\\\\.\\)\\)*'"
+                                               c-new-BEG 'limit))
+            (< (point) (1- c-new-BEG))))
+    (if found
+        (setq c-new-BEG
+              (if (and (eq (point) (1- c-new-BEG))
+                       (eq (char-after) ?')) ; "''" before c-new-BEG.
+                  (1- c-new-BEG)
+                (match-beginning 0))))
+
+    ;; Check for a number with quote separators straddling c-new-BEG
+    (when c-has-quoted-numbers
+      (goto-char c-new-BEG)
+      (when ;; (c-quoted-number-straddling-point)
+          (c-quoted-number-head-before-point)
+        (setq c-new-BEG (match-beginning 0))))
+
+    ;; Do we have a ' (or something like ',',',',...,',') within range of
+    ;; c-new-END?
     (goto-char c-new-END)
-    (when (looking-at "\\(x\\)?[0-9a-fA-F']+")
-      (setq c-new-END (match-end 0)))
+    (setq p-limit (min (+ (point) 2) (point-max)))
+    (while (and (skip-chars-forward "^\\\\'" p-limit)
+                (< (point) p-limit))
+      (when (eq (char-after) ?\\)
+        (setq p-limit (min (1+ p-limit) (point-max))))
+      (forward-char)
+      (setq c-new-END (point)))
+    (if (looking-at "[^']?\\('\\([^'\\]\\|\\\\.\\)\\)*'")
+        (setq c-new-END (match-end 0)))
+
+    ;; Check for a number with quote separators straddling c-new-END.
+    (when c-has-quoted-numbers
+      (goto-char c-new-END)
+      (when ;; (c-quoted-number-straddling-point)
+          (c-quoted-number-tail-after-point)
+        (setq c-new-END (match-end 0))))
+
+    ;; Remove the '(1) syntax-table property from all "'"s within (c-new-BEG
+    ;; c-new-END).
+    (c-clear-char-property-with-value-on-char
+     c-new-BEG c-new-END
+     'syntax-table '(1)
+     ?')
+    ;; Remove the c-digit-separator text property from the same "'"s.
+    (when c-has-quoted-numbers
+      (c-clear-char-property-with-value-on-char
+       c-new-BEG c-new-END
+       'c-digit-separator t
+       ?'))))
+
+(defun c-parse-quotes-after-change (beg end old-len)
+  ;; This function applies syntax-table properties (value '(1)) and
+  ;; c-digit-separator properties as needed to 's within the range (c-new-BEG
+  ;; c-new-END).  This operation is performed even within strings and
+  ;; comments.
+  ;;
+  ;; This function is called exclusively as an after-change function via the
+  ;; variable `c-before-font-lock-functions'.
+  (c-save-buffer-state (p-limit limits num-beg num-end clear-from-BEG-to)
+    ;; Apply the needed syntax-table and c-digit-separator text properties to
+    ;; quotes.
     (goto-char c-new-BEG)
-    (when (looking-at "\\(x?\\)[0-9a-fA-F']")
-      (if (re-search-backward "\\(0x\\)?[0-9a-fA-F]*\\=" nil t)
-          (setq c-new-BEG (point))))
-
-    (while
-        (re-search-forward "[0-9a-fA-F]'[0-9a-fA-F]" c-new-END t)
-      (setq try-end (1- (point)))
-      (re-search-backward "[^0-9a-fA-F']" num-begin t)
-      (setq digit-re
-            (cond
-             ((and (not (bobp)) (eq (char-before) ?0) (memq (char-after) '(?x ?X)))
-              "[0-9a-fA-F]")
-             ((and (eq (char-after (1+ (point))) ?0)
-                   (memq (char-after (+ 2 (point))) '(?b ?B)))
-              "[01]")
-             ((memq (char-after (1+ (point))) '(?0 ?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9))
-              "[0-9]")
-             (t nil)))
-      (when digit-re
-        (cond ((eq (char-after) ?x) (forward-char))
-              ((looking-at ".?0[Bb]") (goto-char (match-end 0)))
-              ((looking-at digit-re))
-              (t (forward-char)))
-        (when (not (c-in-literal))
-          (let ((num-end             ; End of valid sequence of digits/quotes.
-                 (save-excursion
-                   (re-search-forward
-                    (concat "\\=\\(" digit-re "+'\\)*" digit-re "+") nil t)
-                   (point))))
-            (setq try-end               ; End of sequence of digits/quotes
+    (while (and (< (point) c-new-END)
+                (search-forward "'" c-new-END 'limit))
+      (cond ((and (eq (char-before (1- (point))) ?\\)
+                  ;; Check we've got an odd number of \s, here.
                   (save-excursion
-                    (re-search-forward
-                     (concat "\\=\\(" digit-re "\\|'\\)+") nil t)
-                    (point)))
-            (while (re-search-forward
-                    (concat digit-re "\\('\\)" digit-re) num-end t)
-              (if old-len           ; i.e. are we in an after-change function?
-                  (c-put-char-property (match-beginning 1) 'syntax-table '(1))
-                (c-clear-char-property (match-beginning 1) 'syntax-table))
-              (backward-char)))))
-      (goto-char try-end)
-      (setq num-begin (point)))))
-
-;; The following doesn't seem needed at the moment (2016-08-15).
-;; (defun c-before-after-change-extend-region-for-lambda-capture
-;;     (_beg _end &optional _old-len)
-;;   ;; In C++ Mode, extend the region (c-new-BEG c-new-END) to cover any lambda
-;;   ;; function capture lists we happen to be inside.  This function is expected
-;;   ;; to be called both as a before-change and after change function.
-;;   ;;
-;;   ;; Note that these things _might_ be nested, with a capture list looking
-;;   ;; like:
-;;   ;;
-;;   ;;     [ ...., &foo = [..](){...}(..), ... ]
-;;   ;;
-;;   ;; .  What a wonderful language is C++.  ;-)
-;;   (c-save-buffer-state (paren-state pos)
-;;     (goto-char c-new-BEG)
-;;     (setq paren-state (c-parse-state))
-;;     (while (setq pos (c-pull-open-brace paren-state))
-;;       (goto-char pos)
-;;       (when (c-looking-at-c++-lambda-capture-list)
-;;      (setq c-new-BEG (min c-new-BEG pos))
-;;      (if (c-go-list-forward)
-;;          (setq c-new-END (max c-new-END (point))))))
-
-;;     (goto-char c-new-END)
-;;     (setq paren-state (c-parse-state))
-;;     (while (setq pos (c-pull-open-brace paren-state))
-;;       (goto-char pos)
-;;       (when (c-looking-at-c++-lambda-capture-list)
-;;      (setq c-new-BEG (min c-new-BEG pos))
-;;      (if (c-go-list-forward)
-;;          (setq c-new-END (max c-new-END (point))))))))
+                    (backward-char)
+                    (eq (logand (skip-chars-backward "\\\\") 1) 1)))) ; not a real '.
+            ((c-quoted-number-straddling-point)
+             (setq num-beg (match-beginning 0)
+                   num-end (match-end 0))
+             (c-put-char-properties-on-char num-beg num-end
+                                            'syntax-table '(1) ?')
+             (c-put-char-properties-on-char num-beg num-end
+                                            'c-digit-separator t ?')
+             (goto-char num-end))
+            ((looking-at "\\([^\\']\\|\\\\.\\)'") ; balanced quoted expression.
+             (goto-char (match-end 0)))
+            (t (c-put-char-property (1- (point)) 'syntax-table '(1)))))))
 
 (defun c-before-change (beg end)
   ;; Function to be put on `before-change-functions'.  Primarily, this calls
diff --git a/lisp/progmodes/cc-styles.el b/lisp/progmodes/cc-styles.el
index b3848a74f97..b1c94c3bc6a 100644
--- a/lisp/progmodes/cc-styles.el
+++ b/lisp/progmodes/cc-styles.el
@@ -47,6 +47,7 @@
 ;; `c-add-style' often contains references to functions defined there.
 
 ;; Silence the compiler.
+(cc-bytecomp-defun c-guess-basic-syntax)
 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
 
 
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 902a5aace08..de0cd50911a 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -353,8 +353,6 @@ information):
     Quotes all \"#\" characters that don't correspond to actual
     Tcl comments.  (Useful when editing code not originally created
     with this mode).
-  `tcl-auto-fill-mode'
-    Auto-filling of Tcl comments.
 
 Add functions to the hook with `add-hook':
 
@@ -1413,6 +1411,9 @@ Prefix argument means switch to the Tcl buffer afterwards."
 
 (defun tcl-auto-fill-mode (&optional arg)
   "Like `auto-fill-mode', but sets `comment-auto-fill-only-comments'."
+  (declare
+   (obsolete
+    "Use `auto-fill-mode' with `comment-auto-fill-only-comments'." "26.1"))
   (interactive "P")
   (auto-fill-mode arg)
   (if auto-fill-function