[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

master 22b8d68: CC Mode: Remove annoying background fontification. Shoul

From: Alan Mackenzie
Subject: master 22b8d68: CC Mode: Remove annoying background fontification. Should fix bug #52298
Date: Sun, 19 Dec 2021 09:29:46 -0500 (EST)

branch: master
commit 22b8d6813217187e3121338b93deabe62add99c1
Author: Alan Mackenzie <acm@muc.de>
Commit: Alan Mackenzie <acm@muc.de>

    CC Mode: Remove annoying background fontification.  Should fix bug #52298
    Partially revert the commits from 2021-10-24 - 2021-10-26, "CC Mode: Fontify
    "found types" which are recognized after being first scanned".
    This removes the background fontification which ran off of a 0.1s timer, but
    leaves the facility of normal fontification causing the fontification
    throughout the buffer of newly found types.
    * lisp/progmodes/cc-fonts.el (c-find-types-background)
    (c-type-finder-timer-func): Remove.
    * lisp/progmodes/cc-mode.el (c-type-finder-timer, c-inhibit-type-finder)
    (c-type-finder-pos, c-post-gc-hook): Remove.
    (c-leave-cc-mode-mode): Remove the manipulations of c-type-finder-timer and
    (c-basic-common-init): Remove the manipulations of c-type-finder-pos,
    c-type-finder-timer, and c-post-gc-hook.
    * lisp/progmodes/cc-vars.el (c-type-finder-time-slot)
    (c-type-finder-repeat-time, c-type-finder-chunk-size): Remove.
    * doc/misc/cc-mode.texi (Found Types): Remove.  Amend some menu entries.
 doc/misc/cc-mode.texi      |  56 ---------------
 lisp/progmodes/cc-fonts.el | 173 ---------------------------------------------
 lisp/progmodes/cc-mode.el  |  35 +--------
 lisp/progmodes/cc-vars.el  |  33 ---------
 4 files changed, 1 insertion(+), 296 deletions(-)

diff --git a/doc/misc/cc-mode.texi b/doc/misc/cc-mode.texi
index a2ff572..a388846 100644
--- a/doc/misc/cc-mode.texi
+++ b/doc/misc/cc-mode.texi
@@ -284,7 +284,6 @@ Font Locking
 * Faces::
 * Doc Comments::
 * Wrong Comment Style::
-* Found Types::
 * Misc Font Locking::
 * AWK Mode Font Locking::
@@ -1857,7 +1856,6 @@ sections apply to the other languages.
 * Faces::
 * Doc Comments::
 * Wrong Comment Style::
-* Found Types::
 * Misc Font Locking::
 * AWK Mode Font Locking::
 @end menu
@@ -2165,60 +2163,6 @@ which aren't of the default style will be fontified with
 @end defvar
 @comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-@node    Found Types
-@comment  node-name,  next,  previous,  up
-@section ``Found Type'' handling.
-@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-In most languages handled by CC Mode, @dfn{found types} are recognized
-as types by their context in the source code.  These contrast with
-types which are basic to a language or are declared as types (e.g. by
-@code{typedef} in C).
-In earlier versions of @ccmode{}, when @code{jit-lock-mode} was
-enabled in Emacs (which it is by default), found types would
-frequently fail to get fontified properly.  This happened when the
-fontification functions scanned a use of the found type before
-scanning the code which caused it to be recognized.
-From @ccmode{} version 5.36, a timer mechanism scans the entire buffer
-for found types in the seconds immediately after starting the major
-mode.  When a found type gets recognized, all its occurrences in the
-buffer get marked for (re)fontification.  This scanning happens in
-short time slices interleaved with other processing, such as keyboard
-handling, so that the responsiveness of Emacs should be barely
-affected.  This mechanism can be disabled (see below).  It is only
-active when @code{jit-lock-mode} is also active.
-@defvar c-type-finder-time-slot
-@vindex type-finder-time-slot (c-)
-The approximate time in seconds that CC Mode spends in scanning source
-code before relinquishing control to other Emacs activities.  The
-default value is 0.05.  To disable the scanning mechanism, set this
-variable to @code{nil}.
-@end defvar
-@defvar c-type-finder-repeat-time
-@vindex type-finder-repeat-time (c-)
-The approximate frequency (in seconds) with which the scanning
-mechanism is triggered.  This time must be greater than
-@code{c-type-finder-time-slot}.  Its default value is 0.1.  If a less
-powerful machine becomes sluggish due to the scanning, increase the
-value of @code{c-type-finder-repeat-time} to compensate.
-@end defvar
-@defvar c-type-finder-chunk-size
-@vindex type-finder-chunk-size (c-)
-The approximate size (in characters) of the buffer chunk processed as
-a unit before the scanning mechanism checks whether
-@code{c-type-finder-time-slot} seconds have passed.  The default value
-is 1000.  A too small value here will cause inefficiencies due to the
-initialization which happens for each chunk, whereas a too large value
-will cause the processing to consume an excessive proportion of the
-@end defvar
-@comment !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 @node    Misc Font Locking
 @comment  node-name,  next,  previous,  up
 @section Miscellaneous Font Locking
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 967464a..846c25f 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -93,14 +93,10 @@
 (cc-bytecomp-defvar c-preprocessor-face-name)
 (cc-bytecomp-defvar c-reference-face-name)
 (cc-bytecomp-defvar c-block-comment-flag)
-(cc-bytecomp-defvar c-type-finder-pos)
-(cc-bytecomp-defvar c-inhibit-type-finder)
-(cc-bytecomp-defvar c-type-finder-timer)
 (cc-bytecomp-defun c-fontify-recorded-types-and-refs)
 (cc-bytecomp-defun c-font-lock-declarators)
 (cc-bytecomp-defun c-font-lock-objc-method)
 (cc-bytecomp-defun c-font-lock-invalid-string)
-(cc-bytecomp-defun c-before-context-fl-expand-region)
 (cc-bytecomp-defun c-font-lock-fontify-region)
@@ -1603,175 +1599,6 @@ casts and declarations are fontified.  Used on level 2 
and higher."
-(defun c-find-types-background (start limit)
-  ;; Find any "found types" between START and LIMIT.  Allow any such types to
-  ;; be entered into `c-found-types' by the action of `c-forward-name' or
-  ;; `c-forward-type' called from this function.  This process also causes
-  ;; occurrences of the type to be prepared for fontification throughout the
-  ;; buffer.
-  ;;
-  ;; Return POINT at the end of the function.  This should be at or after
-  ;; LIMIT, and not later than the next decl-spot after LIMIT.
-  ;;
-  ;; This function is called from the timer `c-type-finder-timer'.  It may do
-  ;; hidden buffer changes.
-  (save-excursion
-    (save-restriction
-      (widen)
-      (goto-char start)
-      ;; If we're in a (possibly large) literal, skip over it.
-      (let ((lit-bounds (nth 2 (c-full-pp-to-literal (point)))))
-       (if lit-bounds
-           (goto-char (cdr lit-bounds))))
-      (when (< (point) limit)
-       (let (;; o - 'decl if we're in an arglist containing declarations
-             ;;   (but if `c-recognize-paren-inits' is set it might also be
-             ;;   an initializer arglist);
-             ;; o - '<> if the arglist is of angle bracket type;
-             ;; o - 'arglist if it's some other arglist;
-             ;; o - nil, if not in an arglist at all.  This includes the
-             ;;   parenthesized condition which follows "if", "while", etc.
-             context
-             ;; A list of starting positions of possible type declarations, or 
-             ;; the typedef preceding one, if any.
-             last-cast-end
-             ;; The result from `c-forward-decl-or-cast-1'.
-             decl-or-cast
-             ;; The maximum of the end positions of all the checked type
-             ;; decl expressions in the successfully identified
-             ;; declarations.  The position might be either before or
-             ;; after the syntactic whitespace following the last token
-             ;; in the type decl expression.
-             (max-type-decl-end 0)
-             ;; Same as `max-type-decl-*', but used when we're before
-             ;; `token-pos'.
-             (max-type-decl-end-before-token 0)
-             )
-         (goto-char start)
-         (c-find-decl-spots
-          limit
-          c-decl-start-re
-          nil                          ; (eval c-maybe-decl-faces)
-          (lambda (match-pos inside-macro &optional toplev)
-            ;; Note to maintainers: don't use `limit' inside this lambda form;
-            ;; c-find-decl-spots sometimes narrows to less than `limit'.
-            (if (and c-macro-with-semi-re
-                     (looking-at c-macro-with-semi-re))
-                ;; Don't do anything more if we're looking at something that
-                ;; can't start a declaration.
-                t
-              ;; Set `context' and `c-restricted-<>-arglists'.  Look for
-              ;; "<" for the sake of C++-style template arglists.
-              ;; "Ignore "(" when it's part of a control flow construct
-              ;; (e.g. "for (").
-              (let ((got-context
-                     (c-get-fontification-context
-                      match-pos
-                      (< match-pos (if inside-macro
-                                       max-type-decl-end-before-token
-                                     max-type-decl-end))
-                      toplev)))
-                (setq context (car got-context)
-                      c-restricted-<>-arglists (cdr got-context)))
-              ;; In QT, "more" is an irritating keyword that expands to 
-              ;; We skip over it to prevent recognition of "more slots: 
-              ;; as a bitfield declaration.
-              (when (and (c-major-mode-is 'c++-mode)
-                         (looking-at
-                          (concat "\\(more\\)\\([^" c-symbol-chars 
-                (goto-char (match-end 1))
-                (c-forward-syntactic-ws))
-              ;; Now analyze the construct.  This analysis will cause
-              ;; `c-forward-name' and `c-forward-type' to call `c-add-type',
-              ;; triggering the desired recognition and fontification of
-              ;; these found types.
-              (when (not (eq context 'not-decl))
-                (setq decl-or-cast
-                      (c-forward-decl-or-cast-1
-                       match-pos context last-cast-end))
-                (cond
-                 ((eq decl-or-cast 'cast)
-                  ;; Save the position after the previous cast so we can feed
-                  ;; it to `c-forward-decl-or-cast-1' in the next round.  That
-                  ;; helps it discover cast chains like "(a) (b) c".
-                  (setq last-cast-end (point))
-                  nil)
-                 (decl-or-cast
-                  ;; We've found a declaration.
-                  ;; Set `max-type-decl-end' or 
-                  ;; under the assumption that we're after the first type decl
-                  ;; expression in the declaration now.  That's not really 
-                  ;; we could also be after a parenthesized initializer
-                  ;; expression in C++, but this is only used as a last resort
-                  ;; to slant ambiguous expression/declarations, and overall
-                  ;; it's worth the risk to occasionally fontify an expression
-                  ;; as a declaration in an initializer expression compared to
-                  ;; getting ambiguous things in normal function prototypes
-                  ;; fontified as expressions.
-                  (if inside-macro
-                      (when (> (point) max-type-decl-end-before-token)
-                        (setq max-type-decl-end-before-token (point)))
-                    (when (> (point) max-type-decl-end)
-                      (setq max-type-decl-end (point)))))
-                 (t t))))))))
-      (point))))
-(defun c-type-finder-timer-func ()
-  ;; A CC Mode idle timer function for finding "found types".  It triggers
-  ;; every `c-type-finder-repeat-time' seconds and processes buffer chunks of
-  ;; size around `c-type-finder-chunk-size' characters, and runs for (a little
-  ;; over) `c-type-finder-time-slot' seconds.  The types it finds are inserted
-  ;; into `c-found-types', and their occurrences throughout the buffer are
-  ;; prepared for fontification.
-  (when (and c-type-finder-time-slot
-            (boundp 'font-lock-support-mode)
-            (eq font-lock-support-mode 'jit-lock-mode))
-    (if c-inhibit-type-finder ; No processing immediately after a GC operation.
-       (setq c-inhibit-type-finder nil)
-      (let* ((stop-time (+ (float-time) c-type-finder-time-slot))
-            (buf-list (buffer-list)))
-       ;; One CC Mode buffer needing processing each time around this loop.
-       (while (and buf-list
-                   (< (float-time) stop-time))
-         ;; Cdr through BUF-LIST to find the next buffer needing processing.
-         (while (and buf-list
-                     (not (with-current-buffer (car buf-list) 
-           (setq buf-list (cdr buf-list)))
-         (when buf-list
-           (with-current-buffer (car buf-list)
-             ;; (message "%s" (current-buffer)) ; Useful diagnostic.
-             (save-restriction
-               (widen)
-               ;; Process one `c-type-finder-chunk-size' chunk each time
-               ;; around this loop.
-               (while (and c-type-finder-pos
-                           (< (float-time) stop-time))
-                 ;; Process one chunk per iteration.
-                 (save-match-data
-                   (c-save-buffer-state
-                       (case-fold-search
-                        (beg (marker-position c-type-finder-pos))
-                        (end (min (+ beg c-type-finder-chunk-size) 
-                        (region (c-before-context-fl-expand-region beg end)))
-                     (setq beg (car region)
-                           end (cdr region))
-                     (setq beg (max (c-find-types-background beg end) end))
-                     (move-marker c-type-finder-pos
-                                  (if (save-excursion (goto-char beg) (eobp))
-                                      nil
-                                    beg))
-                     (when (not (marker-position c-type-finder-pos))
-                       (setq c-type-finder-pos nil))))))))))))
-  ;; Set the timer to run again.
-  (setq c-type-finder-timer
-       (run-at-time c-type-finder-repeat-time nil #'c-type-finder-timer-func)))
 (defun c-font-lock-enum-body (limit)
   ;; Fontify the identifiers of each enum we find by searching forward.
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index f9435c9..ae2ca39 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -129,16 +129,6 @@
 ;   '
 (require 'cc-fonts) ;)
-(defvar c-type-finder-timer nil)
-;; The variable which holds the repeating idle timer which triggers off the
-;; background type finding search.
-(defvar c-inhibit-type-finder nil)
-;; When non-nil (set by `c-post-gc-hook') don't perform the type finding
-;; activities the next time `c-type-finder-timer' triggers.  This ensures
-;; keyboard/mouse input will be dealt with when garbage collection is taking a
-;; large portion of CPU time.
 ;; The following three really belong to cc-fonts.el, but they are required
 ;; even when cc-fonts.el hasn't been loaded (this happens in XEmacs when
 ;; font-lock-mode is nil).
@@ -197,10 +187,7 @@
                (throw 'found nil)))
          (remove-hook 'post-command-hook 'c-post-command)
-         (remove-hook 'post-gc-hook 'c-post-gc-hook)
-         (and c-type-finder-timer
-              (progn (cancel-timer c-type-finder-timer)
-                     (setq c-type-finder-timer nil)))))
+         (remove-hook 'post-gc-hook 'c-post-gc-hook)))
       (c-save-buffer-state ()
        (c-clear-char-properties (point-min) (point-max) 'category)
        (c-clear-char-properties (point-min) (point-max) 'syntax-table)
@@ -596,12 +583,6 @@ preferably use the `c-mode-menu' language constant 
 ;; currently no such text property.
 (make-variable-buffer-local 'c-max-syn-tab-mkr)
-;; `c-type-finder-pos' is a marker marking the current place in a CC Mode
-;; buffer which is due to be searched next for "found types", or nil if the
-;; searching is complete.
-(defvar c-type-finder-pos nil)
-(make-variable-buffer-local 'c-type-finder-pos)
 (defun c-basic-common-init (mode default-style)
   "Initialize the syntax handling routines and the line breaking/filling code.
 Intended to be used by other packages that embed CC Mode.
@@ -774,17 +755,6 @@ that requires a literal mode spec at compile time."
   ;; c-after-font-lock-init.
   (add-hook 'after-change-functions 'c-after-change nil t)
   (add-hook 'post-command-hook 'c-post-command)
-  (setq c-type-finder-pos
-       (save-restriction
-         (widen)
-         (move-marker (make-marker) (point-min))))
-  ;; Install the functionality for seeking "found types" at mode startup:
-  (or c-type-finder-timer
-      (setq c-type-finder-timer
-           (run-at-time
-            c-type-finder-repeat-time nil #'c-type-finder-timer-func)))
-  (add-hook 'post-gc-hook #'c-post-gc-hook)
   (when (boundp 'font-lock-extend-after-change-region-function)
     (set (make-local-variable 'font-lock-extend-after-change-region-function)
@@ -2028,9 +1998,6 @@ Note that this is a strict tail, so won't match, e.g. 
          c-new-id-end nil
          c-new-id-is-type nil)))
-(defun c-post-gc-hook (&optional _stats) ; For XEmacs.
-  (setq c-inhibit-type-finder t))
 (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
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 40a43c3..83fd3da 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1524,39 +1524,6 @@ working due to this change."
   :type 'boolean
   :group 'c)
-(defcustom c-type-finder-time-slot 0.05
-  "The length in seconds of a background type search time slot.
-In CC Mode modes, \"found types\" wouldn't always get cleanly
-fontified without the background searching for them which happens
-in the seconds after starting Emacs or initializing the major
-This background searching can be disabled by setting this option
-to nil."
-  :type '(choice (const :tag "disabled" nil)
-                number)
-  :group 'c)
-(defcustom c-type-finder-repeat-time 0.1
-  "The interval, in seconds, at which background type searches occur.
-This interval must be greater than `c-type-finder-time-slot'."
-  :type 'number
-  :group 'c)
-(defcustom c-type-finder-chunk-size 1000
-  "The size, in characters, of a chunk for background type search.
-Chunks of this size are searched atomically for \"found types\"
-just after starting Emacs or initializing the major mode.
-This chunk size is a balance between efficiency (with larger
-values) and responsiveness of the keyboard (with smaller values).
-See also `c-type-finder-time-slot'."
-  :type 'integer
-  :group 'c)
 (define-widget 'c-extra-types-widget 'radio
   "Internal CC Mode widget for the `*-font-lock-extra-types' variables."
   :args '((const :tag "none" nil)

reply via email to

[Prev in Thread] Current Thread [Next in Thread]