Finish fixing a cacheing bug in CC Mode (see 2016-03-09)

* lisp/progmodes/cc-cmds.el: (c-beginning-of-defun, c-end-of-defun): Remove
superfluous invocations of c-self-bind-state-cache.

* lisp/progmodes/cc-defs.el: (c-self-bind-state-cache): Copy and terminate
markers correctly.

* lisp/progmodes/cc-engine.el (c-record-parse-state-state): Terminate stale
markers.

diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 764f44a8dd819fcc322cbae62e3c0f35b50dc568..59f2729c43d4ca51183563ecb2bb98779897d89d 100644 (file)
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1594,70 +1594,69 @@ defun."
       (c-region-is-active-p)
       (push-mark))
 
-  (c-self-bind-state-cache ; We must not share with other users of c-state-cache.
-   (c-save-buffer-state
-       (beginning-of-defun-function
-       end-of-defun-function
-       (start (point))
-       (paren-state (c-parse-state))
-       (orig-point-min (point-min)) (orig-point-max (point-max))
-       lim                 ; Position of { which has been widened to.
-       where pos case-fold-search)
-
-     (save-restriction
-       (if (eq c-defun-tactic 'go-outward)
-          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
-                     paren-state orig-point-min orig-point-max)))
-
-       ;; Move back out of any macro/comment/string we happen to be in.
-       (c-beginning-of-macro)
-       (setq pos (c-literal-limits))
-       (if pos (goto-char (car pos)))
-
-       (setq where (c-where-wrt-brace-construct))
-
-       (if (< arg 0)
-          ;; Move forward to the closing brace of a function.
-          (progn
-            (if (memq where '(at-function-end outwith-function))
-                (setq arg (1+ arg)))
-            (if (< arg 0)
-                (c-while-widening-to-decl-block
-                 (< (setq arg (- (c-forward-to-nth-EOF-} (- arg) where))) 0)))
-            ;; Move forward to the next opening brace....
-            (when (and (= arg 0)
-                       (progn
-                         (c-while-widening-to-decl-block
-                          (not (c-syntactic-re-search-forward "{" nil 'eob)))
-                         (eq (char-before) ?{)))
-              (backward-char)
-              ;; ... and backward to the function header.
-              (c-beginning-of-decl-1)
-              t))
-
-        ;; Move backward to the opening brace of a function, making successively
-        ;; larger portions of the buffer visible as necessary.
-        (when (> arg 0)
-          (c-while-widening-to-decl-block
-           (> (setq arg (c-backward-to-nth-BOF-{ arg where)) 0)))
-
-        (when (eq arg 0)
-          ;; Go backward to this function's header.
-          (c-beginning-of-decl-1)
-
-          (setq pos (point))
-          ;; We're now there, modulo comments and whitespace.
-          ;; Try to be line oriented; position point at the closest
-          ;; preceding boi that isn't inside a comment, but if we hit
-          ;; the previous declaration then we use the current point
-          ;; instead.
-          (while (and (/= (point) (c-point 'boi))
-                      (c-backward-single-comment)))
-          (if (/= (point) (c-point 'boi))
-              (goto-char pos)))
-
-        (c-keep-region-active)
-        (= arg 0))))))
+  (c-save-buffer-state
+      (beginning-of-defun-function
+       end-of-defun-function
+       (start (point))
+       (paren-state (c-parse-state))
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim                 ; Position of { which has been widened to.
+       where pos case-fold-search)
+
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+         (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
+                    paren-state orig-point-min orig-point-max)))
+
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
+
+      (setq where (c-where-wrt-brace-construct))
+
+      (if (< arg 0)
+         ;; Move forward to the closing brace of a function.
+         (progn
+           (if (memq where '(at-function-end outwith-function))
+               (setq arg (1+ arg)))
+           (if (< arg 0)
+               (c-while-widening-to-decl-block
+                (< (setq arg (- (c-forward-to-nth-EOF-} (- arg) where))) 0)))
+           ;; Move forward to the next opening brace....
+           (when (and (= arg 0)
+                      (progn
+                        (c-while-widening-to-decl-block
+                         (not (c-syntactic-re-search-forward "{" nil 'eob)))
+                        (eq (char-before) ?{)))
+             (backward-char)
+             ;; ... and backward to the function header.
+             (c-beginning-of-decl-1)
+             t))
+
+       ;; Move backward to the opening brace of a function, making successively
+       ;; larger portions of the buffer visible as necessary.
+       (when (> arg 0)
+         (c-while-widening-to-decl-block
+          (> (setq arg (c-backward-to-nth-BOF-{ arg where)) 0)))
+
+       (when (eq arg 0)
+         ;; Go backward to this function's header.
+         (c-beginning-of-decl-1)
+
+         (setq pos (point))
+         ;; We're now there, modulo comments and whitespace.
+         ;; Try to be line oriented; position point at the closest
+         ;; preceding boi that isn't inside a comment, but if we hit
+         ;; the previous declaration then we use the current point
+         ;; instead.
+         (while (and (/= (point) (c-point 'boi))
+                     (c-backward-single-comment)))
+         (if (/= (point) (c-point 'boi))
+             (goto-char pos)))
+
+       (c-keep-region-active)
+       (= arg 0)))))
 
 (defun c-forward-to-nth-EOF-} (n where)
   ;; Skip to the closing brace of the Nth function after point.  If
@@ -1719,68 +1718,66 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
       (c-region-is-active-p)
       (push-mark))
 
-  (c-self-bind-state-cache ; c-state-cache's list structure must not be shared
-                          ; with other users.
-   (c-save-buffer-state
-       (beginning-of-defun-function
-       end-of-defun-function
-       (start (point))
-       (paren-state (c-parse-state))
-       (orig-point-min (point-min)) (orig-point-max (point-max))
-       lim
-       where pos case-fold-search)
-
-     (save-restriction
-       (if (eq c-defun-tactic 'go-outward)
-          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
-                     paren-state orig-point-min orig-point-max)))
-
-       ;; Move back out of any macro/comment/string we happen to be in.
-       (c-beginning-of-macro)
-       (setq pos (c-literal-limits))
-       (if pos (goto-char (car pos)))
-
-       (setq where (c-where-wrt-brace-construct))
-
-       (if (< arg 0)
-          ;; Move backwards to the } of a function
-          (progn
-            (if (memq where '(at-header outwith-function))
-                (setq arg (1+ arg)))
-            (if (< arg 0)
-                (c-while-widening-to-decl-block
-                 (< (setq arg (- (c-backward-to-nth-BOF-{ (- arg) where))) 0)))
-            (if (= arg 0)
-                (c-while-widening-to-decl-block
-                 (progn (c-syntactic-skip-backward "^}")
-                        (not (eq (char-before) ?}))))))
-
-        ;; Move forward to the } of a function
-        (if (> arg 0)
-            (c-while-widening-to-decl-block
-             (> (setq arg (c-forward-to-nth-EOF-} arg where)) 0))))
-
-       ;; Do we need to move forward from the brace to the semicolon?
-       (when (eq arg 0)
-        (if (c-in-function-trailer-p)  ; after "}" of struct/enum, etc.
-            (c-syntactic-re-search-forward ";"))
+  (c-save-buffer-state
+      (beginning-of-defun-function
+       end-of-defun-function
+       (start (point))
+       (paren-state (c-parse-state))
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim
+       where pos case-fold-search)
 
-        (setq pos (point))
-        ;; We're there now, modulo comments and whitespace.
-        ;; Try to be line oriented; position point after the next
-        ;; newline that isn't inside a comment, but if we hit the
-        ;; next declaration then we use the current point instead.
-        (while (and (not (bolp))
-                    (not (looking-at "\\s *$"))
-                    (c-forward-single-comment)))
-        (cond ((bolp))
-              ((looking-at "\\s *$")
-               (forward-line 1))
-              (t
-               (goto-char pos))))
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+         (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
+                    paren-state orig-point-min orig-point-max)))
 
-       (c-keep-region-active)
-       (= arg 0)))))
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
+
+      (setq where (c-where-wrt-brace-construct))
+
+      (if (< arg 0)
+         ;; Move backwards to the } of a function
+         (progn
+           (if (memq where '(at-header outwith-function))
+               (setq arg (1+ arg)))
+           (if (< arg 0)
+               (c-while-widening-to-decl-block
+                (< (setq arg (- (c-backward-to-nth-BOF-{ (- arg) where))) 0)))
+           (if (= arg 0)
+               (c-while-widening-to-decl-block
+                (progn (c-syntactic-skip-backward "^}")
+                       (not (eq (char-before) ?}))))))
+
+       ;; Move forward to the } of a function
+       (if (> arg 0)
+           (c-while-widening-to-decl-block
+            (> (setq arg (c-forward-to-nth-EOF-} arg where)) 0))))
+
+      ;; Do we need to move forward from the brace to the semicolon?
+      (when (eq arg 0)
+       (if (c-in-function-trailer-p)   ; after "}" of struct/enum, etc.
+           (c-syntactic-re-search-forward ";"))
+
+       (setq pos (point))
+       ;; We're there now, modulo comments and whitespace.
+       ;; Try to be line oriented; position point after the next
+       ;; newline that isn't inside a comment, but if we hit the
+       ;; next declaration then we use the current point instead.
+       (while (and (not (bolp))
+                   (not (looking-at "\\s *$"))
+                   (c-forward-single-comment)))
+       (cond ((bolp))
+             ((looking-at "\\s *$")
+              (forward-line 1))
+             (t
+              (goto-char pos))))
+
+      (c-keep-region-active)
+      (= arg 0))))
 
 (defun c-defun-name ()
   "Return the name of the current defun, or NIL if there isn't one.

diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index f458904c87af68a115b3934ee74ccbeae6f463f1..4c78bc3975c397c8bcb013537741cf7d5e64243e 100644 (file)
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -1400,25 +1400,41 @@ been put there by c-put-char-property.  POINT remains unchanged."
         (c-set-cpp-delimiters ,beg ,end)))))
 
 (defmacro c-self-bind-state-cache (&rest forms)
-  ;; Bind the state cache to itself and execute the FORMS.  It is assumed that no
-  ;; buffer changes will happen in FORMS, and no hidden buffer changes which could
-  ;; affect the parsing will be made by FORMS.
-  `(let ((c-state-cache (copy-tree c-state-cache))
-        (c-state-cache-good-pos c-state-cache-good-pos)
-        ;(c-state-nonlit-pos-cache (copy-tree c-state-nonlit-pos-cache))
-        ;(c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache-limit)
-        ;(c-state-semi-nonlit-pos-cache (copy-tree c-state-semi-nonlit-pos-cache))
-        ;(c-state-semi-nonlit-pos-cache-limit c-state-semi-nonlit-pos-cache)
-        (c-state-brace-pair-desert (copy-tree c-state-brace-pair-desert))
-        (c-state-point-min c-state-point-min)
-        (c-state-point-min-lit-type c-state-point-min-lit-type)
-        (c-state-point-min-lit-start c-state-point-min-lit-start)
-        (c-state-min-scan-pos c-state-min-scan-pos)
-        (c-state-old-cpp-beg c-state-old-cpp-beg)
-        (c-state-old-cpp-end c-state-old-cpp-end))
-     ,@forms))
+  ;; Bind the state cache to itself and execute the FORMS.  Return the result
+  ;; of the last FORM executed.  It is assumed that no buffer changes will
+  ;; happen in FORMS, and no hidden buffer changes which could affect the
+  ;; parsing will be made by FORMS.
+  `(let* ((c-state-cache (copy-tree c-state-cache))
+         (c-state-cache-good-pos c-state-cache-good-pos)
+         ;(c-state-nonlit-pos-cache (copy-tree c-state-nonlit-pos-cache))
+          ;(c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache-limit)
+          ;(c-state-semi-nonlit-pos-cache (copy-tree c-state-semi-nonlit-pos-cache))
+          ;(c-state-semi-nonlit-pos-cache-limit c-state-semi-nonlit-pos-cache)
+         (c-state-brace-pair-desert (copy-tree c-state-brace-pair-desert))
+         (c-state-point-min c-state-point-min)
+         (c-state-point-min-lit-type c-state-point-min-lit-type)
+         (c-state-point-min-lit-start c-state-point-min-lit-start)
+         (c-state-min-scan-pos c-state-min-scan-pos)
+         (c-state-old-cpp-beg-marker (if (markerp c-state-old-cpp-beg-marker)
+                                         (copy-marker c-state-old-cpp-beg-marker)
+                                       c-state-old-cpp-beg-marker))
+         (c-state-old-cpp-beg (if (markerp c-state-old-cpp-beg)
+                                  c-state-old-cpp-beg-marker
+                                c-state-old-cpp-beg))
+         (c-state-old-cpp-end-marker (if (markerp c-state-old-cpp-end-marker)
+                                         (copy-marker c-state-old-cpp-end-marker)
+                                       c-state-old-cpp-end-marker))
+         (c-state-old-cpp-end (if (markerp c-state-old-cpp-end)
+                                  c-state-old-cpp-end-marker
+                                c-state-old-cpp-end))
+         (c-parse-state-state c-parse-state-state))
+     (prog1
+        (progn ,@forms)
+       (if (markerp c-state-old-cpp-beg-marker)
+          (move-marker c-state-old-cpp-beg-marker nil))
+       (if (markerp c-state-old-cpp-end-marker)
+          (move-marker c-state-old-cpp-end-marker nil)))))
 
-\f
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; The following macros are to be used only in `c-parse-state' and its
 ;; subroutines.  Their main purpose is to simplify the handling of C++/Java

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index afe87c5ee6a9dd560b86b0d7604a180f278bb7a0..aac7e631087ca6cd63e368ffcb124f11b55b9e73 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -3472,6 +3472,9 @@ comment at the start of cc-engine.el for more info."
 (make-variable-buffer-local 'c-parse-state-state)
 (defun c-record-parse-state-state ()
   (setq c-parse-state-point (point))
+  (when (markerp (cdr (assq 'c-state-old-cpp-beg c-parse-state-state)))
+    (move-marker (cdr (assq 'c-state-old-cpp-beg c-parse-state-state)) nil)
+    (move-marker (cdr (assq 'c-state-old-cpp-end c-parse-state-state)) nil))
   (setq c-parse-state-state
        (mapcar
         (lambda (arg)