Commit 6b538879 authored by Alan Mackenzie's avatar Alan Mackenzie

Depessimize bits of CC Mode for long C macros.

* lisp/progmodes/cc-engine.el (c-end-of-macro): Check for being in a
degenerate zero length "macro", when setting the macro cache.
(c-determine-+ve-limit): Add in a missing goto-char form for when start-pos is
non-nil.
(c-back-over-member-initializers): Add a search limit parameter.

* lisp/progmodes/cc-fonts.el (c-get-fontification-context): Add a search limit
to c-go-up-list-backward.
(c-font-lock-cut-off-declarators): Add a search limit to
c-back-over-member-initializers.

* lisp/progmodes/cc-mode.el (c-before-change-check-unbalanced-strings): Don't
set c-new-END to the end of logical line (which might be a long macro).
(c-after-change-mark-abnormal-strings): Calculate end-hwm in place of the
setting of c-new-END (above).  Use this as a search limit rather than
c-new-END.
parent 38d8db1b
Pipeline #2037 failed with stage
in 90 minutes and 1 second
......@@ -380,6 +380,8 @@ comment at the start of cc-engine.el for more info."
nil)))
(when (and (car c-macro-cache)
(> (point) (car c-macro-cache)) ; in case we have a
; zero-sized region.
(bolp)
(not (eq (char-before (1- (point))) ?\\)))
(setcdr c-macro-cache (point))
......@@ -5646,6 +5648,7 @@ comment at the start of cc-engine.el for more info."
(let ((pos (or start-pos (point)))
(count how-far)
(s (parse-partial-sexp (point) (point)))) ; null state
(goto-char pos)
(while (and (not (eobp))
(> count 0))
;; Scan over counted characters.
......@@ -8609,53 +8612,56 @@ comment at the start of cc-engine.el for more info."
(throw 'level nil))
(c-backward-syntactic-ws)))
(defun c-back-over-member-initializers ()
(defun c-back-over-member-initializers (&optional limit)
;; Test whether we are in a C++ member initializer list, and if so, go back
;; to the introducing ":", returning the position of the opening paren of
;; the function's arglist. Otherwise return nil, leaving point unchanged.
(let ((here (point))
(paren-state (c-parse-state))
pos level-plausible at-top-level res)
;; Assume tentatively that we're at the top level. Try to go back to the
;; colon we seek.
(setq res
(catch 'done
(setq level-plausible
(catch 'level
(c-backward-syntactic-ws)
(when (memq (char-before) '(?\) ?}))
(when (not (c-go-list-backward))
(throw 'done nil))
(c-backward-syntactic-ws))
(when (c-back-over-compound-identifier)
(c-backward-syntactic-ws))
(c-back-over-list-of-member-inits)
(and (eq (char-before) ?:)
(save-excursion
(c-backward-token-2)
(not (looking-at c-:$-multichar-token-regexp)))
(c-just-after-func-arglist-p))))
(while (and (not (and level-plausible
(setq at-top-level (c-at-toplevel-p))))
(setq pos (c-pull-open-brace paren-state))) ; might be a paren.
;; LIMIT, if non-nil, is a limit for the backward search.
(save-restriction
(if limit (narrow-to-region limit (point)))
(let ((here (point))
(paren-state (c-parse-state))
pos level-plausible at-top-level res)
;; Assume tentatively that we're at the top level. Try to go back to the
;; colon we seek.
(setq res
(catch 'done
(setq level-plausible
(catch 'level
(goto-char pos)
(c-backward-syntactic-ws)
(when (not (c-back-over-compound-identifier))
(throw 'level nil))
(c-backward-syntactic-ws)
(when (memq (char-before) '(?\) ?}))
(when (not (c-go-list-backward))
(throw 'done nil))
(c-backward-syntactic-ws))
(when (c-back-over-compound-identifier)
(c-backward-syntactic-ws))
(c-back-over-list-of-member-inits)
(and (eq (char-before) ?:)
(save-excursion
(c-backward-token-2)
(not (looking-at c-:$-multichar-token-regexp)))
(c-just-after-func-arglist-p)))))
(c-just-after-func-arglist-p))))
(while (and (not (and level-plausible
(setq at-top-level (c-at-toplevel-p))))
(setq pos (c-pull-open-brace paren-state))) ; might be a paren.
(setq level-plausible
(catch 'level
(goto-char pos)
(c-backward-syntactic-ws)
(when (not (c-back-over-compound-identifier))
(throw 'level nil))
(c-backward-syntactic-ws)
(c-back-over-list-of-member-inits)
(and (eq (char-before) ?:)
(save-excursion
(c-backward-token-2)
(not (looking-at c-:$-multichar-token-regexp)))
(c-just-after-func-arglist-p)))))
(and at-top-level level-plausible)))
(or res (goto-char here))
res))
(and at-top-level level-plausible)))
(or res (goto-char here))
res)))
(defun c-forward-class-decl ()
"From the beginning of a struct/union, etc. move forward to
......
......@@ -1204,7 +1204,7 @@ casts and declarations are fontified. Used on level 2 and higher."
((save-excursion
(goto-char match-pos)
(and (memq (char-before match-pos) '(?\( ?\,))
(c-go-up-list-backward match-pos)
(c-go-up-list-backward match-pos (c-determine-limit 500))
(eq (char-after) ?\()
(let ((type (c-get-char-property (point) 'c-type)))
(or (memq type '(c-decl-arg-start c-decl-type-start))
......@@ -1605,7 +1605,7 @@ casts and declarations are fontified. Used on level 2 and higher."
c-recognize-knr-p) ; Strictly speaking, bogus, but it
; speeds up lisp.h tremendously.
(save-excursion
(when (not (c-back-over-member-initializers))
(when (not (c-back-over-member-initializers (c-determine-limit 2000)))
(unless (or (eobp)
(looking-at "\\s(\\|\\s)"))
(forward-char))
......
......@@ -1256,7 +1256,6 @@ Note that the style variables are always made local to the buffer."
(re-search-forward "[\n\r]?\\(\\\\\\(.\\|\n\\)\\|[^\\\n\r]\\)*"
nil t)
;; We're at an EOLL or point-max.
(setq c-new-END (max c-new-END (min (1+ (point)) (point-max))))
(if (equal (c-get-char-property (point) 'syntax-table) '(15))
(if (memq (char-after) '(?\n ?\r))
;; Normally terminated invalid string.
......@@ -1363,6 +1362,16 @@ Note that the style variables are always made local to the buffer."
(cdr (assq (char-before) c-string-innards-re-alist)) nil t)
(1+ (point)))))
(cll)))
(end-hwm ; the highest position which could possibly be affected by
; insertion/deletion of string delimiters.
(max
(progn
(goto-char (min (1+ end) ; 1+, in case a NL has become escaped.
(point-max)))
(re-search-forward "\\(\\\\\\(.\\|\n\\|\r\\)\\|[^\\\n\r]\\)*"
nil t)
(point))
c-new-END))
s)
(goto-char
(cond ((null beg-literal-type)
......@@ -1374,13 +1383,13 @@ Note that the style variables are always made local to the buffer."
;; Handle one string each time around the next while loop.
(while
(and
(< (point) c-new-END)
(< (point) end-hwm)
(progn
;; Skip over any comments before the next string.
(while (progn
(setq s (parse-partial-sexp (point) c-new-END nil
(setq s (parse-partial-sexp (point) end-hwm nil
nil s 'syntax-table))
(and (< (point) c-new-END)
(and (< (point) end-hwm)
(or (not (nth 3 s))
(not (memq (char-before) c-string-delims))))))
;; We're at the start of a string.
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment