CC Mode: optimize for repeated simple operations.

Do this by recognising that unterminated strings in a buffer are typically
going to be few and close together.  Also optimize code for C++ attributes.

* lisp/progmodes/cc-defs.el (c-previous-single-property-change): New macro.
(c-put-syn-tab, c-clear-syn-tab): Turned from macros into functions, and moved
to cc-mode.el.
(c-clear-syn-tab-properties): Amended to use c-min/max-syn-tab-mkr.
(c-with-extended-string-fences): Removed.

* lisp/progmodes/cc-engine-el (c-enclosing-c++-attribute): Rewritten for
speed.
(c-slow-enclosing-c++-attribute): Removed.
(c-semi-pp-to-literal): Remove a superfluous call to
c-with-extended-string-fences.

* lisp/progmodes/cc-mode.el (c-min-syn-tab-mkr, c-max-syn-tab-mkr): two new
marker variables which bound the region occupied by positions with
c-fl-syn-tab text properties.
(c-basic-common-init): Initialize these two variables.
(c-fl-syn-tab-region): Removed.
(c-put-syn-tab, c-clear-syn-tab): Functions moved from cc-defs.el.
(c-clear-string-fences): Amended to use the new scheme.
(c-restore-string-fences): Now takes no arguments; amended to use the new
scheme.
(c-font-lock-fontify-region): Amended to use the new scheme.

3 files changed, 183 insertions, 169 deletions

diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 2624d9db58d..9a3d7adf61d 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -445,6 +445,15 @@ to it is returned.  This function does not modify the point or the mark."
     ;; Emacs and earlier XEmacs
     `(next-single-property-change ,position ,prop ,object ,limit)))
 
+(defmacro c-previous-single-property-change (position prop &optional object limit)
+  ;; See the doc string for either of the defuns expanded to.
+  (if (and c-use-extents
+           (fboundp 'previous-single-char-property-change))
+      ;; XEmacs >= 2005-01-25
+      `(previous-single-char-property-change ,position ,prop ,object ,limit)
+    ;; Emacs and earlier XEmacs
+    `(previous-single-property-change ,position ,prop ,object ,limit)))
+
 (defmacro c-region-is-active-p ()
   ;; Return t when the region is active.  The determination of region
   ;; activeness is different in both Emacs and XEmacs.
@@ -1047,15 +1056,6 @@ MODE is either a mode symbol or a list of mode symbols."
 ;; properties set on a single character and that never spread to any
 ;; other characters.
 
-(defmacro c-put-syn-tab (pos value)
-  ;; Set both the syntax-table and the c-fl-syn-tab text properties at POS to
-  ;; VALUE (which should not be nil).
-  `(let ((-pos- ,pos)
-         (-value- ,value))
-     (c-put-char-property -pos- 'syntax-table -value-)
-     (c-put-char-property -pos- 'c-fl-syn-tab -value-)
-     (c-truncate-lit-pos-cache -pos-)))
-
 (eval-and-compile
   ;; Constant used at compile time to decide whether or not to use
   ;; XEmacs extents.  Check all the extent functions we'll use since
@@ -1183,13 +1183,6 @@ MODE is either a mode symbol or a list of mode symbols."
          ;; Emacs < 21.
          `(c-clear-char-property-fun ,pos ',property))))
 
-(defmacro c-clear-syn-tab (pos)
-  ;; Remove both the 'syntax-table and `c-fl-syn-tab properties at POS.
-  `(let ((-pos- ,pos))
-     (c-clear-char-property -pos- 'syntax-table)
-     (c-clear-char-property -pos- 'c-fl-syn-tab)
-     (c-truncate-lit-pos-cache -pos-)))
-
 (defmacro c-min-property-position (from to property)
   ;; Return the first position in the range [FROM to) where the text property
   ;; PROPERTY is set, or `most-positive-fixnum' if there is no such position.
@@ -1235,8 +1228,18 @@ MODE is either a mode symbol or a list of mode symbols."
   ;; Remove all occurrences of the `syntax-table' and `c-fl-syn-tab' text
   ;; properties between FROM and TO.
   `(let ((-from- ,from) (-to- ,to))
-     (c-clear-char-properties -from- -to- 'syntax-table)
-     (c-clear-char-properties -from- -to- 'c-fl-syn-tab)))
+     (when (and
+            c-min-syn-tab-mkr c-max-syn-tab-mkr
+            (< -from- c-max-syn-tab-mkr)
+            (> -to- c-min-syn-tab-mkr))
+       (let ((pos -from-))
+         (while (and
+                 (< pos -to-)
+                 (setq pos (c-min-property-position pos -to- 'c-fl-syn-tab))
+                 (< pos -to-))
+           (c-clear-syn-tab pos)
+           (setq pos (1+ pos)))))
+     (c-clear-char-properties -from- -to- 'syntax-table)))
 
 (defmacro c-search-forward-char-property (property value &optional limit)
   "Search forward for a text-property PROPERTY having value VALUE.
@@ -1456,28 +1459,6 @@ with value CHAR in the region [FROM to)."
          (c-put-char-property (point) ,property ,value)
          (forward-char)))))
 
-(defmacro c-with-extended-string-fences (beg end &rest body)
-  ;; If needed, extend the region with "mirrored" c-fl-syn-tab properties to
-  ;; contain the region (BEG END), then evaluate BODY.  If this mirrored
-  ;; region was initially empty, restore it afterwards.
-  `(let ((-beg- ,beg)
-         (-end- ,end)
-         )
-     (cond
-      ((null c-fl-syn-tab-region)
-       (unwind-protect
-           (progn
-             (c-restore-string-fences -beg- -end-)
-             ,@body)
-         (c-clear-string-fences)))
-      ((and (>= -beg- (car c-fl-syn-tab-region))
-            (<= -end- (cdr c-fl-syn-tab-region)))
-       ,@body)
-      (t                                ; Crudely extend the mirrored region.
-       (setq -beg- (min -beg- (car c-fl-syn-tab-region))
-             -end- (max -end- (cdr c-fl-syn-tab-region)))
-       (c-restore-string-fences -beg- -end-)
-       ,@body))))
 
 ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text.
 ;; For our purposes, these are characterized by being possible to
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 888184d2b46..1977eadb5c6 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -163,7 +163,9 @@
 (defvar c-doc-line-join-re)
 (defvar c-doc-bright-comment-start-re)
 (defvar c-doc-line-join-end-ch)
-(defvar c-fl-syn-tab-region)
+(cc-bytecomp-defvar c-min-syn-tab-mkr)
+(cc-bytecomp-defvar c-max-syn-tab-mkr)
+(cc-bytecomp-defun c-clear-syn-tab)
 (cc-bytecomp-defun c-clear-string-fences)
 (cc-bytecomp-defun c-restore-string-fences)
 
@@ -1910,52 +1912,29 @@ comment at the start of cc-engine.el for more info."
 (defun c-enclosing-c++-attribute ()
   ;; If we're in C++ Mode, and point is within a correctly balanced [[ ... ]]
   ;; attribute structure, return a cons of its starting and ending positions.
-  ;; Otherwise, return nil.  We use the c-{in,is}-sws-face text properties for
-  ;; this determination, this macro being intended only for use in the *-sws-*
-  ;; functions and macros.  The match data are NOT preserved over this macro.
-  (let (attr-end pos-is-sws)
-     (and
-      (c-major-mode-is 'c++-mode)
-      (> (point) (point-min))
-      (setq pos-is-sws
-            (if (get-text-property (1- (point)) 'c-is-sws)
-                (1- (point))
-              (1- (previous-single-property-change
-                   (point) 'c-is-sws nil (point-min)))))
-      (save-excursion
-        (goto-char pos-is-sws)
-        (setq attr-end (c-looking-at-c++-attribute)))
-      (> attr-end (point))
-      (cons pos-is-sws attr-end))))
-
-(defun c-slow-enclosing-c++-attribute ()
-  ;; Like `c-enclosing-c++-attribute', but does not depend on the c-i[ns]-sws
-  ;; properties being set.
+  ;; Otherwise, return nil.
   (and
    (c-major-mode-is 'c++-mode)
    (save-excursion
-     (let ((paren-state (c-parse-state))
+     (let ((lim (max (- (point) 200) (point-min)))
            cand)
        (while
-           (progn
-             (setq cand
-                   (catch 'found-cand
-                     (while (cdr paren-state)
-                       (when (and (numberp (car paren-state))
-                                  (numberp (cadr paren-state))
-                                  (eq (car paren-state)
-                                      (1+ (cadr paren-state)))
-                                  (eq (char-after (car paren-state)) ?\[)
-                                  (eq (char-after (cadr paren-state)) ?\[))
-                         (throw 'found-cand (cadr paren-state)))
-                       (setq paren-state (cdr paren-state)))))
-             (and cand
-                  (not
-                   (and (c-go-list-forward cand)
-                        (eq (char-before) ?\])
-                        (eq (char-before (1- (point))) ?\])))))
-         (setq paren-state (cdr paren-state)))
-       (and cand (cons cand (point)))))))
+           (and
+            (progn
+              (skip-chars-backward "^[;{}" lim)
+              (eq (char-before) ?\[))
+            (not (eq (char-before (1- (point))) ?\[))
+            (> (point) lim))
+         (backward-char))
+       (and (eq (char-before) ?\[)
+            (eq (char-before (1- (point))) ?\[)
+            (progn (backward-char 2) t)
+            (setq cand (point))
+            (c-go-list-forward nil (min (+ (point) 200) (point-max)))
+            (eq (char-before) ?\])
+            (eq (char-before (1- (point))) ?\])
+            (not (c-literal-limits))
+            (cons cand (point)))))))
 
 (defun c-invalidate-sws-region-before (beg end)
   ;; Called from c-before-change.  BEG and END are the bounds of the change
@@ -3003,9 +2982,7 @@ comment at the start of cc-engine.el for more info."
                                  c-block-comment-awkward-chars)))
                  (and (nth 4 s) (nth 7 s) ; Line comment
                       (not (memq (char-before here) '(?\\ ?\n)))))))
-            (c-with-extended-string-fences
-             pos here
-             (setq s (parse-partial-sexp pos here nil nil s))))
+            (setq s (parse-partial-sexp pos here nil nil s)))
           (when (not (eq near-pos here))
             (c-semi-put-near-cache-entry here s))
           (cond
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 4869f5c596d..bd0efc681eb 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -558,6 +558,18 @@ preferably use the `c-mode-menu' language constant directly."
 ;; and `after-change-functions'.  Note that this variable is not set when
 ;; `c-before-change' is invoked by a change to text properties.
 
+(defvar c-min-syn-tab-mkr nil)
+;; The minimum buffer position where there's a `c-fl-syn-tab' text property,
+;; or nil if there aren't any.  This is a marker, or nil if there's currently
+;; no such text property.
+(make-variable-buffer-local 'c-min-syn-tab-mkr)
+
+(defvar c-max-syn-tab-mkr nil)
+;; The maximum buffer position plus 1 where there's a `c-fl-syn-tab' text
+;; property, or nil if there aren't any.  This is a marker, or nil if there's
+;; currently no such text property.
+(make-variable-buffer-local 'c-max-syn-tab-mkr)
+
 (defun c-basic-common-init (mode default-style)
   "Do the necessary initialization for the syntax handling routines
 and the line breaking/filling code.  Intended to be used by other
@@ -631,6 +643,10 @@ that requires a literal mode spec at compile time."
   ;; Initialize the "brace stack" cache.
   (c-init-bs-cache)
 
+  ;; Keep track of where `c-fl-syn-tab' text properties are set.
+  (setq c-min-syn-tab-mkr nil)
+  (setq c-max-syn-tab-mkr nil)
+
   (when (or c-recognize-<>-arglists
             (c-major-mode-is 'awk-mode)
             (c-major-mode-is '(java-mode c-mode c++-mode objc-mode pike-mode)))
@@ -1232,52 +1248,94 @@ Note that the style variables are always made local to the buffer."
         (c-put-char-property (1- (point)) 'syntax-table '(15)))
        (t nil)))))
 
-(defvar c-fl-syn-tab-region nil)
-  ;; Non-nil when a `c-restore-string-fences' is "in force".  It's value is a
-  ;; cons of the BEG and END of the region currently "mirroring" the
-  ;; c-fl-syn-tab properties as syntax-table properties.
+(defun c-put-syn-tab (pos value)
+  ;; Set both the syntax-table and the c-fl-syn-tab text properties at POS to
+  ;; VALUE (which should not be nil).
+  ;; `(let ((-pos- ,pos)
+  ;;     (-value- ,value))
+  (c-put-char-property pos 'syntax-table value)
+  (c-put-char-property pos 'c-fl-syn-tab value)
+  (cond
+   ((null c-min-syn-tab-mkr)
+    (setq c-min-syn-tab-mkr (copy-marker pos t)))
+   ((< pos c-min-syn-tab-mkr)
+    (move-marker c-min-syn-tab-mkr pos)))
+  (cond
+   ((null c-max-syn-tab-mkr)
+    (setq c-max-syn-tab-mkr (copy-marker (1+ pos) nil)))
+   ((>= pos c-max-syn-tab-mkr)
+    (move-marker c-max-syn-tab-mkr (1+ pos))))
+  (c-truncate-lit-pos-cache pos))
+
+(defun c-clear-syn-tab (pos)
+  ;; Remove both the 'syntax-table and `c-fl-syn-tab properties at POS.
+     (c-clear-char-property pos 'syntax-table)
+     (c-clear-char-property pos 'c-fl-syn-tab)
+     (when c-min-syn-tab-mkr
+       (if (and (eq pos (marker-position c-min-syn-tab-mkr))
+                (eq (1+ pos) (marker-position c-max-syn-tab-mkr)))
+           (progn
+             (move-marker c-min-syn-tab-mkr nil)
+             (move-marker c-max-syn-tab-mkr nil)
+             (setq c-min-syn-tab-mkr nil  c-max-syn-tab-mkr nil))
+         (when (eq pos (marker-position c-min-syn-tab-mkr))
+           (move-marker c-min-syn-tab-mkr
+                        (if (c-get-char-property (1+ pos) 'c-fl-syn-tab)
+                            (1+ pos)
+                          (c-next-single-property-change
+                           (1+ pos) 'c-fl-syn-tab nil c-max-syn-tab-mkr))))
+         (when (eq (1+ pos) (marker-position c-max-syn-tab-mkr))
+           (move-marker c-max-syn-tab-mkr
+                        (if (c-get-char-property (1- pos) 'c-fl-syn-tab)
+                            pos
+                          (c-previous-single-property-change
+                           pos 'c-fl-syn-tab nil (1+ c-min-syn-tab-mkr)))))))
+     (c-truncate-lit-pos-cache pos))
 
 (defun c-clear-string-fences ()
-  ;; Clear syntax-table text properties in the region defined by
-  ;; `c-cl-syn-tab-region' which are "mirrored" by c-fl-syn-tab text
-  ;; properties.  However, any such " character which ends up not being
+  ;; Clear syntax-table text properties which are "mirrored" by c-fl-syn-tab
+  ;; text properties.  However, any such " character which ends up not being
   ;; balanced by another " is left with a '(1) syntax-table property.
-  (when c-fl-syn-tab-region
-    (let ((beg (car c-fl-syn-tab-region))
-          (end (cdr c-fl-syn-tab-region))
-          s pos)
-      (setq pos beg)
+  (when
+      (and c-min-syn-tab-mkr c-max-syn-tab-mkr)
+    (let (s pos)
+      (setq pos c-min-syn-tab-mkr)
       (while
           (and
-           (< pos end)
-           (setq pos
-                 (c-min-property-position pos end 'c-fl-syn-tab))
-           (< pos end))
+           (< pos c-max-syn-tab-mkr)
+           (setq pos (c-min-property-position pos
+                                              c-max-syn-tab-mkr
+                                              'c-fl-syn-tab))
+           (< pos c-max-syn-tab-mkr))
         (c-clear-char-property pos 'syntax-table)
         (setq pos (1+ pos)))
       ;; Check we haven't left any unbalanced "s.
       (save-excursion
-        (setq pos beg)
+        (setq pos c-min-syn-tab-mkr)
         ;; Is there already an unbalanced " before BEG?
-        (setq pos (c-min-property-position pos end 'c-fl-syn-tab))
-        (when (< pos end) (goto-char pos))
+        (setq pos (c-min-property-position pos c-max-syn-tab-mkr
+                                           'c-fl-syn-tab))
+        (when (< pos c-max-syn-tab-mkr)
+          (goto-char pos))
         (when (and (save-match-data
                      (c-search-backward-char-property-with-value-on-char
                       'c-fl-syn-tab '(15) ?\"
                       (max (- (point) 500) (point-min))))
                    (not (equal (c-get-char-property (point) 'syntax-table) '(1))))
           (setq pos (1+ pos)))
-        (while (< pos end)
+        (while (< pos c-max-syn-tab-mkr)
           (setq pos
-                (c-min-property-position pos end 'c-fl-syn-tab))
-          (when (< pos end)
+                (c-min-property-position pos c-max-syn-tab-mkr 'c-fl-syn-tab))
+          (when (< pos c-max-syn-tab-mkr)
             (if (memq (char-after pos) c-string-delims)
                 (progn
                   ;; Step over the ".
-                  (setq s (parse-partial-sexp pos end nil nil nil
+                  (setq s (parse-partial-sexp pos c-max-syn-tab-mkr
+                                              nil nil nil
                                               'syntax-table))
                   ;; Seek a (bogus) matching ".
-                  (setq s (parse-partial-sexp (point) end nil nil s
+                  (setq s (parse-partial-sexp (point) c-max-syn-tab-mkr
+                                              nil nil s
                                               'syntax-table))
                   ;; When a bogus matching " is found, do nothing.
                   ;; Otherwise mark the " with 'syntax-table '(1).
@@ -1287,23 +1345,22 @@ Note that the style variables are always made local to the buffer."
                        (c-get-char-property (1- (point)) 'c-fl-syn-tab))
                     (c-put-char-property pos 'syntax-table '(1)))
                   (setq pos (point)))
-              (setq pos (1+ pos))))))
-      (setq c-fl-syn-tab-region nil))))
-
-(defun c-restore-string-fences (beg end)
-  ;; Restore any syntax-table text properties in the region (BEG END) which
-  ;; are "mirrored" by c-fl-syn-tab text properties.
-  (let ((pos beg))
-    (while
-        (and
-         (< pos end)
-         (setq pos
-               (c-min-property-position pos end 'c-fl-syn-tab))
-         (< pos end))
-      (c-put-char-property pos 'syntax-table
-                           (c-get-char-property pos 'c-fl-syn-tab))
-      (setq pos (1+ pos)))
-    (setq c-fl-syn-tab-region (cons beg end))))
+              (setq pos (1+ pos)))))))))
+
+(defun c-restore-string-fences ()
+  ;; Restore any syntax-table text properties which are "mirrored" by
+  ;; c-fl-syn-tab text properties.
+  (when (and c-min-syn-tab-mkr c-max-syn-tab-mkr)
+    (let ((pos c-min-syn-tab-mkr))
+      (while
+          (and
+           (< pos c-max-syn-tab-mkr)
+           (setq pos
+                 (c-min-property-position pos c-max-syn-tab-mkr 'c-fl-syn-tab))
+           (< pos c-max-syn-tab-mkr))
+        (c-put-char-property pos 'syntax-table
+                             (c-get-char-property pos 'c-fl-syn-tab))
+        (setq pos (1+ pos))))))
 
 (defvar c-bc-changed-stringiness nil)
 ;; Non-nil when, in a before-change function, the deletion of a range of text
@@ -1913,7 +1970,7 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
         (widen)
         (unwind-protect
             (progn
-              (c-restore-string-fences (point-min) (point-max))
+              (c-restore-string-fences)
               (save-excursion
                 ;; Are we inserting/deleting stuff in the middle of an
                 ;; identifier?
@@ -2043,7 +2100,7 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
           (widen)
           (unwind-protect
               (progn
-                (c-restore-string-fences (point-min) (point-max))
+                (c-restore-string-fences)
                 (when (> end (point-max))
                   ;; Some emacsen might return positions past the end. This
                   ;; has been observed in Emacs 20.7 when rereading a buffer
@@ -2208,7 +2265,7 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
         enclosing-attribute pos1)
     (unless lit-start
       (c-backward-syntactic-ws)
-      (when (setq enclosing-attribute (c-slow-enclosing-c++-attribute))
+      (when (setq enclosing-attribute (c-enclosing-c++-attribute))
         (goto-char (car enclosing-attribute))) ; Only happens in C++ Mode.
       (when (setq pos1 (c-on-identifier))
         (goto-char pos1)
@@ -2303,46 +2360,45 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
                     (t beg)))
         (c-save-buffer-state nil
           ;; Temporarily reapply the string fence syntax-table properties.
-          (c-with-extended-string-fences
-           string-fence-beg (if c-in-after-change-fontification
-                                (max end c-new-END)
-                              end)
-
-           (if (and c-in-after-change-fontification
-                    (< beg c-new-END) (> end c-new-BEG))
-               ;; Region and the latest after-change fontification region overlap.
-               ;; Determine the upper and lower bounds of our adjusted region
-               ;; separately.
-               (progn
-                 (if (<= beg c-new-BEG)
-                     (setq c-in-after-change-fontification nil))
-                 (setq new-beg
-                       (if (and (>= beg (c-point 'bol c-new-BEG))
-                                (<= beg c-new-BEG))
-                           ;; Either jit-lock has accepted `c-new-BEG', or has
-                           ;; (probably) extended the change region spuriously
-                           ;; to BOL, which position likely has a
-                           ;; syntactically different position.  To ensure
-                           ;; correct fontification, we start at `c-new-BEG',
-                           ;; assuming any characters to the left of
-                           ;; `c-new-BEG' on the line do not require
-                           ;; fontification.
-                           c-new-BEG
-                         (setq new-region (c-before-context-fl-expand-region beg end)
-                               new-end (cdr new-region))
-                         (car new-region)))
-                 (setq new-end
-                       (if (and (>= end (c-point 'bol c-new-END))
-                                (<= end c-new-END))
-                           c-new-END
-                         (or new-end
-                             (cdr (c-before-context-fl-expand-region beg end))))))
-             ;; Context (etc.) fontification.
-             (setq new-region (c-before-context-fl-expand-region beg end)
-                   new-beg (car new-region)  new-end (cdr new-region)))
-           ;; Finally invoke font lock's functionality.
-           (funcall (default-value 'font-lock-fontify-region-function)
-                    new-beg new-end verbose)))))))
+          (unwind-protect
+              (progn
+                (c-restore-string-fences)
+                (if (and c-in-after-change-fontification
+                         (< beg c-new-END) (> end c-new-BEG))
+                    ;; Region and the latest after-change fontification region overlap.
+                    ;; Determine the upper and lower bounds of our adjusted region
+                    ;; separately.
+                    (progn
+                      (if (<= beg c-new-BEG)
+                          (setq c-in-after-change-fontification nil))
+                      (setq new-beg
+                            (if (and (>= beg (c-point 'bol c-new-BEG))
+                                     (<= beg c-new-BEG))
+                                ;; Either jit-lock has accepted `c-new-BEG', or has
+                                ;; (probably) extended the change region spuriously
+                                ;; to BOL, which position likely has a
+                                ;; syntactically different position.  To ensure
+                                ;; correct fontification, we start at `c-new-BEG',
+                                ;; assuming any characters to the left of
+                                ;; `c-new-BEG' on the line do not require
+                                ;; fontification.
+                                c-new-BEG
+                              (setq new-region (c-before-context-fl-expand-region beg end)
+                                    new-end (cdr new-region))
+                              (car new-region)))
+                      (setq new-end
+                            (if (and (>= end (c-point 'bol c-new-END))
+                                     (<= end c-new-END))
+                                c-new-END
+                              (or new-end
+                                  (cdr (c-before-context-fl-expand-region beg end))))))
+                  ;; Context (etc.) fontification.
+                  (setq new-region (c-before-context-fl-expand-region beg end)
+                        new-beg (car new-region)  new-end (cdr new-region)))
+                ;; Finally invoke font lock's functionality.
+                (funcall (default-value 'font-lock-fontify-region-function)
+                         new-beg new-end verbose))
+            (c-clear-string-fences)))))))
 
 (defun c-after-font-lock-init ()
   ;; Put on `font-lock-mode-hook'.  This function ensures our after-change