Revert 2009-12-03T16:02:10Z!acm@muc.de (enhance c-parse-state) and 2010-02-04T21:15:37Z!acm@muc.de (< and > handling).

[These enhancements were not sufficiently stable at the time of releasing
a pretest.]

7 files changed, 431 insertions, 1585 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index fe1e4b25878..35198619654 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -134,11 +134,6 @@
 
         * indent.el (indent-for-tab-command): Doc fix.
 
-2010-03-22  Alan Mackenzie  <acm@muc.de>
-
-        * progmodes/cc-engine.el (c-remove-stale-state-cache):
-        Fix off-by-one error.  Fixes bug #5747.
-
 2010-03-22  Juanma Barranquero  <lekktu@gmail.com>
 
         * image-dired.el (image-dired-display-thumbs): Fix typo in docstring.
@@ -287,11 +282,6 @@
         * calendar/cal-hebrew.el (holiday-hebrew-passover): Fix date
         of Yom HaAtzma'ut when it falls on a Monday (rule changed in 2004).
 
-2010-03-01  Alan Mackenzie  <acm@muc.de>
-
-        * progmodes/cc-engine.el (c-remove-stale-state-cache):
-        Correct previous patch.
-
 2010-03-01  Kenichi Handa  <handa@m17n.org>
 
         * language/burmese.el (burmese-composable-pattern): Rename from
@@ -303,11 +293,6 @@
         (otf-script-alist): Likewise.
         (setup-default-fontset): Likewise.  Re-fix :otf spec.
 
-2010-03-01  Alan Mackenzie  <bug-cc-mode@gnu.org>
-
-        * cc-engine.el (c-remove-stale-state-cache): Take account of when
-        `good-pos' is in the same macro as `here'.  Fixes bug#5649.
-
 2010-02-28  Katsumi Yamaoka  <yamaoka@jpl.org>
 
         * menu-bar.el (menu-bar-manuals-menu): Fix typo.
@@ -373,16 +358,6 @@
         * mail/sendmail.el (send-mail-function): Autoload the call
         to custom-initialize-delay, not otherwise preserved in loaddefs.el.
 
-2010-02-25  Alan Mackenzie  <acm@muc.de>
-
-        * progmodes/cc-engine.el (c-clear-<-pair-props)
-        (c-clear->-pair-props): Correct to wipe category text props, not
-        syntax-table ones.
-
-        * progmodes/cc-mode.el (c-after-change): Remove any hard
-        syntax-table properties for <, > which, e.g., C-y has
-        inopportunely converted from category properties.
-
 2010-02-24  Chong Yidong  <cyd@stupidchicken.com>
 
         * files.el (hack-local-variables-filter): For eval forms, also
@@ -720,33 +695,6 @@
         (doc-view-pdf->png): Don't rely on doc-view-pdf/ps->png for the few
         windows that are not yet showing images.
 
-2010-02-04  Alan Mackenzie  <acm@muc.de>
-
-        Change strategy for marking < and > as template delimiters: mark
-        them strictly in matching pairs.
-
-        * cc-mode.el (c-before-change):
-        Use c-get-state-before-change-functions.
-        (c-common-init): Adapt to use
-        c-get-state-before-change-functions (note plural).
-
-        * cc-langs.el (c-no-parens-syntax-table): New syntax table, used
-        for searching syntactically for matching <s and >s.
-        (c-get-state-before-change-functions): New language variable (note
-        the plural) which supersedes c-get-state-before-change-function.
-
-        * cc-engine.el (c-clear-<-pair-props, c-clear->-pair-props)
-        (c-clear-<>-pair-props, c-clear-<-pair-props-if-match-after)
-        (c-clear->-pair-props-if-match-before)
-        (c-before-change-check-<>-operators): New functions.
-        (c-after-change-check-<>-operators): Use macro
-        c-unmark-<->-as-paren.
-
-        * cc-defs.el (c-search-backward-char-property): New macro.
-
-        * cc-cmds.el (c-electric-lt-gt): Do not set text properties on <
-        and > any more.  (These will be handled by font locking.)
-
 2010-02-04  Michael Albinus  <michael.albinus@gmx.de>
 
         * dired.el (dired-revert): If DIRED-DIRECTORY is a cons cell, call
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 56fc8032541..4eade6edf58 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1086,76 +1086,104 @@ numeric argument is supplied, or the point is inside a literal."
 
   (interactive "*P")
   (let ((c-echo-syntactic-information-p nil)
-        final-pos close-paren-inserted found-delim)
+        final-pos close-paren-inserted)
 
     (self-insert-command (prefix-numeric-value arg))
     (setq final-pos (point))
 
-;;;; 2010-01-31: There used to be code here to put a syntax-table text
-;;;; property on the new < or > and its mate (if any) when they are template
-;;;; parens.  This is now done in an after-change function.
+    (c-save-buffer-state (c-parse-and-markup-<>-arglists
+                          c-restricted-<>-arglists
+                          <-pos)
 
-    ;; Indent the line if appropriate.
-    (when (and c-electric-flag c-syntactic-indentation c-recognize-<>-arglists)
-      (setq found-delim
-            (if (eq last-command-event ?<)
-                ;; If a <, basically see if it's got "template" before it .....
-                (or (and (progn
-                           (backward-char)
-                           (= (point)
-                              (progn (c-beginning-of-current-token) (point))))
-                         (progn
-                           (c-backward-token-2)
-                           (looking-at c-opt-<>-sexp-key)))
-                    ;; ..... or is a C++ << operator.
-                    (and (c-major-mode-is 'c++-mode)
-                         (progn
-                           (goto-char (1- final-pos))
-                           (c-beginning-of-current-token)
-                           (looking-at "<<"))
-                         (>= (match-end 0) final-pos)))
-
-              ;; It's a >.  Either a C++ >> operator. ......
-              (or (and (c-major-mode-is 'c++-mode)
+      (when c-recognize-<>-arglists
+        (if (eq last-command-event ?<)
+            (when (and (progn
+                         (backward-char)
+                         (= (point)
+                            (progn
+                              (c-beginning-of-current-token)
+                              (point))))
                        (progn
-                         (goto-char (1- final-pos))
-                         (c-beginning-of-current-token)
-                         (looking-at ">>"))
-                       (>= (match-end 0) final-pos))
-                  ;; ...., or search back for a < which isn't already marked as an
-                  ;; opening template delimiter.
-                  (save-restriction
-                    (widen)
-                    ;; Narrow to avoid `c-forward-<>-arglist' below searching past
-                    ;; our position.
-                    (narrow-to-region (point-min) final-pos)
-                    (goto-char final-pos)
-                    (while
-                        (and
-                         (progn
-                           (c-syntactic-skip-backward "^<;}" nil t)
-                           (eq (char-before) ?<))
-                         (progn
-                           (backward-char)
-                           (looking-at "\\s\("))))
-                    (and (eq (char-after) ?<)
-                         (not (looking-at "\\s\("))
-                         (progn (c-backward-syntactic-ws)
-                                (c-simple-skip-symbol-backward))
-                         (or (looking-at c-opt-<>-sexp-key)
-                             (not (looking-at c-keywords-regexp)))))))))
+                         (c-backward-token-2)
+                         (looking-at c-opt-<>-sexp-key)))
+              (c-mark-<-as-paren (1- final-pos)))
+
+          ;; It's a ">".  Check if there's an earlier "<" which either has
+          ;; open paren syntax already or that can be recognized as an arglist
+          ;; together with this ">".  Note that this won't work in cases like
+          ;; "template <x, a < b, y>" but they ought to be rare.
+
+          (save-restriction
+            ;; Narrow to avoid that `c-forward-<>-arglist' below searches past
+            ;; our position.
+            (narrow-to-region (point-min) final-pos)
+
+            (while (and
+                    (progn
+                      (goto-char final-pos)
+                      (c-syntactic-skip-backward "^<;}" nil t)
+                      (eq (char-before) ?<))
+                    (progn
+                      (backward-char)
+                      ;; If the "<" already got open paren syntax we know we
+                      ;; have the matching closer.  Handle it and exit the
+                      ;; loop.
+                      (if (looking-at "\\s\(")
+                          (progn
+                            (c-mark->-as-paren (1- final-pos))
+                            (setq close-paren-inserted t)
+                            nil)
+                        t))
 
+                    (progn
+                      (setq <-pos (point))
+                      (c-backward-syntactic-ws)
+                      (c-simple-skip-symbol-backward))
+                    (or (looking-at c-opt-<>-sexp-key)
+                        (not (looking-at c-keywords-regexp)))
+
+                    (let ((c-parse-and-markup-<>-arglists t)
+                          c-restricted-<>-arglists
+                          (containing-sexp
+                           (c-most-enclosing-brace (c-parse-state))))
+                      (when (and containing-sexp
+                                 (progn (goto-char containing-sexp)
+                                        (eq (char-after) ?\())
+                                 (not (eq (get-text-property (point) 'c-type)
+                                          'c-decl-arg-start)))
+                        (setq c-restricted-<>-arglists t))
+                      (goto-char <-pos)
+                      (c-forward-<>-arglist nil))
+
+                    ;; Loop here if the "<" we found above belongs to a nested
+                    ;; angle bracket sexp.  When we start over we'll find the
+                    ;; previous or surrounding sexp.
+                    (if (< (point) final-pos)
+                        t
+                      (setq close-paren-inserted t)
+                      nil)))))))
     (goto-char final-pos)
-    (when found-delim
-      (indent-according-to-mode)
-      (when (and (eq (char-before) ?>)
-                 (not executing-kbd-macro)
-                 blink-paren-function)
-            ;; Note: Most paren blink functions, such as the standard
-            ;; `blink-matching-open', currently doesn't handle paren chars
-            ;; marked with text properties very well.  Maybe we should avoid
-            ;; this call for the time being?
-            (funcall blink-paren-function)))))
+
+    ;; Indent the line if appropriate.
+    (when (and c-electric-flag c-syntactic-indentation)
+      (backward-char)
+      (when (prog1 (or (looking-at "\\s\(\\|\\s\)")
+                       (and (c-major-mode-is 'c++-mode)
+                            (progn
+                              (c-beginning-of-current-token)
+                              (looking-at "<<\\|>>"))
+                            (= (match-end 0) final-pos)))
+              (goto-char final-pos))
+        (indent-according-to-mode)))
+
+    (when (and close-paren-inserted
+               (not executing-kbd-macro)
+               blink-paren-function)
+      ;; Note: Most paren blink functions, such as the standard
+      ;; `blink-matching-open', currently doesn't handle paren chars
+      ;; marked with text properties very well.  Maybe we should avoid
+      ;; this call for the time being?
+      (funcall blink-paren-function))))
 
 (defun c-electric-paren (arg)
   "Insert a parenthesis.
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 7eb0016ff43..39036b743c6 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -1029,44 +1029,6 @@ MODE is either a mode symbol or a list of mode symbols."
     ;; Emacs.
     `(remove-text-properties ,from ,to '(,property nil))))
 
-(defmacro c-search-forward-char-property (property value &optional limit)
-  "Search forward for a text-property PROPERTY having value VALUE.
-LIMIT bounds the search.  The comparison is done with `equal'.
-
-Leave point just after the character, and set the match data on
-this character, and return point.  If VALUE isn't found, Return
-nil; point is then left undefined."
-  `(let ((place (point)))
-     (while
-         (and
-          (< place ,(or limit '(point-max)))
-          (not (equal (get-text-property place ,property) ,value)))
-       (setq place (next-single-property-change
-                    place ,property nil ,(or limit '(point-max)))))
-     (when (< place ,(or limit '(point-max)))
-       (goto-char place)
-       (search-forward-regexp ".")      ; to set the match-data.
-       (point))))
-
-(defmacro c-search-backward-char-property (property value &optional limit)
-  "Search backward for a text-property PROPERTY having value VALUE.
-LIMIT bounds the search.  The comparison is done with `equal'.
-
-Leave point just before the character, set the match data on this
-character, and return point.  If VALUE isn't found, Return nil;
-point is then left undefined."
-  `(let ((place (point)))
-     (while
-         (and
-          (> place ,(or limit '(point-min)))
-          (not (equal (get-text-property (1- place) ,property) ,value)))
-       (setq place (previous-single-property-change
-                    place ,property nil ,(or limit '(point-min)))))
-     (when (> place ,(or limit '(point-max)))
-       (goto-char place)
-       (search-backward-regexp ".")     ; to set the match-data.
-       (point))))
-
 (defun c-clear-char-property-with-value-function (from to property value)
   "Remove all text-properties PROPERTY from the region (FROM, TO)
 which have the value VALUE, as tested by `equal'.  These
@@ -1183,117 +1145,23 @@ been put there by c-put-char-property.  POINT remains unchanged."
         (goto-char (point-max)))))
 
 (defconst c-<-as-paren-syntax '(4 . ?>))
-(put 'c-<-as-paren-syntax 'syntax-table c-<-as-paren-syntax)
 
 (defsubst c-mark-<-as-paren (pos)
-  ;; Mark the "<" character at POS as a template opener using the
-  ;; `syntax-table' property via the `category' property.
+  ;; Mark the "<" character at POS as an sexp list opener using the
+  ;; syntax-table property.
   ;;
-  ;; This function does a hidden buffer change.  Note that we use
-  ;; indirection through the `category' text property.  This allows us to
-  ;; toggle the property in all template brackets simultaneously and
-  ;; cheaply.  We use this, for instance, in `c-parse-state'.
-  (c-put-char-property pos 'category 'c-<-as-paren-syntax))
+  ;; This function does a hidden buffer change.
+  (c-put-char-property pos 'syntax-table c-<-as-paren-syntax))
 
 (defconst c->-as-paren-syntax '(5 . ?<))
-(put 'c->-as-paren-syntax 'syntax-table c->-as-paren-syntax)
 
 (defsubst c-mark->-as-paren (pos)
   ;; Mark the ">" character at POS as an sexp list closer using the
   ;; syntax-table property.
   ;;
-  ;; This function does a hidden buffer change.  Note that we use
-  ;; indirection through the `category' text property.  This allows us to
-  ;; toggle the property in all template brackets simultaneously and
-  ;; cheaply.  We use this, for instance, in `c-parse-state'.
-  (c-put-char-property pos 'category 'c->-as-paren-syntax))
-
-(defsubst c-unmark-<->-as-paren (pos)
-  ;; Unmark the "<" or "<" character at POS as an sexp list opener using
-  ;; the syntax-table property indirectly through the `category' text
-  ;; property.
-  ;;
-  ;; This function does a hidden buffer change.  Note that we use
-  ;; indirection through the `category' text property.  This allows us to
-  ;; toggle the property in all template brackets simultaneously and
-  ;; cheaply.  We use this, for instance, in `c-parse-state'.
-  (c-clear-char-property pos 'category))
-
-(defsubst c-suppress-<->-as-parens ()
-  ;; Suppress the syntactic effect of all marked < and > as parens.  Note
-  ;; that this effect is NOT buffer local.  You should probably not use
-  ;; this directly, but only through the macro
-  ;; `c-with-<->-as-parens-suppressed'
-  (put 'c-<-as-paren-syntax 'syntax-table nil)
-  (put 'c->-as-paren-syntax 'syntax-table nil))
-
-(defsubst c-restore-<->-as-parens ()
-  ;; Restore the syntactic effect of all marked <s and >s as parens.  This
-  ;; has no effect on unmarked <s and >s
-  (put 'c-<-as-paren-syntax 'syntax-table c-<-as-paren-syntax)
-  (put 'c->-as-paren-syntax 'syntax-table c->-as-paren-syntax))
-
-(defmacro c-with-<->-as-parens-suppressed (&rest forms)
-  ;; Like progn, except that the paren property is suppressed on all
-  ;; template brackets whilst they are running.  This macro does a hidden
-  ;; buffer change.
-  `(unwind-protect
-       (progn
-         (c-suppress-<->-as-parens)
-         ,@forms)
-     (c-restore-<->-as-parens)))
-
-;;;;;;;;;;;;;;;
-
-(defconst c-cpp-delimiter '(14)) ; generic comment syntax
-;; This is the value of the `category' text property placed on every #
-;; which introduces a CPP construct and every EOL (or EOB, or character
-;; preceding //, etc.) which terminates it.  We can instantly "comment
-;; out" all CPP constructs by giving `c-cpp-delimiter' a syntax-table
-;; propery '(14) (generic comment delimiter).
-(defmacro c-set-cpp-delimiters (beg end)
-  ;; This macro does a hidden buffer change.
-  `(progn
-     (c-put-char-property ,beg 'category 'c-cpp-delimiter)
-     (if (< ,end (point-max))
-         (c-put-char-property ,end 'category 'c-cpp-delimiter))))
-(defmacro c-clear-cpp-delimiters (beg end)
-  ;; This macro does a hidden buffer change.
-  `(progn
-     (c-clear-char-property ,beg 'category)
-     (if (< ,end (point-max))
-         (c-clear-char-property ,end 'category))))
-
-(defsubst c-comment-out-cpps ()
-  ;; Render all preprocessor constructs syntactically commented out.
-  (put 'c-cpp-delimiter 'syntax-table c-cpp-delimiter))
-(defsubst c-uncomment-out-cpps ()
-  ;; Restore the syntactic visibility of preprocessor constructs.
-  (put 'c-cpp-delimiter 'syntax-table nil))
-
-(defmacro c-with-cpps-commented-out (&rest forms)
-  ;; Execute FORMS... whilst the syntactic effect of all characters in
-  ;; all CPP regions is suppressed.  In particular, this is to suppress
-  ;; the syntactic significance of parens/braces/brackets to functions
-  ;; such as `scan-lists' and `parse-partial-sexp'.
-  `(unwind-protect
-       (c-save-buffer-state ()
-           (c-comment-out-cpps)
-           ,@forms)
-     (c-save-buffer-state ()
-       (c-uncomment-out-cpps))))
-
-(defmacro c-with-all-but-one-cpps-commented-out (beg end &rest forms)
-  ;; Execute FORMS... whilst the syntactic effect of all characters in
-  ;; every CPP region APART FROM THE ONE BETWEEN BEG and END is
-  ;; suppressed.
-  `(unwind-protect
-       (c-save-buffer-state ()
-         (c-clear-cpp-delimiters ,beg ,end)
-         ,`(c-with-cpps-commented-out ,@forms))
-     (c-save-buffer-state ()
-       (c-set-cpp-delimiters ,beg ,end))))
-
+  ;; This function does a hidden buffer change.
+  (c-put-char-property pos 'syntax-table c->-as-paren-syntax))
+
 (defsubst c-intersect-lists (list alist)
   ;; return the element of ALIST that matches the first element found
   ;; in LIST.  Uses assq.
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 2d28d003fd5..9c04920a208 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -79,10 +79,6 @@
 ;; Note: This doc is for internal use only.  Other packages should not
 ;; assume that these text properties are used as described here.
 ;;
-;; 'category
-;;   Used for "indirection".  With its help, some other property can
-;;   be cheaply and easily switched on or off everywhere it occurs.
-;;
 ;; 'syntax-table
 ;;   Used to modify the syntax of some characters.  It is used to
 ;;   mark the "<" and ">" of angle bracket parens with paren syntax, and
@@ -260,27 +256,6 @@ comment at the start of cc-engine.el for more info."
              (forward-char)
              t))))
 
-(defun c-syntactic-end-of-macro ()
-  ;; Go to the end of a CPP directive, or a "safe" pos just before.
-  ;;
-  ;; This is normally the end of the next non-escaped line.  A "safe"
-  ;; position is one not within a string or comment.  (The EOL on a line
-  ;; comment is NOT "safe").
-  ;;
-  ;; This function must only be called from the beginning of a CPP construct.
-  ;;
-  ;; Note that this function might do hidden buffer changes.  See the comment
-  ;; at the start of cc-engine.el for more info.
-  (let* ((here (point))
-         (there (progn (c-end-of-macro) (point)))
-         (s (parse-partial-sexp here there)))
-    (while (and (or (nth 3 s)    ; in a string
-                    (nth 4 s))   ; in a comment (maybe at end of line comment)
-                (> there here))  ; No infinite loops, please.
-      (setq there (1- (nth 8 s)))
-      (setq s (parse-partial-sexp here there)))
-    (point)))
-
 (defun c-forward-over-cpp-define-id ()
   ;; Assuming point is at the "#" that introduces a preprocessor
   ;; directive, it's moved forward to the end of the identifier which is
@@ -1972,18 +1947,10 @@ comment at the start of cc-engine.el for more info."
 
 ;; A system for finding noteworthy parens before the point.
 
-(defconst c-state-cache-too-far 5000)
-;; A maximum comfortable scanning distance, e.g. between
-;; `c-state-cache-good-pos' and "HERE" (where we call c-parse-state).  When
-;; this distance is exceeded, we take "emergency meausures", e.g. by clearing
-;; the cache and starting again from point-min or a beginning of defun.  This
-;; value can be tuned for efficiency or set to a lower value for testing.
-
 (defvar c-state-cache nil)
 (make-variable-buffer-local 'c-state-cache)
 ;; The state cache used by `c-parse-state' to cut down the amount of
-;; searching.  It's the result from some earlier `c-parse-state' call.  See
-;; `c-parse-state''s doc string for details of its structure.
+;; searching.  It's the result from some earlier `c-parse-state' call.
 ;;
 ;; The use of the cached info is more effective if the next
 ;; `c-parse-state' call is on a line close by the one the cached state
@@ -1992,12 +1959,18 @@ comment at the start of cc-engine.el for more info."
 ;; most effective if `c-parse-state' is used on each line while moving
 ;; forward.
 
+(defvar c-state-cache-start 1)
+(make-variable-buffer-local 'c-state-cache-start)
+;; This is (point-min) when `c-state-cache' was calculated, since a
+;; change of narrowing is likely to affect the parens that are visible
+;; before the point.
+
 (defvar c-state-cache-good-pos 1)
 (make-variable-buffer-local 'c-state-cache-good-pos)
-;; This is a position where `c-state-cache' is known to be correct, or
-;; nil (see below).  It's a position inside one of the recorded unclosed
-;; parens or the top level, but not further nested inside any literal or
-;; subparen that is closed before the last recorded position.
+;; This is a position where `c-state-cache' is known to be correct.
+;; It's a position inside one of the recorded unclosed parens or the
+;; top level, but not further nested inside any literal or subparen
+;; that is closed before the last recorded position.
 ;;
 ;; The exact position is chosen to try to be close to yet earlier than
 ;; the position where `c-state-cache' will be called next.  Right now
@@ -2005,1057 +1978,313 @@ comment at the start of cc-engine.el for more info."
 ;; closing paren (of any type) before the line on which
 ;; `c-parse-state' was called.  That is chosen primarily to work well
 ;; with refontification of the current line.
-;;
-;; 2009-07-28: When `c-state-point-min' and the last position where
-;; `c-parse-state' or for which `c-invalidate-state-cache' was called, are
-;; both in the same literal, there is no such "good position", and
-;; c-state-cache-good-pos is then nil.  This is the ONLY circumstance in which
-;; it can be nil.  In this case, `c-state-point-min-literal' will be non-nil.
-;;
-;; 2009-06-12: In a brace desert, c-state-cache-good-pos may also be in
-;; the middle of the desert, as long as it is not within a brace pair
-;; recorded in `c-state-cache' or a paren/bracket pair.
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; We maintain a simple cache of positions which aren't in a literal, so as to
-;; speed up testing for non-literality.
-(defconst c-state-nonlit-pos-interval 10000)
-;; The approximate interval between entries in `c-state-nonlit-pos-cache'.
-
-(defvar c-state-nonlit-pos-cache nil)
-(make-variable-buffer-local 'c-state-nonlit-pos-cache)
-;; A list of buffer positions which are known not to be in a literal.  This is
-;; ordered with higher positions at the front of the list.  Only those which
-;; are less than `c-state-nonlit-pos-cache-limit' are valid.
-
-(defvar c-state-nonlit-pos-cache-limit 1)
-(make-variable-buffer-local 'c-state-nonlit-pos-cache-limit)
-;; An upper limit on valid entries in `c-state-nonlit-pos-cache'.  This is
-;; reduced by buffer changes, and increased by invocations of
-;; `c-state-literal-at'.
-
-(defsubst c-state-pp-to-literal (from to)
-  ;; Do a parse-partial-sexp from FROM to TO, returning the bounds of any
-  ;; literal at TO as a cons, otherwise NIL.
-  ;; FROM must not be in a literal, and the buffer should already be wide
-  ;; enough.
-  (save-excursion
-    (let ((s (parse-partial-sexp from to)))
-      (when (or (nth 3 s) (nth 4 s))    ; in a string or comment
-        (parse-partial-sexp (point) (point-max)
-                            nil                  ; TARGETDEPTH
-                            nil                  ; STOPBEFORE
-                            s                    ; OLDSTATE
-                            'syntax-table)       ; stop at end of literal
-        (cons (nth 8 s) (point))))))
-
-(defun c-state-literal-at (here)
-  ;; If position HERE is inside a literal, return (START . END), the
-  ;; boundaries of the literal (which may be outside the accessible bit of the
-  ;; buffer).  Otherwise, return nil.
-  ;;
-  ;; This function is almost the same as `c-literal-limits'.  It differs in
-  ;; that it is a lower level function, and that it rigourously follows the
-  ;; syntax from BOB, whereas `c-literal-limits' uses a "local" safe position.
-  (save-restriction
-    (widen)
-    (save-excursion
-      (let ((c c-state-nonlit-pos-cache)
-            pos npos lit)
-        ;; Trim the cache to take account of buffer changes.
-        (while (and c (> (car c) c-state-nonlit-pos-cache-limit))
-          (setq c (cdr c)))
-        (setq c-state-nonlit-pos-cache c)
-
-        (while (and c (> (car c) here))
-          (setq c (cdr c)))
-        (setq pos (or (car c) (point-min)))
-
-        (while (<= (setq npos (+ pos c-state-nonlit-pos-interval))
-                   here)
-          (setq lit (c-state-pp-to-literal pos npos))
-          (setq pos (or (cdr lit) npos)) ; end of literal containing npos.
-          (setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
-
-        (if (> pos c-state-nonlit-pos-cache-limit)
-            (setq c-state-nonlit-pos-cache-limit pos))
-        (if (< pos here)
-            (setq lit (c-state-pp-to-literal pos here)))
-        lit))))
-
-(defsubst c-state-lit-beg (pos)
-  ;; Return the start of the literal containing POS, or POS itself.
-  (or (car (c-state-literal-at pos))
-      pos))
-
-(defsubst c-state-cache-non-literal-place (pos state)
-  ;; Return a position outside of a string/comment at or before POS.
-  ;; STATE is the parse-partial-sexp state at POS.
-  (if (or (nth 3 state)                 ; in a string?
-          (nth 4 state))                ; in a comment?
-      (nth 8 state)
-    pos))
 
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Stuff to do with point-min, and coping with any literal there.
-(defvar c-state-point-min 1)
-(make-variable-buffer-local 'c-state-point-min)
-;; This is (point-min) when `c-state-cache' was last calculated.  A change of
-;; narrowing is likely to affect the parens that are visible before the point.
-
-(defvar c-state-point-min-lit-type nil)
-(make-variable-buffer-local 'c-state-point-min-lit-type)
-(defvar c-state-point-min-lit-start nil)
-(make-variable-buffer-local 'c-state-point-min-lit-start)
-;; These two variables define the literal, if any, containing point-min.
-;; Their values are, respectively, 'string, c, or c++, and the start of the
-;; literal.  If there's no literal there, they're both nil.
-
-(defvar c-state-min-scan-pos 1)
-(make-variable-buffer-local 'c-state-min-scan-pos)
-;; This is the earliest buffer-pos from which scanning can be done.  It is
-;; either the end of the literal containing point-min, or point-min itself.
-;; It becomes nil if the buffer is changed earlier than this point.
-(defun c-state-get-min-scan-pos ()
-  ;; Return the lowest valid scanning pos.  This will be the end of the
-  ;; literal enclosing point-min, or point-min itself.
-  (or c-state-min-scan-pos
-      (save-restriction
-        (save-excursion
-          (widen)
-          (goto-char c-state-point-min-lit-start)
-          (if (eq c-state-point-min-lit-type 'string)
-              (forward-sexp)
-            (forward-comment 1))
-          (setq c-state-min-scan-pos (point))))))
-
-(defun c-state-mark-point-min-literal ()
-  ;; Determine the properties of any literal containing POINT-MIN, setting the
-  ;; variables `c-state-point-min-lit-type', `c-state-point-min-lit-start',
-  ;; and `c-state-min-scan-pos' accordingly.  The return value is meaningless.
-  (let ((p-min (point-min))
-        lit)
-    (save-restriction
-      (widen)
-      (setq lit (c-state-literal-at p-min))
-      (if lit
-          (setq c-state-point-min-lit-type
-                (save-excursion
-                  (goto-char (car lit))
-                  (cond
-                   ((looking-at c-block-comment-start-regexp) 'c)
-                   ((looking-at c-line-comment-starter) 'c++)
-                   (t 'string)))
-                c-state-point-min-lit-start (car lit)
-                c-state-min-scan-pos (cdr lit))
-        (setq c-state-point-min-lit-type nil
-              c-state-point-min-lit-start nil
-              c-state-min-scan-pos p-min)))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; A variable which signals a brace dessert - helpful for reducing the number
-;; of fruitless backward scans.
-(defvar c-state-brace-pair-desert nil)
-(make-variable-buffer-local 'c-state-brace-pair-desert)
-;; Used only in `c-append-lower-brace-pair-to-state-cache'.  It is set when an
-;; that defun has searched backwards for a brace pair and not found one.  Its
-;; value is either nil or a cons (PA . FROM), where PA is the position of the
-;; enclosing opening paren/brace/bracket which bounds the backwards search (or
-;; nil when at top level) and FROM is where the backward search started.  It
-;; is reset to nil in `c-invalidate-state-cache'.
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Lowish level functions/macros which work directly on `c-state-cache', or a
-;; list of like structure.
-(defmacro c-state-cache-top-lparen (&optional cache)
-  ;; Return the address of the top left brace/bracket/paren recorded in CACHE
-  ;; (default `c-state-cache') (or nil).
-  (let ((cash (or cache 'c-state-cache)))
-    `(if (consp (car ,cash))
-         (caar ,cash)
-       (car ,cash))))
-
-(defmacro c-state-cache-top-paren (&optional cache)
-  ;; Return the address of the latest brace/bracket/paren (whether left or
-  ;; right) recorded in CACHE (default `c-state-cache') or nil.
-  (let ((cash (or cache 'c-state-cache)))
-    `(if (consp (car ,cash))
-         (cdar ,cash)
-       (car ,cash))))
-
-(defmacro c-state-cache-after-top-paren (&optional cache)
-  ;; Return the position just after the latest brace/bracket/paren (whether
-  ;; left or right) recorded in CACHE (default `c-state-cache') or nil.
-  (let ((cash (or cache 'c-state-cache)))
-    `(if (consp (car ,cash))
-         (cdar ,cash)
-       (and (car ,cash)
-            (1+ (car ,cash))))))
-
-(defun c-get-cache-scan-pos (here)
-  ;; From the state-cache, determine the buffer position from which we might
-  ;; scan forward to HERE to update this cache.  This position will be just
-  ;; after a paren/brace/bracket recorded in the cache, if possible, otherwise
-  ;; return the earliest position in the accessible region which isn't within
-  ;; a literal.  If the visible portion of the buffer is entirely within a
-  ;; literal, return NIL.
-  (let ((c c-state-cache) elt)
-    ;(while (>= (or (c-state-cache-top-lparen c) 1) here)
-    (while (and c
-                (>= (c-state-cache-top-lparen c) here))
-      (setq c (cdr c)))
-
-    (setq elt (car c))
-    (cond
-     ((consp elt)
-      (if (> (cdr elt) here)
-          (1+ (car elt))
-        (cdr elt)))
-     (elt (1+ elt))
-     ((<= (c-state-get-min-scan-pos) here)
-      (c-state-get-min-scan-pos))
-     (t nil))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Variables which keep track of preprocessor constructs.
-(defvar c-state-old-cpp-beg nil)
-(make-variable-buffer-local 'c-state-old-cpp-beg)
-(defvar c-state-old-cpp-end nil)
-(make-variable-buffer-local 'c-state-old-cpp-end)
-;; These are the limits of the macro containing point at the previous call of
-;; `c-parse-state', or nil.
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Defuns which analyse the buffer, yet don't change `c-state-cache'.
-(defun c-get-fallback-scan-pos (here)
-  ;; Return a start position for building `c-state-cache' from
-  ;; scratch.  This will be at the top level, 2 defuns back.
+(defsubst c-invalidate-state-cache (pos)
+  ;; Invalidate all info on `c-state-cache' that applies to the buffer
+  ;; at POS or higher.  This is much like `c-whack-state-after', but
+  ;; it never changes a paren pair element into an open paren element.
+  ;; Doing that would mean that the new open paren wouldn't have the
+  ;; required preceding paren pair element.
+  (while (and (or c-state-cache
+                  (when (< pos c-state-cache-good-pos)
+                    (setq c-state-cache-good-pos 1)
+                    nil))
+              (let ((elem (car c-state-cache)))
+                (if (consp elem)
+                    (or (< pos (cdr elem))
+                        (when (< pos c-state-cache-good-pos)
+                          (setq c-state-cache-good-pos (cdr elem))
+                          nil))
+                  (or (<= pos elem)
+                      (when (< pos c-state-cache-good-pos)
+                        (setq c-state-cache-good-pos (1+ elem))
+                        nil)))))
+    (setq c-state-cache (cdr c-state-cache))))
+
+(defun c-get-fallback-start-pos (here)
+  ;; Return the start position for building `c-state-cache' from
+  ;; scratch.
   (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.
+        (c-beginning-of-defun-1)
         (if (eq (char-after) ?\{)
             (setq cnt (1- cnt)))))
     (point)))
 
-(defun c-state-balance-parens-backwards (here top)
-  ;; Return the position of the opening paren/brace/bracket before HERE which
-  ;; matches the outermost close p/b/b between HERE and TOP, like this:
-  ;;
-  ;;      ......................................
-  ;;      |                                    |
-  ;;      (    [ ( ...........  )      ( )  ]  )
-  ;;      ^                 ^                       ^
-  ;;      |                 |                       |
-  ;;   return             HERE                     TOP
-  ;;
-  ;; If there aren't enough opening paren/brace/brackets, return the position
-  ;; of the outermost one found, or HERE it there are none.  If there are no
-  ;; closeing p/b/bs between HERE and TOP, return HERE.  HERE and TOP must not
-  ;; be inside literals.  Only the accessible portion of the buffer will be
-  ;; scanned.
-
-  ;; PART 1: scan from `here' up to `top', accumulating ")"s which enclose
-  ;; `here'.  Go round the next loop each time we pass over such a ")".  These
-  ;; probably match "("s before `here'.
-  (let (pos pa ren+1 lonely-rens)
-    (save-excursion
-      (save-restriction
-        (narrow-to-region (point-min) top) ; This can move point, sometimes.
-        (setq pos here)
-        (c-safe
-          (while
-              (setq ren+1 (scan-lists pos 1 1)) ; might signal
-            (setq lonely-rens (cons ren+1 lonely-rens)
-                  pos ren+1)))))
-
-      ;; PART 2: Scan back before `here' searching for the "("s
-      ;; matching/mismatching the ")"s found above. We only need to direct the
-      ;; caller to scan when we've encountered unmatched right parens.
-      (when lonely-rens
-        (setq pos here)
-        (c-safe
-          (while
-              (and lonely-rens          ; actual values aren't used.
-                   (setq pa (scan-lists pos -1 1)))
-            (setq pos pa)
-            (setq lonely-rens (cdr lonely-rens)))) ;)
-        )
-      pos))
-
-(defun c-parse-state-get-strategy (here good-pos)
-  ;; Determine the scanning strategy for adjusting `c-parse-state', attempting
-  ;; to minimise the amount of scanning.  HERE is the pertinent position in
-  ;; the buffer, GOOD-POS is a position where `c-state-cache' (possibly with
-  ;; its head trimmed) is known to be good, or nil if there is no such
-  ;; position.
-  ;;
-  ;; The return value is a list, one of the following:
-  ;;
-  ;; o - ('forward CACHE-POS START-POINT) - scan forward from START-POINT,
-  ;;                                        which is not less than CACHE-POS.
-  ;; o - ('backward CACHE-POS nil) - scan backwards (from HERE).
-  ;; o - ('BOD nil START-POINT) - scan forwards from START-POINT, which is at the
-  ;;   top level.
-  ;; o - ('IN-LIT nil nil) - point is inside the literal containing point-min.
-  ;; , where CACHE-POS is the highest position recorded in `c-state-cache' at
-  ;; or below HERE.
-  (let ((cache-pos (c-get-cache-scan-pos here)) ; highest position below HERE in cache (or 1)
-        BOD-pos             ; position of 2nd BOD before HERE.
-        strategy            ; 'forward, 'backward, 'BOD, or 'IN-LIT.
-        start-point
-        how-far)                        ; putative scanning distance.
-    (setq good-pos (or good-pos (c-state-get-min-scan-pos)))
-    (cond
-     ((< here (c-state-get-min-scan-pos))
-      (setq strategy 'IN-LIT
-            start-point nil
-            cache-pos nil
-            how-far 0))
-     ((<= good-pos here)
-      (setq strategy 'forward
-            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
-            how-far (- good-pos here)))
-     (t
-      (setq strategy 'forward
-              how-far (- here cache-pos)
-              start-point cache-pos)))
-
-    ;; Might we be better off starting from the top level, two defuns back,
-    ;; instead?
-    (when (> how-far c-state-cache-too-far)
-      (setq BOD-pos (c-get-fallback-scan-pos here)) ; somewhat EXPENSIVE!!!
-      (if (< (- here BOD-pos) how-far)
-          (setq strategy 'BOD
-                start-point BOD-pos)))
-
-    (list
-     strategy
-     (and (memq strategy '(forward backward)) cache-pos)
-     (and (memq strategy '(forward BOD)) start-point))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Routines which change `c-state-cache' and associated values.
-(defun c-renarrow-state-cache ()
-  ;; The region (more precisely, point-min) has changed since we
-  ;; calculated `c-state-cache'.  Amend `c-state-cache' accordingly.
-  (if (< (point-min) c-state-point-min)
-      ;; If point-min has MOVED BACKWARDS then we drop the state completely.
-      ;; It would be possible to do a better job here and recalculate the top
-      ;; only.
-      (progn
-        (c-state-mark-point-min-literal)
-        (setq c-state-cache nil
-              c-state-cache-good-pos c-state-min-scan-pos
-              c-state-brace-pair-desert nil))
-
-    ;; point-min has MOVED FORWARD.
-
-    ;; Is the new point-min inside a (different) literal?
-    (unless (and c-state-point-min-lit-start ; at prev. point-min
-                 (< (point-min) (c-state-get-min-scan-pos)))
-      (c-state-mark-point-min-literal))
-
-    ;; Cut off a bit of the tail from `c-state-cache'.
-    (let ((ptr (cons nil c-state-cache))
-          pa)
-      (while (and (setq pa (c-state-cache-top-lparen (cdr ptr)))
-                  (>= pa (point-min)))
-        (setq ptr (cdr ptr)))
-
-      (when (consp ptr)
-        (if (eq (cdr ptr) c-state-cache)
-            (setq c-state-cache nil
-                  c-state-cache-good-pos c-state-min-scan-pos)
-          (setcdr ptr nil)
-          (setq c-state-cache-good-pos (1+ (c-state-cache-top-lparen))))
-        )))
-
-  (setq c-state-point-min (point-min)))
-
-(defun c-append-lower-brace-pair-to-state-cache (from &optional upper-lim)
-  ;; If there is a brace pair preceding FROM in the buffer (not necessarily
-  ;; immediately preceding), push a cons onto `c-state-cache' to represent it.
-  ;; FROM must not be inside a literal.  If UPPER-LIM is non-nil, we append
-  ;; the highest brace pair whose "}" is below UPPER-LIM.
-  ;;
-  ;; Return non-nil when this has been done.
-  ;;
-  ;; This routine should be fast.  Since it can get called a LOT, we maintain
-  ;; `c-state-brace-pair-desert', a small cache of "failures", such that we
-  ;; reduce the time wasted in repeated fruitless searches in brace deserts.
-  (save-excursion
-    (save-restriction
-      (let ((bra from) ce               ; Positions of "{" and "}".
-            new-cons
-            (cache-pos (c-state-cache-top-lparen)) ; might be nil.
-            (macro-start-or-from
-             (progn (goto-char from)
-                    (c-beginning-of-macro)
-                    (point))))
-        (or upper-lim (setq upper-lim from))
-
-        ;; If we're essentially repeating a fruitless search, just give up.
-        (unless (and c-state-brace-pair-desert
-                     (eq cache-pos (car c-state-brace-pair-desert))
-                     (<= from (cdr c-state-brace-pair-desert)))
-          ;; Only search what we absolutely need to:
-          (if (and c-state-brace-pair-desert
-                   (> from (cdr c-state-brace-pair-desert)))
-              (narrow-to-region (cdr c-state-brace-pair-desert) (point-max)))
-
-          ;; In the next pair of nested loops, the inner one moves back past a
-          ;; pair of (mis-)matching parens or brackets; the outer one moves
-          ;; back over a sequence of unmatched close brace/paren/bracket each
-          ;; time round.
-          (while
-              (progn
-                (c-safe
-                  (while
-                      (and (setq ce (scan-lists bra -1 -1)) ; back past )/]/}; might signal
-                           (setq bra (scan-lists ce -1 1)) ; back past (/[/{; might signal
-                           (or (> ce upper-lim)
-                               (not (eq (char-after bra) ?\{))
-                               (and (goto-char bra)
-                                    (c-beginning-of-macro)
-                                    (< (point) macro-start-or-from))))))
-                (and ce (< ce bra)))
-            (setq bra ce))      ; If we just backed over an unbalanced closing
-                                        ; brace, ignore it.
-
-          (if (and ce (< bra ce) (eq (char-after bra) ?\{))
-              ;; We've found the desired brace-pair.
-              (progn
-                (setq new-cons (cons bra (1+ ce)))
-                (cond
-                 ((consp (car c-state-cache))
-                  (setcar c-state-cache new-cons))
-                 ((and (numberp (car c-state-cache)) ; probably never happens
-                       (< ce (car c-state-cache)))
-                  (setcdr c-state-cache
-                          (cons new-cons (cdr c-state-cache))))
-                 (t (setq c-state-cache (cons new-cons c-state-cache)))))
-
-            ;; We haven't found a brace pair.  Record this.
-            (setq c-state-brace-pair-desert (cons cache-pos from))))))))
-
-(defsubst c-state-push-any-brace-pair (bra+1 macro-start-or-here)
-  ;; If BRA+1 is nil, do nothing.  Otherwise, BRA+1 is the buffer position
-  ;; following a {, and that brace has a (mis-)matching } (or ]), and we
-  ;; "push" "a" brace pair onto `c-state-cache'.
-  ;;
-  ;; Here "push" means overwrite the top element if it's itself a brace-pair,
-  ;; otherwise push it normally.
-  ;;
-  ;; The brace pair we push is normally the one surrounding BRA+1, but if the
-  ;; latter is inside a macro, not being a macro containing
-  ;; MACRO-START-OR-HERE, we scan backwards through the buffer for a non-macro
-  ;; base pair.  This latter case is assumed to be rare.
-  ;;
-  ;; Note: POINT is not preserved in this routine.
-  (if bra+1
-      (if (or (> bra+1 macro-start-or-here)
-              (progn (goto-char bra+1)
-                     (not (c-beginning-of-macro))))
-          (setq c-state-cache
-                (cons (cons (1- bra+1)
-                            (scan-lists bra+1 1 1))
-                      (if (consp (car c-state-cache))
-                          (cdr c-state-cache)
-                        c-state-cache)))
-        ;; N.B.  This defsubst codes one method for the simple, normal case,
-        ;; and a more sophisticated, slower way for the general case.  Don't
-        ;; eliminate this defsubst - it's a speed optimisation.
-        (c-append-lower-brace-pair-to-state-cache (1- bra+1)))))
-
-(defun c-append-to-state-cache (from)
-  ;; Scan the buffer from FROM to (point-max), adding elements into
-  ;; `c-state-cache' for braces etc.  Return a candidate for
-  ;; `c-state-cache-good-pos'.
-  ;;
-  ;; FROM must be after the latest brace/paren/bracket in `c-state-cache', if
-  ;; any.  Typically, it is immediately after it.  It must not be inside a
-  ;; literal.
-  (let ((here-bol (c-point 'bol (point-max)))
-        (macro-start-or-here
-         (save-excursion (goto-char (point-max))
-                         (if (c-beginning-of-macro)
-                             (point)
-                           (point-max))))
-        pa+1                  ; pos just after an opening PAren (or brace).
-        (ren+1 from)          ; usually a pos just after an closing paREN etc.
-                              ; Is actually the pos. to scan for a (/{/[ from,
-                              ; which sometimes is after a silly )/}/].
-        paren+1               ; Pos after some opening or closing paren.
-        paren+1s              ; A list of `paren+1's; used to determine a
-                              ; good-pos.
-        bra+1 ce+1            ; just after L/R bra-ces.
-        bra+1s                ; list of OLD values of bra+1.
-        mstart)               ; start of a macro.
-
-    (save-excursion
-      ;; Each time round the following loop, we enter a succesively deeper
-      ;; level of brace/paren nesting.  (Except sometimes we "continue at
-      ;; the existing level".)  `pa+1' is a pos inside an opening
-      ;; brace/paren/bracket, usually just after it.
-      (while
-          (progn
-            ;; Each time round the next loop moves forward over an opening then
-            ;; a closing brace/bracket/paren.  This loop is white hot, so it
-            ;; plays ugly tricks to go fast.  DON'T PUT ANYTHING INTO THIS
-            ;; LOOP WHICH ISN'T ABSOLUTELY NECESSARY!!!  It terminates when a
-            ;; call of `scan-lists' signals an error, which happens when there
-            ;; are no more b/b/p's to scan.
-            (c-safe
-              (while t
-                (setq pa+1 (scan-lists ren+1 1 -1) ; Into (/{/[; might signal
-                      paren+1s (cons pa+1 paren+1s))
-                (setq ren+1 (scan-lists pa+1 1 1)) ; Out of )/}/]; might signal
-                (if (and (eq (char-before pa+1) ?{)) ; Check for a macro later.
-                    (setq bra+1 pa+1))
-                (setcar paren+1s ren+1)))
-
-            (if (and pa+1 (> pa+1 ren+1))
-                ;; We've just entered a deeper nesting level.
-                (progn
-                  ;; Insert the brace pair (if present) and the single open
-                  ;; paren/brace/bracket into `c-state-cache' It cannot be
-                  ;; inside a macro, except one around point, because of what
-                  ;; `c-neutralize-syntax-in-CPP' has done.
-                  (c-state-push-any-brace-pair bra+1 macro-start-or-here)
-                  ;; Insert the opening brace/bracket/paren position.
-                  (setq c-state-cache (cons (1- pa+1) c-state-cache))
-                  ;; Clear admin stuff for the next more nested part of the scan.
-                  (setq ren+1 pa+1  pa+1 nil  bra+1 nil  bra+1s nil)
-                  t)                    ; Carry on the loop
-
-              ;; All open p/b/b's at this nesting level, if any, have probably
-              ;; been closed by matching/mismatching ones.  We're probably
-              ;; finished - we just need to check for having found an
-              ;; unmatched )/}/], which we ignore.  Such a )/}/] can't be in a
-              ;; macro, due the action of `c-neutralize-syntax-in-CPP'.
-              (c-safe (setq ren+1 (scan-lists ren+1 1 1)))))) ; acts as loop control.
-
-      ;; Record the final, innermost, brace-pair if there is one.
-      (c-state-push-any-brace-pair bra+1 macro-start-or-here)
-
-      ;; Determine a good pos
-      (while (and (setq paren+1 (car paren+1s))
-                  (> (if (> paren+1 macro-start-or-here)
-                         paren+1
-                       (goto-char paren+1)
-                       (setq mstart (and (c-beginning-of-macro)
-                                         (point)))
-                       (or mstart paren+1))
-                     here-bol))
-        (setq paren+1s (cdr paren+1s)))
-      (cond
-       ((and paren+1 mstart)
-        (min paren+1 mstart))
-       (paren+1)
-       (t from)))))
-
-(defun c-remove-stale-state-cache (good-pos pps-point)
-  ;; Remove stale entries from the `c-cache-state', i.e. those which will
-  ;; not be in it when it is amended for position (point-max).
-  ;; Additionally, the "outermost" open-brace entry before (point-max)
-  ;; will be converted to a cons if the matching close-brace is scanned.
-  ;;
-  ;; GOOD-POS is a "maximal" "safe position" - there must be no open
-  ;; parens/braces/brackets between GOOD-POS and (point-max).
-  ;;
-  ;; As a second thing, calculate the result of parse-partial-sexp at
-  ;; PPS-POINT, w.r.t. GOOD-POS.  The motivation here is that
-  ;; `c-state-cache-good-pos' may become PPS-POINT, but the caller may need to
-  ;; adjust it to get outside a string/comment.  (Sorry about this!  The code
-  ;; needs to be FAST).
-  ;;
-  ;; Return a list (GOOD-POS SCAN-BACK-POS PPS-STATE), where
-  ;; o - GOOD-POS is a position where the new value `c-state-cache' is known
-  ;;   to be good (we aim for this to be as high as possible);
-  ;; o - SCAN-BACK-POS, if not nil, indicates there may be a brace pair
-  ;;   preceding POS which needs to be recorded in `c-state-cache'.  It is a
-  ;;   position to scan backwards from.
-  ;; o - PPS-STATE is the parse-partial-sexp state at PPS-POINT.
-  (save-restriction
-    (narrow-to-region 1 (point-max))
-    (save-excursion
-      (let* ((in-macro-start   ; start of macro containing (point-max) or nil.
-              (save-excursion
-                (goto-char (point-max))
-                (and (c-beginning-of-macro)
-                     (point))))
-             (good-pos-actual-macro-start ; Start of macro containing good-pos
-                                        ; or nil
-              (and (< good-pos (point-max))
-                   (save-excursion
-                     (goto-char good-pos)
-                     (and (c-beginning-of-macro)
-                          (point)))))
-             (good-pos-actual-macro-end ; End of this macro, (maybe
-                                        ; (point-max)), or nil.
-              (and good-pos-actual-macro-start
-                   (save-excursion
-                     (goto-char good-pos-actual-macro-start)
-                     (c-end-of-macro)
-                     (point))))
-             pps-state                  ; Will be 9 or 10 elements long.
-             pos
-             upper-lim     ; ,beyond which `c-state-cache' entries are removed
-             scan-back-pos
-             pair-beg pps-point-state target-depth)
-
-        ;; Remove entries beyond (point-max).  Also remove any entries inside
-        ;; a macro, unless (point-max) is in the same macro.
-        (setq upper-lim
-              (if (or (null c-state-old-cpp-beg)
-                      (and (> (point-max) c-state-old-cpp-beg)
-                           (< (point-max) c-state-old-cpp-end)))
-                  (point-max)
-                (min (point-max) c-state-old-cpp-beg)))
-        (while (and c-state-cache (>= (c-state-cache-top-lparen) upper-lim))
-          (setq c-state-cache (cdr c-state-cache)))
-        ;; If `upper-lim' is inside the last recorded brace pair, remove its
-        ;; RBrace and indicate we'll need to search backwards for a previous
-        ;; brace pair.
-        (when (and c-state-cache
-                   (consp (car c-state-cache))
-                   (> (cdar c-state-cache) upper-lim))
-          (setcar c-state-cache (caar c-state-cache))
-          (setq scan-back-pos (car c-state-cache)))
-
-        ;; The next loop jumps forward out of a nested level of parens each
-        ;; time round; the corresponding elements in `c-state-cache' are
-        ;; removed.  `pos' is just after the brace-pair or the open paren at
-        ;; (car c-state-cache).  There can be no open parens/braces/brackets
-        ;; between `good-pos'/`good-pos-actual-macro-start' and (point-max),
-        ;; due to the interface spec to this function.
-        (setq pos (if (and good-pos-actual-macro-end
-                           (not (eq good-pos-actual-macro-start
-                                    in-macro-start)))
-                      (1+ good-pos-actual-macro-end) ; get outside the macro as
-                                        ; marked by a `category' text property.
-                    good-pos))
-        (goto-char pos)
-        (while (and c-state-cache
-                    (< (point) (point-max)))
-          (cond
-           ((null pps-state)            ; first time through
-            (setq target-depth -1))
-           ((eq (car pps-state) target-depth) ; found closing ),},]
-            (setq target-depth (1- (car pps-state))))
-           ;; Do nothing when we've merely reached pps-point.
-           )
-
-          ;; Scan!
-          (setq pps-state
-                (parse-partial-sexp
-                 (point) (if (< (point) pps-point) pps-point (point-max))
-                 target-depth
-                 nil pps-state))
-
-          (if (= (point) pps-point)
-              (setq pps-point-state pps-state))
-
-          (when (eq (car pps-state) target-depth)
-            (setq pos (point))       ; POS is now just after an R-paren/brace.
-            (cond
-             ((and (consp (car c-state-cache))
-                   (eq (point) (cdar c-state-cache)))
-                ;; We've just moved out of the paren pair containing the brace-pair
-                ;; at (car c-state-cache).  `pair-beg' is where the open paren is,
-                ;; and is potentially where the open brace of a cons in
-                ;; c-state-cache will be.
-              (setq pair-beg (car-safe (cdr c-state-cache))
-                    c-state-cache (cdr-safe (cdr c-state-cache)))) ; remove {}pair + containing Lparen.
-             ((numberp (car c-state-cache))
-              (setq pair-beg (car c-state-cache)
-                    c-state-cache (cdr c-state-cache))) ; remove this
-                                        ; containing Lparen
-             ((numberp (cadr c-state-cache))
-              (setq pair-beg (cadr c-state-cache)
-                    c-state-cache (cddr c-state-cache))) ; Remove a paren pair
-                                        ; together with enclosed brace pair.
-             ;; (t nil)                 ; Ignore an unmated Rparen.
-             )))
-
-        (if (< (point) pps-point)
-            (setq pps-state (parse-partial-sexp (point) pps-point
-                                                nil nil ; TARGETDEPTH, STOPBEFORE
-                                                pps-state)))
-
-        ;; If the last paren pair we moved out of was actually a brace pair,
-        ;; insert it into `c-state-cache'.
-        (when (and pair-beg (eq (char-after pair-beg) ?{))
-          (if (consp (car-safe c-state-cache))
-              (setq c-state-cache (cdr c-state-cache)))
-          (setq c-state-cache (cons (cons pair-beg pos)
-                                    c-state-cache)))
-
-        (list pos scan-back-pos pps-state)))))
-
-(defun c-remove-stale-state-cache-backwards (here cache-pos)
-  ;; Strip stale elements of `c-state-cache' by moving backwards through the
-  ;; buffer, and inform the caller of the scenario detected.
-  ;;
-  ;; HERE is the position we're setting `c-state-cache' for.
-  ;; CACHE-POS is just after the latest recorded position in `c-state-cache'
-  ;;   before HERE, or a position at or near point-min which isn't in a
-  ;;   literal.
-  ;;
-  ;; This function must only be called only when (> `c-state-cache-good-pos'
-  ;; HERE).  Usually the gap between CACHE-POS and HERE is large.  It is thus
-  ;; optimised to eliminate (or minimise) scanning between these two
-  ;; positions.
-  ;;
-  ;; Return a three element list (GOOD-POS SCAN-BACK-POS FWD-FLAG), where:
-  ;; o - GOOD-POS is a "good position", where `c-state-cache' is valid, or
-  ;;   could become so after missing elements are inserted into
-  ;;   `c-state-cache'.  This is JUST AFTER an opening or closing
-  ;;   brace/paren/bracket which is already in `c-state-cache' or just before
-  ;;   one otherwise.  exceptionally (when there's no such b/p/b handy) the BOL
-  ;;   before `here''s line, or the start of the literal containing it.
-  ;; o - SCAN-BACK-POS, if non-nil, indicates there may be a brace pair
-  ;;   preceding POS which isn't recorded in `c-state-cache'.  It is a position
-  ;;   to scan backwards from.
-  ;; o - FWD-FLAG, if non-nil, indicates there may be parens/braces between
-  ;;   POS and HERE which aren't recorded in `c-state-cache'.
-  ;;
-  ;; The comments in this defun use "paren" to mean parenthesis or square
-  ;; bracket (as contrasted with a brace), and "(" and ")" likewise.
-  ;;
-  ;;    .   {..} (..) (..)  ( .. {   }  ) (...)    ( ....          .  ..)
-  ;;    |                   |       |   |     |                    |
-  ;;    CP                  E      here D     C                   good
-  (let ((pos c-state-cache-good-pos)
-        pa ren         ; positions of "(" and ")"
-        dropped-cons ; whether the last element dropped from `c-state-cache'
-                     ; was a cons (representing a brace-pair)
-        good-pos                        ; see above.
-        lit         ; (START . END) of a literal containing some point.
-        here-lit-start here-lit-end     ; bounds of literal containing `here'
-                                        ; or `here' itself.
-        (here-bol (c-point 'bol here))
-        (too-far-back (max (- here c-state-cache-too-far) 1)))
-
-    ;; Remove completely irrelevant entries from `c-state-cache'.
-    (while (and c-state-cache
-                (>= (setq pa (c-state-cache-top-lparen)) here))
-      (setq dropped-cons (consp (car c-state-cache)))
-      (setq c-state-cache (cdr c-state-cache))
-      (setq pos pa))
-    ;; At this stage, (> pos here);
-    ;; (< (c-state-cache-top-lparen) here)  (or is nil).
-
-    ;; CASE 1: The top of the cache is a brace pair which now encloses `here'.
-    ;; As good-pos, return the address. of the "{".
-    (if (and (consp (car c-state-cache))
-             (> (cdar c-state-cache) here))
-        ;; Since we've no knowledge of what's inside these braces, we have no
-        ;; alternative but to direct the caller to scan the buffer from the
-        ;; opening brace.
-        (progn
-          (setq pos (caar c-state-cache))
-          (setcar c-state-cache pos)
-          (list (1+ pos) pos t)) ; return value.  We've just converted a brace
-                                 ; pair entry into a { entry, so the caller
-                                 ; needs to search for a brace pair before the
-                                 ; {.
-
-      ;; ;; `here' might be inside a literal.  Check for this.
-      (setq lit (c-state-literal-at here)
-            here-lit-start (or (car lit) here)
-            here-lit-end (or (cdr lit) here))
-
-      ;; `here' might be nested inside any depth of parens (or brackets but
-      ;; not braces).  Scan backwards to find the outermost such opening
-      ;; paren, if there is one.  This will be the scan position to return.
-      (save-restriction
-        (narrow-to-region cache-pos (point-max))
-        (setq pos (c-state-balance-parens-backwards here-lit-end pos)))
-
-      (if (< pos here-lit-start)
-          ;; CASE 2: Address of outermost ( or [ which now encloses `here',
-          ;; but didn't enclose the (previous) `c-state-cache-good-pos'.  If
-          ;; there is a brace pair preceding this, it will already be in
-          ;; `c-state-cache', unless there was a brace pair after it,
-          ;; i.e. there'll only be one to scan for if we've just deleted one.
-          (list pos (and dropped-cons pos) t) ; Return value.
-
-        ;; `here' isn't enclosed in a (previously unrecorded) bracket/paren.
-        ;; Further forward scanning isn't needed, but we still need to find a
-        ;; GOOD-POS.  Step out of all enclosing "("s on HERE's line.
-        (save-restriction
-          (narrow-to-region here-bol (point-max))
-          (setq pos here-lit-start)
-          (c-safe (while (setq pa (scan-lists pos -1 1))
-                    (setq pos pa))))    ; might signal
-        (if (setq ren (c-safe-scan-lists pos -1 -1 too-far-back))
-            ;; CASE 3: After a }/)/] before `here''s BOL.
-            (list (1+ ren) (and dropped-cons pos) nil) ; Return value
-
-          ;; CASE 4; Best of a bad job: BOL before `here-bol', or beginning of
-          ;; literal containing it.
-          (setq good-pos (c-state-lit-beg (c-point 'bopl here-bol)))
-          (list good-pos (and dropped-cons good-pos) nil))))))
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Externally visible routines.
-
-(defun c-state-cache-init ()
-  (setq c-state-cache nil
-        c-state-cache-good-pos 1
-        c-state-nonlit-pos-cache nil
-        c-state-nonlit-pos-cache-limit 1
-        c-state-brace-pair-desert nil
-        c-state-point-min 1
-        c-state-point-min-lit-type nil
-        c-state-point-min-lit-start nil
-        c-state-min-scan-pos 1
-        c-state-old-cpp-beg nil
-        c-state-old-cpp-end nil)
-  (c-state-mark-point-min-literal))
-
-(defun c-invalidate-state-cache-1 (here)
-  ;; Invalidate all info on `c-state-cache' that applies to the buffer at HERE
-  ;; or higher and set `c-state-cache-good-pos' accordingly.  The cache is
-  ;; left in a consistent state.
-  ;;
-  ;; This is much like `c-whack-state-after', but it never changes a paren
-  ;; pair element into an open paren element.  Doing that would mean that the
-  ;; new open paren wouldn't have the required preceding paren pair element.
-  ;;
-  ;; This function is called from c-after-change.
-
-  ;; The cache of non-literals:
-  (if (< here c-state-nonlit-pos-cache-limit)
-      (setq c-state-nonlit-pos-cache-limit here))
-
-  ;; `c-state-cache':
-  ;; Case 1: if `here' is in a literal containing point-min, everything
-  ;; becomes (or is already) nil.
-  (if (or (null c-state-cache-good-pos)
-          (< here (c-state-get-min-scan-pos)))
-      (setq c-state-cache nil
-            c-state-cache-good-pos nil
-            c-state-min-scan-pos nil)
-
-;;; Truncate `c-state-cache' and set `c-state-cache-good-pos' to a value below
-;;; `here'.  To maintain its consistency, we may need to insert a new brace
-;;; pair.
-    (let ((here-bol (c-point 'bol here))
-          too-high-pa             ; recorded {/(/[ next above here, or nil.
-          dropped-cons            ; was the last removed element a brace pair?
-          pa)
-      ;; The easy bit - knock over-the-top bits off `c-state-cache'.
-      (while (and c-state-cache
-                  (>= (setq pa (c-state-cache-top-paren)) here))
-        (setq dropped-cons (consp (car c-state-cache))
-              too-high-pa (c-state-cache-top-lparen)
-              c-state-cache (cdr c-state-cache)))
-
-      ;; Do we need to add in an earlier brace pair, having lopped one off?
-      (if (and dropped-cons
-               (< too-high-pa (+ here c-state-cache-too-far)))
-          (c-append-lower-brace-pair-to-state-cache too-high-pa here-bol))
-      (setq c-state-cache-good-pos (or (c-state-cache-after-top-paren)
-                                       (c-state-get-min-scan-pos)))))
-
-  ;; The brace-pair desert marker:
-  (when (car c-state-brace-pair-desert)
-    (if (< here (car c-state-brace-pair-desert))
-        (setq c-state-brace-pair-desert nil)
-      (if (< here (cdr c-state-brace-pair-desert))
-          (setcdr c-state-brace-pair-desert here)))))
-
-(defun c-parse-state-1 ()
-  ;; Find and record all noteworthy parens between some good point earlier in
-  ;; the file and point.  That good point is at least the beginning of the
-  ;; top-level construct we are in, or the beginning of the preceding
-  ;; top-level construct if we aren't in one.
-  ;;
-  ;; The returned value is a list of the noteworthy parens with the last one
-  ;; first.  If an element in the list is an integer, it's the position of an
-  ;; open paren (of any type) which has not been closed before the point.  If
-  ;; an element is a cons, it gives the position of a closed BRACE paren
-  ;; pair[*]; the car is the start brace position and the cdr is the position
-  ;; following the closing brace.  Only the last closed brace paren pair
-  ;; before each open paren and before the point is recorded, and thus the
-  ;; state never contains two cons elements in succession.  When a close brace
-  ;; has no matching open brace (e.g., the matching brace is outside the
-  ;; visible region), it is not represented in the returned value.
-  ;;
-  ;; [*] N.B. The close "brace" might be a mismatching close bracket or paren.
-  ;; This defun explicitly treats mismatching parens/braces/brackets as
-  ;; matching.  It is the open brace which makes it a "brace" pair.
-  ;;
-  ;; If POINT is within a macro, open parens and brace pairs within
-  ;; THIS macro MIGHT be recorded.  This depends on whether their
-  ;; syntactic properties have been suppressed by
-  ;; `c-neutralize-syntax-in-CPP'.  This might need fixing (2008-12-11).
+(defun c-parse-state ()
+  ;; Find and record all noteworthy parens between some good point
+  ;; earlier in the file and point.  That good point is at least the
+  ;; beginning of the top-level construct we are in, or the beginning
+  ;; of the preceding top-level construct if we aren't in one.
+  ;;
+  ;; The returned value is a list of the noteworthy parens with the
+  ;; last one first.  If an element in the list is an integer, it's
+  ;; the position of an open paren which has not been closed before
+  ;; the point.  If an element is a cons, it gives the position of a
+  ;; closed brace paren pair; the car is the start paren position and
+  ;; the cdr is the position following the closing paren.  Only the
+  ;; last closed brace paren pair before each open paren and before
+  ;; the point is recorded, and thus the state never contains two cons
+  ;; elements in succession.
   ;;
   ;; Currently no characters which are given paren syntax with the
   ;; syntax-table property are recorded, i.e. angle bracket arglist
   ;; parens are never present here.  Note that this might change.
   ;;
   ;; BUG: This function doesn't cope entirely well with unbalanced
-  ;; parens in macros.  (2008-12-11: this has probably been resolved
-  ;; by the function `c-neutralize-syntax-in-CPP'.)  E.g. in the
-  ;; following case the brace before the macro isn't balanced with the
-  ;; one after it:
+  ;; parens in macros.  E.g. in the following case the brace before
+  ;; the macro isn't balanced with the one after it:
   ;;
   ;;     {
   ;;     #define X {
   ;;     }
   ;;
-  ;; Note to maintainers: this function DOES get called with point
-  ;; within comments and strings, so don't assume it doesn't!
-  ;;
   ;; This function might do hidden buffer changes.
-  (let* ((here (point))
-         (here-bopl (c-point 'bopl))
-         strategy            ; 'forward, 'backward etc..
-         ;; Candidate positions to start scanning from:
-         cache-pos           ; highest position below HERE already existing in
-                             ; cache (or 1).
-         good-pos
-         start-point
-         bopl-state
-         res
-         scan-backward-pos scan-forward-p) ; used for 'backward.
-    ;; If POINT-MIN has changed, adjust the cache
-    (unless (= (point-min) c-state-point-min)
-      (c-renarrow-state-cache))
-
-    ;; Strategy?
-    (setq res (c-parse-state-get-strategy here c-state-cache-good-pos)
-          strategy (car res)
-          cache-pos (cadr res)
-          start-point (nth 2 res))
-
-    (when (eq strategy 'BOD)
-      (setq c-state-cache nil
-            c-state-cache-good-pos start-point))
-
-    ;; SCAN!
-    (save-restriction
-      (cond
-       ((memq strategy '(forward BOD))
-        (narrow-to-region (point-min) here)
-        (setq res (c-remove-stale-state-cache start-point here-bopl))
-        (setq cache-pos (car res)
-              scan-backward-pos (cadr res)
-              bopl-state (car (cddr res))) ; will be nil if (< here-bopl
-                                        ; start-point)
-        (if scan-backward-pos
-            (c-append-lower-brace-pair-to-state-cache scan-backward-pos))
-        (setq good-pos
-              (c-append-to-state-cache cache-pos))
-        (setq c-state-cache-good-pos
-              (if (and bopl-state
-                       (< good-pos (- here c-state-cache-too-far)))
-                  (c-state-cache-non-literal-place here-bopl bopl-state)
-                good-pos)))
-
-       ((eq strategy 'backward)
-        (setq res (c-remove-stale-state-cache-backwards here cache-pos)
-              good-pos (car res)
-              scan-backward-pos (cadr res)
-              scan-forward-p (car (cddr res)))
-        (if scan-backward-pos
-            (c-append-lower-brace-pair-to-state-cache
-             scan-backward-pos))
-        (setq c-state-cache-good-pos
-              (if scan-forward-p
-                  (progn (narrow-to-region (point-min) here)
-                         (c-append-to-state-cache good-pos))
-
-                (c-get-cache-scan-pos good-pos))))
-
-       (t ; (eq strategy 'IN-LIT)
-        (setq c-state-cache nil
-              c-state-cache-good-pos nil)))))
-
-  c-state-cache)
-
-(defun c-invalidate-state-cache (here)
-  ;; This is a wrapper over `c-invalidate-state-cache-1'.
-  ;;
-  ;; It suppresses the syntactic effect of the < and > (template) brackets and
-  ;; of all parens in preprocessor constructs, except for any such construct
-  ;; containing point.  We can then call `c-invalidate-state-cache-1' without
-  ;; worrying further about macros and template delimiters.
-  (c-with-<->-as-parens-suppressed
-   (if (and c-state-old-cpp-beg
-            (< c-state-old-cpp-beg here))
-       (c-with-all-but-one-cpps-commented-out
-        c-state-old-cpp-beg
-        (min c-state-old-cpp-end here)
-        (c-invalidate-state-cache-1 here))
-     (c-with-cpps-commented-out
-      (c-invalidate-state-cache-1 here)))))
 
-(defun c-parse-state ()
-  ;; This is a wrapper over `c-parse-state-1'.  See that function for a
-  ;; description of the functionality and return value.
-  ;;
-  ;; It suppresses the syntactic effect of the < and > (template) brackets and
-  ;; of all parens in preprocessor constructs, except for any such construct
-  ;; containing point.  We can then call `c-parse-state-1' without worrying
-  ;; further about macros and template delimiters.
-  (let (here-cpp-beg here-cpp-end)
-    (save-excursion
-      (when (c-beginning-of-macro)
-        (setq here-cpp-beg (point))
-        (unless
-            (> (setq here-cpp-end (c-syntactic-end-of-macro))
-               here-cpp-beg)
-          (setq here-cpp-beg nil  here-cpp-end nil))))
-    ;; FIXME!!! Put in a `condition-case' here to protect the integrity of the
-    ;; subsystem.
-    (prog1
-        (c-with-<->-as-parens-suppressed
-         (if (and here-cpp-beg (> here-cpp-end here-cpp-beg))
-             (c-with-all-but-one-cpps-commented-out
-              here-cpp-beg here-cpp-end
-              (c-parse-state-1))
-           (c-with-cpps-commented-out
-            (c-parse-state-1))))
-      (setq c-state-old-cpp-beg (and here-cpp-beg (copy-marker here-cpp-beg t))
-            c-state-old-cpp-end (and here-cpp-end (copy-marker here-cpp-end t)))
-      )))
+  (save-restriction
+    (let* ((here (point))
+           (here-bol (c-point 'bol))
+           (c-macro-start (c-query-macro-start))
+           (in-macro-start (or c-macro-start (point)))
+           old-state last-pos brace-pair-open brace-pair-close
+           pos save-pos)
+      (c-invalidate-state-cache here)
+
+      ;; If the minimum position has changed due to narrowing then we
+      ;; have to fix the tail of `c-state-cache' accordingly.
+      (unless (= c-state-cache-start (point-min))
+        (if (> (point-min) c-state-cache-start)
+            ;; If point-min has moved forward then we just need to cut
+            ;; off a bit of the tail.
+            (let ((ptr (cons nil c-state-cache)) elem)
+              (while (and (setq elem (car-safe (cdr ptr)))
+                          (>= (if (consp elem) (car elem) elem)
+                              (point-min)))
+                (setq ptr (cdr ptr)))
+              (when (consp ptr)
+                (if (eq (cdr ptr) c-state-cache)
+                    (setq c-state-cache nil
+                          c-state-cache-good-pos 1)
+                  (setcdr ptr nil))))
+          ;; If point-min has moved backward then we drop the state
+          ;; completely.  It's possible to do a better job here and
+          ;; recalculate the top only.
+          (setq c-state-cache nil
+                c-state-cache-good-pos 1))
+        (setq c-state-cache-start (point-min)))
+
+      ;; Get the latest position we know are directly inside the
+      ;; closest containing paren of the cached state.
+      (setq last-pos (and c-state-cache
+                          (if (consp (car c-state-cache))
+                              (cdr (car c-state-cache))
+                            (1+ (car c-state-cache)))))
+      (if (or (not last-pos)
+              (< last-pos c-state-cache-good-pos))
+          (setq last-pos c-state-cache-good-pos)
+        ;; Take the opportunity to move the cached good position
+        ;; further down.
+        (if (< last-pos here-bol)
+            (setq c-state-cache-good-pos last-pos)))
 
-;; Debug tool to catch cache inconsistencies.  This is called from
-;; 000tests.el.
+      ;; Check if `last-pos' is in a macro.  If it is, and we're not
+      ;; in the same macro, we must discard everything on
+      ;; `c-state-cache' that is inside the macro before using it.
+      (save-excursion
+        (goto-char last-pos)
+        (when (and (c-beginning-of-macro)
+                   (/= (point) in-macro-start))
+          (c-invalidate-state-cache (point))
+          ;; Set `last-pos' again just like above except that there's
+          ;; no use looking at `c-state-cache-good-pos' here.
+          (setq last-pos (if c-state-cache
+                             (if (consp (car c-state-cache))
+                                 (cdr (car c-state-cache))
+                               (1+ (car c-state-cache)))
+                           1))))
+
+      ;; If we've moved very far from the last cached position then
+      ;; it's probably better to redo it from scratch, otherwise we
+      ;; might spend a lot of time searching from `last-pos' down to
+      ;; here.
+      (when (< last-pos (- here 20000))
+        ;; First get the fallback start position.  If it turns out
+        ;; that it's so far back that the cached state is closer then
+        ;; we'll keep it afterall.
+        (setq pos (c-get-fallback-start-pos here))
+        (if (<= pos last-pos)
+            (setq pos nil)
+          (setq last-pos nil
+                c-state-cache nil
+                c-state-cache-good-pos 1)))
+
+      ;; Find the start position for the forward search.  (Can't
+      ;; search in the backward direction since the point might be in
+      ;; some kind of literal.)
+
+      (unless pos
+        (setq old-state c-state-cache)
+
+        ;; There's a cached state with a containing paren.  Pop off
+        ;; the stale containing sexps from it by going forward out of
+        ;; parens as far as possible.
+        (narrow-to-region (point-min) here)
+        (let (placeholder pair-beg)
+          (while (and c-state-cache
+                      (setq placeholder
+                            (c-up-list-forward last-pos)))
+            (setq last-pos placeholder)
+            (if (consp (car c-state-cache))
+                (setq pair-beg (car-safe (cdr c-state-cache))
+                      c-state-cache (cdr-safe (cdr c-state-cache)))
+              (setq pair-beg (car c-state-cache)
+                    c-state-cache (cdr c-state-cache))))
+
+          (when (and pair-beg (eq (char-after pair-beg) ?{))
+            ;; The last paren pair we moved out from was a brace
+            ;; pair.  Modify the state to record this as a closed
+            ;; pair now.
+            (if (consp (car-safe c-state-cache))
+                (setq c-state-cache (cdr c-state-cache)))
+            (setq c-state-cache (cons (cons pair-beg last-pos)
+                                      c-state-cache))))
+
+        ;; Check if the preceding balanced paren is within a
+        ;; macro; it should be ignored if we're outside the
+        ;; macro.  There's no need to check any further upwards;
+        ;; if the macro contains an unbalanced opening paren then
+        ;; we're smoked anyway.
+        (when (and (<= (point) in-macro-start)
+                   (consp (car c-state-cache)))
+          (save-excursion
+            (goto-char (car (car c-state-cache)))
+            (when (c-beginning-of-macro)
+              (setq here (point)
+                    c-state-cache (cdr c-state-cache)))))
+
+        (unless (eq c-state-cache old-state)
+          ;; Have to adjust the cached good position if state has been
+          ;; popped off.
+          (setq c-state-cache-good-pos
+                (if c-state-cache
+                    (if (consp (car c-state-cache))
+                        (cdr (car c-state-cache))
+                      (1+ (car c-state-cache)))
+                  1)
+                old-state c-state-cache))
+
+        (when c-state-cache
+          (setq pos last-pos)))
+
+      ;; Get the fallback start position.
+      (unless pos
+        (setq pos (c-get-fallback-start-pos here)
+              c-state-cache nil
+              c-state-cache-good-pos 1))
+
+      (narrow-to-region (point-min) here)
+
+      (while pos
+        (setq save-pos pos
+              brace-pair-open nil)
+
+        ;; Find the balanced brace pairs.  This loop is hot, so it
+        ;; does ugly tricks to go faster.
+        (c-safe
+          (let (set-good-pos set-brace-pair)
+            (while t
+              (setq last-pos nil
+                    last-pos (scan-lists pos 1 -1)) ; Might signal.
+              (setq pos (scan-lists last-pos 1 1) ; Might signal.
+                    set-good-pos (< pos here-bol)
+                    set-brace-pair (eq (char-before last-pos) ?{))
+
+              ;; Update the cached good position and record the brace
+              ;; pair, whichever is applicable for the paren we've
+              ;; just jumped over.  But first check that it isn't
+              ;; inside a macro and the point isn't inside the same
+              ;; one.
+              (when (and (or set-good-pos set-brace-pair)
+                         (or (>= pos in-macro-start)
+                             (save-excursion
+                               (goto-char pos)
+                               (not (c-beginning-of-macro)))))
+                (if set-good-pos
+                    (setq c-state-cache-good-pos pos))
+                (if set-brace-pair
+                    (setq brace-pair-open last-pos
+                          brace-pair-close pos))))))
+
+        ;; Record the last brace pair.
+        (when brace-pair-open
+          (let ((head (car-safe c-state-cache)))
+            (if (consp head)
+                (progn
+                  (setcar head (1- brace-pair-open))
+                  (setcdr head brace-pair-close))
+              (setq c-state-cache (cons (cons (1- brace-pair-open)
+                                              brace-pair-close)
+                                        c-state-cache)))))
+
+        (if last-pos
+            ;; Prepare to loop, but record the open paren only if it's
+            ;; outside a macro or within the same macro as point, and
+            ;; if it is a legitimate open paren and not some character
+            ;; that got an open paren syntax-table property.
+            (progn
+              (setq pos last-pos)
+              (when (and (or (>= last-pos in-macro-start)
+                             (save-excursion
+                               (goto-char last-pos)
+                               (not (c-beginning-of-macro))))
+                         ;; Check for known types of parens that we
+                         ;; want to record.  The syntax table is not to
+                         ;; be trusted here since the caller might be
+                         ;; using e.g. `c++-template-syntax-table'.
+                         (memq (char-before last-pos) '(?{ ?\( ?\[)))
+                (if (< last-pos here-bol)
+                    (setq c-state-cache-good-pos last-pos))
+                (setq c-state-cache (cons (1- last-pos) c-state-cache))))
+
+          (if (setq last-pos (c-up-list-forward pos))
+              ;; Found a close paren without a corresponding opening
+              ;; one.  Maybe we didn't go back far enough, so try to
+              ;; scan backward for the start paren and then start over.
+              (progn
+                (setq pos (c-up-list-backward pos)
+                      c-state-cache nil
+                      c-state-cache-good-pos c-state-cache-start)
+                (when (or (not pos)
+                          ;; Emacs (up to at least 21.2) can get confused by
+                          ;; open parens in column zero inside comments: The
+                          ;; sexp functions can then misbehave and bring us
+                          ;; back to the same point again.  Check this so that
+                          ;; we don't get an infinite loop.
+                          (>= pos save-pos))
+                  (setq pos last-pos
+                        c-parsing-error
+                        (format "Unbalanced close paren at line %d"
+                                (1+ (count-lines (point-min)
+                                                 (c-point 'bol last-pos)))))))
+            (setq pos nil))))
+
+      ;;(message "c-parse-state: %S end: %S" c-state-cache c-state-cache-good-pos)
+      c-state-cache)))
+
+;; Debug tool to catch cache inconsistencies.
 (defvar c-debug-parse-state nil)
 (unless (fboundp 'c-real-parse-state)
   (fset 'c-real-parse-state (symbol-function 'c-parse-state)))
 (cc-bytecomp-defun c-real-parse-state)
 (defun c-debug-parse-state ()
-  (let ((here (point)) (res1 (c-real-parse-state)) res2)
+  (let ((res1 (c-real-parse-state)) res2)
     (let ((c-state-cache nil)
-          (c-state-cache-good-pos 1)
-          (c-state-nonlit-pos-cache nil)
-          (c-state-nonlit-pos-cache-limit 1)
-          (c-state-brace-pair-desert nil)
-          (c-state-point-min 1)
-          (c-state-point-min-lit-type nil)
-          (c-state-point-min-lit-start nil)
-          (c-state-min-scan-pos 1)
-          (c-state-old-cpp-beg nil)
-          (c-state-old-cpp-end nil))
+          (c-state-cache-start 1)
+          (c-state-cache-good-pos 1))
       (setq res2 (c-real-parse-state)))
     (unless (equal res1 res2)
       ;; The cache can actually go further back due to the ad-hoc way
@@ -3067,11 +2296,10 @@ comment at the start of cc-engine.el for more info."
         (while (not (or (bobp) (eq (char-after) ?{)))
           (c-beginning-of-defun-1))
         (unless (equal (c-whack-state-before (point) res1) res2)
-          (message (concat "c-parse-state inconsistency at %s: "
+          (message (concat "c-parse-state inconsistency: "
                            "using cache: %s, from scratch: %s")
-                   here res1 res2))))
+                   res1 res2))))
     res1))
-
 (defun c-toggle-parse-state-debug (&optional arg)
   (interactive "P")
   (setq c-debug-parse-state (c-calculate-state arg c-debug-parse-state))
@@ -3082,7 +2310,6 @@ comment at the start of cc-engine.el for more info."
 (when c-debug-parse-state
   (c-toggle-parse-state-debug 1))
 
-
 (defun c-whack-state-before (bufpos paren-state)
   ;; Whack off any state information from PAREN-STATE which lies
   ;; before BUFPOS.  Not destructive on PAREN-STATE.
@@ -4882,168 +4109,7 @@ comment at the start of cc-engine.el for more info."
         )))
 
 
-;; Setting and removing syntax properties on < and > in languages (C++
-;; and Java) where they can be template/generic delimiters as well as
-;; their normal meaning of "less/greater than".
-
-;; Normally, < and > have syntax 'punctuation'.  When they are found to
-;; be delimiters, they are marked as such with the category properties
-;; c-<-as-paren-syntax, c->-as-paren-syntax respectively.
-
-;; STRATEGY:
-;;
-;; It is impossible to determine with certainty whether a <..> pair in
-;; C++ is two comparison operators or is template delimiters, unless
-;; one duplicates a lot of a C++ compiler.  For example, the following
-;; code fragment:
-;;
-;;     foo (a < b, c > d) ;
-;;
-;; could be a function call with two integer parameters (each a
-;; relational expression), or it could be a constructor for class foo
-;; taking one parameter d of templated type "a < b, c >".  They are
-;; somewhat easier to distinguish in Java.
-;;
-;; The strategy now (2010-01) adopted is to mark and unmark < and
-;; > IN MATCHING PAIRS ONLY.  [Previously, they were marked
-;; individually when their context so indicated.  This gave rise to
-;; intractible problems when one of a matching pair was deleted, or
-;; pulled into a literal.]
-;;
-;; At each buffer change, the syntax-table properties are removed in a
-;; before-change function and reapplied, when needed, in an
-;; after-change function.  It is far more important that the
-;; properties get removed when they they are spurious than that they
-;; be present when wanted.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defun c-clear-<-pair-props (&optional pos)
-  ;; POS (default point) is at a < character.  If it is marked with
-  ;; open paren syntax-table text property, remove the property,
-  ;; together with the close paren property on the matching > (if
-  ;; any).
-  (save-excursion
-    (if pos
-        (goto-char pos)
-      (setq pos (point)))
-    (when (equal (c-get-char-property (point) 'syntax-table)
-                 c-<-as-paren-syntax)
-      (with-syntax-table c-no-parens-syntax-table ; ignore unbalanced [,{,(,..
-        (c-go-list-forward))
-      (when (equal (c-get-char-property (1- (point)) 'syntax-table)
-                   c->-as-paren-syntax) ; should always be true.
-        (c-clear-char-property (1- (point)) 'category))
-      (c-clear-char-property pos 'category))))
-
-(defun c-clear->-pair-props (&optional pos)
-  ;; POS (default point) is at a > character.  If it is marked with
-  ;; close paren syntax-table property, remove the property, together
-  ;; with the open paren property on the matching < (if any).
-  (save-excursion
-    (if pos
-        (goto-char pos)
-      (setq pos (point)))
-    (when (equal (c-get-char-property (point) 'syntax-table)
-                 c->-as-paren-syntax)
-      (with-syntax-table c-no-parens-syntax-table ; ignore unbalanced [,{,(,..
-        (c-go-up-list-backward))
-      (when (equal (c-get-char-property (point) 'syntax-table)
-                        c-<-as-paren-syntax) ; should always be true.
-        (c-clear-char-property (point) 'category))
-      (c-clear-char-property pos 'category))))
-
-(defun c-clear-<>-pair-props (&optional pos)
-  ;; POS (default point) is at a < or > character.  If it has an
-  ;; open/close paren syntax-table property, remove this property both
-  ;; from the current character and its partner (which will also be
-  ;; thusly marked).
-  (cond
-   ((eq (char-after) ?\<)
-    (c-clear-<-pair-props pos))
-   ((eq (char-after) ?\>)
-    (c-clear->-pair-props pos))
-   (t (c-benign-error
-       "c-clear-<>-pair-props called from wrong position"))))
-
-(defun c-clear-<-pair-props-if-match-after (lim &optional pos)
-  ;; POS (default point) is at a < character.  If it is both marked
-  ;; with open/close paren syntax-table property, and has a matching >
-  ;; (also marked) which is after LIM, remove the property both from
-  ;; the current > and its partner.
-  (save-excursion
-    (if pos
-        (goto-char pos)
-      (setq pos (point)))
-    (when (equal (c-get-char-property (point) 'syntax-table)
-                 c-<-as-paren-syntax)
-      (with-syntax-table c-no-parens-syntax-table ; ignore unbalanced [,{,(,..
-        (c-go-list-forward))
-      (when (and (>= (point) lim)
-                 (equal (c-get-char-property (1- (point)) 'syntax-table)
-                        c->-as-paren-syntax)) ; should always be true.
-        (c-unmark-<->-as-paren (1- (point)))
-        (c-unmark-<->-as-paren pos)))))
-
-(defun c-clear->-pair-props-if-match-before (lim &optional pos)
-  ;; POS (default point) is at a > character.  If it is both marked
-  ;; with open/close paren syntax-table property, and has a matching <
-  ;; (also marked) which is before LIM, remove the property both from
-  ;; the current < and its partner.
-  (save-excursion
-    (if pos
-        (goto-char pos)
-      (setq pos (point)))
-    (when (equal (c-get-char-property (point) 'syntax-table)
-                 c->-as-paren-syntax)
-      (with-syntax-table c-no-parens-syntax-table ; ignore unbalanced [,{,(,..
-        (c-go-up-list-backward))
-      (when (and (<= (point) lim)
-                 (equal (c-get-char-property (point) 'syntax-table)
-                        c-<-as-paren-syntax)) ; should always be true.
-        (c-unmark-<->-as-paren (point))
-        (c-unmark-<->-as-paren pos)))))
-
-(defun c-before-change-check-<>-operators (beg end)
-  ;; Unmark certain pairs of "< .... >" which are currently marked as
-  ;; template/generic delimiters.  (This marking is via syntax-table
-  ;; text properties).
-  ;;
-  ;; These pairs are those which are in the current "statement" (i.e.,
-  ;; the region between the {, }, or ; before BEG and the one after
-  ;; END), and which enclose any part of the interval (BEG END).
-  ;;
-  ;; Note that in C++ (?and Java), template/generic parens cannot
-  ;; enclose a brace or semicolon, so we use these as bounds on the
-  ;; region we must work on.
-  ;;
-  ;; This function is called from before-change-functions (via
-  ;; c-get-state-before-change-functions).  Thus the buffer is widened,
-  ;; and point is undefined, both at entry and exit.
-  ;;
-  ;; FIXME!!!  This routine ignores the possibility of macros entirely.
-  ;; 2010-01-29.
-  (save-excursion
-    (let ((beg-lit-limits (progn (goto-char beg) (c-literal-limits)))
-          (end-lit-limits (progn (goto-char end) (c-literal-limits))))
-      ;; Locate the barrier before the changed region
-      (goto-char  (if beg-lit-limits (car beg-lit-limits) beg))
-      (c-syntactic-skip-backward "^;{}" (max (- beg 2048) (point-min)))
-
-      ;; Remove the syntax-table properties from each pertinent <...> pair.
-      ;; Firsly, the ones with the < before beg and > after beg.
-      (while (c-search-forward-char-property 'category 'c-<-as-paren-syntax beg)
-        (c-clear-<-pair-props-if-match-after beg (1- (point))))
-
-      ;; Locate the barrier after END.
-      (goto-char (if end-lit-limits (cdr end-lit-limits) end))
-      (c-syntactic-re-search-forward "[;{}]"
-                                     (min (+ end 2048) (point-max)) 'end)
-
-      ;; Remove syntax-table properties from the remaining pertinent <...>
-      ;; pairs, those with a > after end and < before end.
-      (while (c-search-backward-char-property 'category 'c->-as-paren-syntax end)
-        (c-clear->-pair-props-if-match-before end)))))
-
-
+;; Handling of small scale constructs like types and names.
 
 (defun c-after-change-check-<>-operators (beg end)
   ;; This is called from `after-change-functions' when
@@ -5065,7 +4131,7 @@ comment at the start of cc-engine.el for more info."
                  (< beg (setq beg (match-end 0))))
         (while (progn (skip-chars-forward "^<>" beg)
                       (< (point) beg))
-          (c-clear-<>-pair-props)
+          (c-clear-char-property (point) 'syntax-table)
           (forward-char))))
 
     (when (< beg end)
@@ -5080,13 +4146,9 @@ comment at the start of cc-engine.el for more info."
                    (< end (setq end (match-end 0))))
           (while (progn (skip-chars-forward "^<>" end)
                         (< (point) end))
-            (c-clear-<>-pair-props)
+            (c-clear-char-property (point) 'syntax-table)
             (forward-char)))))))
 
-
-
-;; Handling of small scale constructs like types and names.
-
 ;; Dynamically bound variable that instructs `c-forward-type' to also
 ;; treat possible types (i.e. those that it normally returns 'maybe or
 ;; 'found for) as actual types (and always return 'found for them).
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 907c308daca..80783670f66 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -426,8 +426,7 @@ stuff.  Used on level 1 and higher."
                                    (progn
                                      (c-mark-<-as-paren beg)
                                      (c-mark->-as-paren end))
-                                 ;; (c-clear-char-property beg 'syntax-table)
-                                 (c-clear-char-property beg 'category)))
+                                 (c-clear-char-property beg 'syntax-table)))
                              nil)))))))
 
               ;; #define.
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index d3669f259de..ac6ff40b4c0 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -391,27 +391,6 @@ The syntax tables aren't stored directly since they're quite large."
   (and (c-lang-const c++-make-template-syntax-table)
        (funcall (c-lang-const c++-make-template-syntax-table))))
 
-(c-lang-defconst c-no-parens-syntax-table
-  ;; A variant of the standard syntax table which is used to find matching
-  ;; "<"s and ">"s which have been marked as parens using syntax table
-  ;; properties.  The other paren characters (e.g. "{", ")" "]") are given a
-  ;; non-paren syntax here. so that the list commands will work on "< ... >"
-  ;; even when there's unbalanced other parens inside them.
-  ;;
-  ;; This variable is nil for languages which don't have template stuff.
-  t  `(lambda ()
-        (if (c-lang-const c-recognize-<>-arglists)
-            (let ((table (funcall ,(c-lang-const c-make-mode-syntax-table))))
-              (modify-syntax-entry ?\( "." table)
-              (modify-syntax-entry ?\) "." table)
-              (modify-syntax-entry ?\[ "." table)
-              (modify-syntax-entry ?\] "." table)
-              (modify-syntax-entry ?\{ "." table)
-              (modify-syntax-entry ?\} "." table)
-              table))))
-(c-lang-defvar c-no-parens-syntax-table
-               (funcall (c-lang-const c-no-parens-syntax-table)))
-
 (c-lang-defconst c-identifier-syntax-modifications
   "A list that describes the modifications that should be done to the
 mode syntax table to get a syntax table that matches all identifiers
@@ -444,36 +423,26 @@ the new syntax, as accepted by `modify-syntax-entry'."
 classifies symbol constituents like '_' and '$' as word constituents,
 so that all identifiers are recognized as words.")
 
-(c-lang-defconst c-get-state-before-change-functions
-  ;; For documentation see the following c-lang-defvar of the same name.
-  ;; The value here may be a list of functions or a single function.
-  t nil
-  c++ '(c-extend-region-for-CPP c-before-change-check-<>-operators)
-  (c objc) 'c-extend-region-for-CPP
-  ;; java '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)))
-                  (if (listp fs)
-                      fs
-                    (list fs)))
-  "If non-nil, a list of functions called from c-before-change-hook.
-Typically these will record enough state to allow
+(c-lang-defconst c-get-state-before-change-function
+  "If non-nil, a function called from c-before-change-hook.
+Typically it will record enough state to allow
 `c-before-font-lock-function' to extend the region to fontify,
 and may do such things as removing text-properties which must be
 recalculated.
 
-These functions will be run in the order given.  Each of them
-takes 2 parameters, the BEG and END supplied to every
+It takes 2 parameters, the BEG and END supplied to every
 before-change function; on entry, the buffer will have been
 widened and match-data will have been saved; point is undefined
 on both entry and exit; the return value is ignored.
 
-The functions are called even when font locking isn't enabled.
-
-When the mode is initialized, the functions are called with
-parameters \(point-min) and \(point-max).")
-
+When the mode is initialized, this function is called with
+parameters \(point-min) and \(point-max)."
+  t nil
+  (c c++ objc) 'c-extend-region-for-CPP
+  awk 'c-awk-record-region-clear-NL)
+(c-lang-defvar c-get-state-before-change-function
+               (c-lang-const c-get-state-before-change-function))
+  
 (c-lang-defconst c-before-font-lock-function
   "If non-nil, a function called just before font locking.
 Typically it will extend the region about to be fontified \(see
@@ -492,7 +461,7 @@ The function is called even when font locking is disabled.
 When the mode is initialized, this function is called with
 parameters \(point-min), \(point-max) and <buffer size>."
   t nil
-  (c c++ objc) 'c-neutralize-syntax-in-and-mark-CPP
+  (c c++ objc) 'c-extend-and-neutralize-syntax-in-CPP
   awk 'c-awk-extend-and-syntax-tablify-region)
 (c-lang-defvar c-before-font-lock-function
                (c-lang-const c-before-font-lock-function))
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 7f9ed6436f4..2bfa2b7df9b 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -410,7 +410,7 @@ preferably use the `c-mode-menu' language constant directly."
 ;; temporary changes in some font lock support modes, causing extra
 ;; unnecessary work and font lock glitches due to interactions between
 ;; various text properties.
-;;
+;; 
 ;; (2007-02-12): The macro `combine-after-change-calls' ISN'T used any
 ;; more.
 
@@ -451,18 +451,18 @@ preferably use the `c-mode-menu' language constant directly."
                               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
+;; changed where an element of `found-types' might become stale.  It 
 ;; is set in c-before-change and is either nil, or has the form:
 ;;
 ;;   (c-decl-id-start "foo" 97 107  " (* ooka) " "o"), where
-;;
+;;   
 ;; o - `c-decl-id-start' is the c-type text property value at buffer
 ;;   pos 96.
-;;
+;; 
 ;; o - 97 107 is the region potentially containing the stale type -
 ;;   this is delimited by a non-nil c-type text property at 96 and
 ;;   either another one or a ";", "{", or "}" at 107.
-;;
+;; 
 ;; o - " (* ooka) " is the (before change) buffer portion containing
 ;;   the suspect type (here "ooka").
 ;;
@@ -517,9 +517,6 @@ that requires a literal mode spec at compile time."
   (make-local-variable 'fill-paragraph-function)
   (setq fill-paragraph-function 'c-fill-paragraph)
 
-  ;; Initialise the cache of brace pairs, and opening braces/brackets/parens.
-  (c-state-cache-init)
-
   (when (or c-recognize-<>-arglists
             (c-major-mode-is 'awk-mode)
             (c-major-mode-is '(c-mode c++-mode objc-mode)))
@@ -641,10 +638,8 @@ compatible with old code; callers should always specify it."
   (save-restriction
     (widen)
     (save-excursion
-      (if c-get-state-before-change-functions
-          (mapc (lambda (fn)
-                  (funcall fn (point-min) (point-max)))
-                c-get-state-before-change-functions))
+      (if c-get-state-before-change-function
+          (funcall c-get-state-before-change-function (point-min) (point-max)))
       (if c-before-font-lock-function
           (funcall c-before-font-lock-function (point-min) (point-max)
                    (- (point-max) (point-min))))))
@@ -777,7 +772,7 @@ Note that the style variables are always made local to the buffer."
 
 (defmacro c-run-mode-hooks (&rest hooks)
   ;; Emacs 21.1 has introduced a system with delayed mode hooks that
-  ;; requires the use of the new function `run-mode-hooks'.
+  ;; require the use of the new function `run-mode-hooks'.
   (if (cc-bytecomp-fboundp 'run-mode-hooks)
       `(run-mode-hooks ,@hooks)
     `(progn ,@(mapcar (lambda (hook) `(run-hooks ,hook)) hooks))))
@@ -810,8 +805,8 @@ Note that the style variables are always made local to the buffer."
   ;; has already been widened, and match-data saved.  The return value is
   ;; meaningless.
   ;;
-  ;; This function is in the C/C++/ObjC values of
-  ;; `c-get-state-before-change-functions' and is called exclusively as a
+  ;; This function is the C/C++/ObjC value of
+  ;; `c-get-state-before-change-function' and is called exclusively as a
   ;; before change function.
   (goto-char beg)
   (c-beginning-of-macro)
@@ -848,7 +843,7 @@ Note that the style variables are always made local to the buffer."
               t)
              (t nil)))))))
 
-(defun c-neutralize-syntax-in-and-mark-CPP (begg endd old-len)
+(defun c-extend-and-neutralize-syntax-in-CPP (begg endd old-len)
   ;; (i) Extend the font lock region to cover all changed preprocessor
   ;; regions; it does this by setting the variables `c-new-BEG' and
   ;; `c-new-END' to the new boundaries.
@@ -857,15 +852,10 @@ Note that the style variables are always made local to the buffer."
   ;; extended changed region.  "Restore" lines which were CPP lines before the
   ;; change and are no longer so; these can be located from the Buffer local
   ;; variables `c-old-BOM' and `c-old-EOM'.
-  ;;
-  ;; (iii) Mark every CPP construct by placing a `category' property value
-  ;; `c-cpp-delimiter' at its start and end.  The marked characters are the
-  ;; opening # and usually the terminating EOL, but sometimes the character
-  ;; before a comment/string delimiter.
-  ;;
+  ;; 
   ;; That is, set syntax-table properties on characters that would otherwise
   ;; interact syntactically with those outside the CPP line(s).
-  ;;
+  ;; 
   ;; This function is called from an after-change function, BEGG ENDD and
   ;; OLD-LEN being the standard parameters.  It prepares the buffer for font
   ;; locking, hence must get called before `font-lock-after-change-function'.
@@ -876,34 +866,32 @@ Note that the style variables are always made local to the buffer."
   ;; This function is the C/C++/ObjC value of `c-before-font-lock-function'.
   ;;
   ;; Note: SPEED _MATTERS_ IN THIS FUNCTION!!!
-  ;;
+  ;; 
   ;; This function might make hidden buffer changes.
-  (c-save-buffer-state (limits)
+  (c-save-buffer-state (limits mbeg+1)
     ;; First determine the region, (c-new-BEG c-new-END), which will get font
     ;; locked.  It might need "neutralizing".  This region may not start
     ;; inside a string, comment, or macro.
     (goto-char c-old-BOM)         ; already set to old start of macro or begg.
     (setq c-new-BEG
-          (if (setq limits (c-state-literal-at (point)))
+          (if (setq limits (c-literal-limits))
               (cdr limits)          ; go forward out of any string or comment.
             (point)))
 
     (goto-char endd)
-    (if (setq limits (c-state-literal-at (point)))
+    (if (setq limits (c-literal-limits))
         (goto-char (car limits)))  ; go backward out of any string or comment.
     (if (c-beginning-of-macro)
         (c-end-of-macro))
     (setq c-new-END (max (+ (- c-old-EOM old-len) (- endd begg))
                    (point)))
 
-    ;; Clear all old relevant properties.
+    ;; Clear any existing punctuation properties.
     (c-clear-char-property-with-value c-new-BEG c-new-END 'syntax-table '(1))
-    (c-clear-char-property-with-value c-new-BEG c-new-END 'category 'c-cpp-delimiter)
-    ;; FIXME!!!  What about the "<" and ">" category properties?  2009-11-16
 
     ;; Add needed properties to each CPP construct in the region.
     (goto-char c-new-BEG)
-    (let ((pps-position c-new-BEG)  pps-state mbeg)
+    (let ((pps-position c-new-BEG)  pps-state)
       (while (and (< (point) c-new-END)
                   (search-forward-regexp c-anchored-cpp-prefix c-new-END t))
         ;; If we've found a "#" inside a string/comment, ignore it.
@@ -912,24 +900,18 @@ Note that the style variables are always made local to the buffer."
               pps-position (point))
         (unless (or (nth 3 pps-state)   ; in a string?
                     (nth 4 pps-state))  ; in a comment?
-          (goto-char (match-beginning 0))
-          (setq mbeg (point))
-          (if (> (c-syntactic-end-of-macro) mbeg)
-              (progn
-                (c-neutralize-CPP-line mbeg (point))
-                (c-set-cpp-delimiters mbeg (point))
-                ;(setq pps-position (point))
-                )
-            (forward-line))           ; no infinite loop with, e.g., "#//"
-          )))))
+          (setq mbeg+1 (point))
+          (c-end-of-macro)        ; Do we need to go forward 1 char here?  No!
+          (c-neutralize-CPP-line mbeg+1 (point))
+          (setq pps-position (point))))))) ; no need to update pps-state.
 
 (defun c-before-change (beg end)
-  ;; Function to be put on `before-change-functions'.  Primarily, this calls
-  ;; the language dependent `c-get-state-before-change-functions'.  It is
+  ;; Function to be put on `before-change-function'.  Primarily, this calls
+  ;; the language dependent `c-get-state-before-change-function'.  It is
   ;; otherwise used only to remove stale entries from the `c-found-types'
   ;; cache, and to record entries which a `c-after-change' function might
   ;; confirm as stale.
-  ;;
+  ;; 
   ;; Note that this function must be FAST rather than accurate.  Note
   ;; also that it only has any effect when font locking is enabled.
   ;; We exploit this by checking for font-lock-*-face instead of doing
@@ -1003,10 +985,8 @@ Note that the style variables are always made local to the buffer."
         ;; larger than (beg end).
         (setq c-new-BEG beg
               c-new-END end)
-        (if c-get-state-before-change-functions
-            (mapc (lambda (fn)
-                    (funcall fn beg end))
-                  c-get-state-before-change-functions))
+        (if c-get-state-before-change-function
+            (funcall c-get-state-before-change-function beg end))
         ))))
 
 (defun c-after-change (beg end old-len)
@@ -1040,14 +1020,6 @@ Note that the style variables are always made local to the buffer."
           (when (> beg end)
             (setq beg end)))
 
-        ;; C-y is capable of spuriously converting category properties
-        ;; c-</>-as-paren-syntax into hard syntax-table properties.  Remove
-        ;; these when it happens.
-        (c-clear-char-property-with-value beg end 'syntax-table
-                                          c-<-as-paren-syntax)
-        (c-clear-char-property-with-value beg end 'syntax-table
-                                          c->-as-paren-syntax)
-
         (c-trim-found-types beg end old-len) ; maybe we don't need all of these.
         (c-invalidate-sws-region-after beg end)
         (c-invalidate-state-cache beg)