JezK
Edit File: jit-lock.elc
;ELC ;;; Compiled by mockbuild@buildfarm03-new.corp.cloudlinux.com on Wed Aug 19 23:56:22 2026 ;;; from file /builddir/build/BUILD/emacs-24.3/lisp/jit-lock.el ;;; in Emacs version 24.3 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301\302\303\304\305\306\307&\210\310\311\312\313\314\315\306\301&\210\310\316\302\317\314\320\306\301&\210\310\321\322\323\314\324\306\301&\210\310\325\326\327\314\302\330\331\217\203< \332\202= \333\306\301&\210\310\334\302\335\314\336\306\301&\210\337\340\341\"\210\310\341\342\343\314\344\306\301&\210\310\345\346\347\314\350\306\301&\210\310\351\302\352\306\301\314\353&\207" [custom-declare-group jit-lock nil "Font Lock support mode to fontify just-in-time." :version "21.1" :group font-lock custom-declare-variable jit-lock-chunk-size 500 "Jit-lock fontifies chunks of at most this many characters at a time.\n\nThis variable controls both display-time and stealth fontification." :type integer jit-lock-stealth-time "Time in seconds to wait before beginning stealth fontification.\nStealth fontification occurs if there is no input within this time.\nIf nil, stealth fontification is never performed.\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (number :tag "seconds" :value 16)) jit-lock-stealth-nice 0.5 "Time in seconds to pause between chunks of stealth fontification.\nEach iteration of stealth fontification is separated by this amount of time,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never paused.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could increase the value of this variable.\nSee also `jit-lock-stealth-load'." (choice (const :tag "never" nil) (number :tag "seconds")) jit-lock-stealth-load (if (condition-case nil (load-average) (error)) 200) "Load in percentage above which stealth fontification is suspended.\nStealth fontification pauses when the system short-term load average (as\nreturned by the function `load-average' if supported) goes above this level,\nthus reducing the demand that stealth fontification makes on the system.\nIf nil, means stealth fontification is never suspended.\nTo reduce machine load during stealth fontification, at the cost of stealth\ntaking longer to fontify, you could reduce the value of this variable.\nSee also `jit-lock-stealth-nice'." (load-average) ((error)) (choice (const :tag "never" nil) (integer :tag "load")) (const :format "%t: unsupported\n" nil) jit-lock-stealth-verbose "If non-nil, means stealth fontification should show status messages." boolean defvaralias jit-lock-defer-contextually jit-lock-contextually 'syntax-driven "If non-nil, means fontification should be syntactically true.\nIf nil, means fontification occurs only on those lines modified. This\nmeans where modification on a line causes syntactic change on subsequent lines,\nthose subsequent lines are not refontified to reflect their new context.\nIf t, means fontification occurs on those lines modified and all\nsubsequent lines. This means those subsequent lines are refontified to reflect\ntheir new syntactic context, after `jit-lock-context-time' seconds.\nIf any other value, e.g., `syntax-driven', means syntactically true\nfontification occurs only if syntactic fontification is performed using the\nbuffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil.\n\nThe value of this variable is used when JIT Lock mode is turned on." (choice (const :tag "never" nil) (const :tag "always" t) (other :tag "syntax-driven" syntax-driven)) jit-lock-context-time 0.5 "Idle time after which text is contextually refontified, if applicable." (number :tag "seconds") jit-lock-defer-time "Idle time after which deferred fontification should take place.\nIf nil, fontification is not deferred." (choice (const :tag "never" nil) (number :tag "seconds"))] 8) #@49 Non-nil means Just-in-time Lock mode is active. (defvar jit-lock-mode nil (#$ . 4294)) (make-variable-buffer-local 'jit-lock-mode) #@123 Functions to do the actual fontification. They are called with two arguments: the START and END of the region to fontify. (defvar jit-lock-functions nil (#$ . 4432)) (make-variable-buffer-local 'jit-lock-functions) #@110 Consider text after this position as contextually unfontified. If nil, contextual fontification is disabled. (defvar jit-lock-context-unfontify-pos nil (#$ . 4654)) (make-variable-buffer-local 'jit-lock-context-unfontify-pos) #@60 Timer for stealth fontification in Just-in-time Lock mode. (defvar jit-lock-stealth-timer nil (#$ . 4886)) #@69 Timer for repeated stealth fontification in Just-in-time Lock mode. (defvar jit-lock-stealth-repeat-timer nil (#$ . 4999)) #@60 Timer for context fontification in Just-in-time Lock mode. (defvar jit-lock-context-timer nil (#$ . 5128)) #@61 Timer for deferred fontification in Just-in-time Lock mode. (defvar jit-lock-defer-timer nil (#$ . 5241)) #@54 List of buffers with pending deferred fontification. (defvar jit-lock-defer-buffers nil (#$ . 5353)) #@54 List of buffers that are being fontified stealthily. (defvar jit-lock-stealth-buffers nil (#$ . 5460)) #@1588 Toggle Just-in-time Lock mode. Turn Just-in-time Lock mode on if and only if ARG is non-nil. Enable it automatically by customizing group `font-lock'. When Just-in-time Lock mode is enabled, fontification is different in the following ways: - Demand-driven buffer fontification triggered by Emacs C code. This means initial fontification of the whole buffer does not occur. Instead, fontification occurs when necessary, such as when scrolling through the buffer would otherwise reveal unfontified areas. This is useful if buffer fontification is too slow for large buffers. - Stealthy buffer fontification if `jit-lock-stealth-time' is non-nil. This means remaining unfontified areas of buffers are fontified if Emacs has been idle for `jit-lock-stealth-time' seconds, while Emacs remains idle. This is useful if any buffer has any deferred fontification. - Deferred context fontification if `jit-lock-contextually' is non-nil. This means fontification updates the buffer corresponding to true syntactic context, after `jit-lock-context-time' seconds of Emacs idle time, while Emacs remains idle. Otherwise, fontification occurs on modified lines only, and subsequent lines can remain fontified corresponding to previous syntactic contexts. This is useful where strings or comments span lines. Stealth fontification only occurs while the system remains unloaded. If the system load rises above `jit-lock-stealth-load' percent, stealth fontification is suspended. Stealth fontification intensity is controlled via the variable `jit-lock-stealth-nice'. (defalias 'jit-lock-mode #[(arg) "\211\203j \306 \210\n\203 \204 \307\n\310\311#\n\2032 \f\2042 \312\310\313\211\211\211\211\211\211\211& \314\f\311\315#\210 \203B \204B \307 \310\316#\310=\203^ \204V \307 \310\317# \206\\ d \320\321\322\313\310$\210\320\323\324\"\207 \204x \204x \203\242 \325\326\215\204\242 \203\210 \327 !\210\313\203\225 \327!\210\313\203\242 \327!\210\313\330\321\322\310#\210\330\323\324\"\207" [arg jit-lock-mode jit-lock-stealth-time jit-lock-stealth-timer jit-lock-stealth-repeat-timer jit-lock-defer-time jit-lock-refontify run-with-idle-timer t jit-lock-stealth-fontify vector nil timer-set-function (t) jit-lock-deferred-fontify jit-lock-context-fontify add-hook after-change-functions jit-lock-after-change fontification-functions jit-lock-function found (byte-code "\303 \304\211\205\" @rq\210\n\203 \305\306\307\"\210) A\211\204 \304*\207" [buf --dolist-tail-- jit-lock-mode buffer-list nil throw found t] 4) cancel-timer remove-hook jit-lock-defer-timer jit-lock-contextually jit-lock-context-timer jit-lock-context-time jit-lock-context-unfontify-pos] 11 (#$ . 5571)]) #@255 Register FUN as a fontification function to be called in this buffer. FUN will be called with two arguments START and END indicating the region that needs to be (re)fontified. If non-nil, CONTEXTUAL means that a contextual fontification would be useful. (defalias 'jit-lock-register #[(fun &optional contextual) "\303\304\305\306$\210 \203 \n\203 \307\302!\210\306\310\306!\207" [fun contextual jit-lock-contextually add-hook jit-lock-functions nil t make-local-variable jit-lock-mode] 5 (#$ . 8315)]) #@81 Unregister FUN as a fontification function. Only applies to the current buffer. (defalias 'jit-lock-unregister #[(fun) "\302\301\303#\210 ?\205 \304\305!\207" [fun jit-lock-functions remove-hook t jit-lock-mode nil] 4 (#$ . 8827)]) #@70 Force refontification of the region BEG..END (default whole buffer). (defalias 'jit-lock-refontify #[(&optional beg end) "\306\307 \306\211\306 \310\211 \f\310 \311\216\214~\210\312\206 e\206% d\313\310$.\n\207" [inhibit-point-motion-hooks #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) put-text-property fontified buffer-file-name buffer-file-truename beg end] 6 (#$ . 9067)]) #@136 Fontify current buffer starting at position START. This function is added to `fontification-functions' when `jit-lock-mode' is active. (defalias 'jit-lock-function #[(start) "\205J ?\205J \n\204 \306 \211\f\\\"\207p >\204 p B\307 \310 \307\211 \307 \311\211 \311 \312\216\313 \314 \315\311d \f\\^$\315\316$. \207" [jit-lock-mode memory-full jit-lock-defer-timer start jit-lock-chunk-size jit-lock-defer-buffers jit-lock-fontify-now t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) put-text-property next-single-property-change fontified defer inhibit-point-motion-hooks #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename] 10 (#$ . 9615)]) #@100 Fontify current buffer from START to END. Defaults to the whole buffer. END can be out of bounds. (defalias 'jit-lock-fontify-now #[(&optional start end) "\306\307 \306\211\306 \310\211 \310 \311\216\212\204 e \203* d^\202+ d \310 \312 \313\216\205\270 W\205\270 \314 \315\306$\206T \211 b\210\316\317! b\210\316 \203\207 W\203\207 Y\203\207 \320\321\"\204\207 \322 \315\306$\210\323\324\325\217\210 W\203\251 \326\327\310\330p &\210\314 \315\310$\211\204? \310.\207" [inhibit-point-motion-hooks #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) text-property-any fontified line-beginning-position 2 get-text-property jit-lock-defer-multiline put-text-property err (byte-code "\302\303 #\207" [start next run-hook-with-args jit-lock-functions] 4) ((quit (byte-code "\303 \304\305$\210\306\n@\nA\"\207" [start next err put-text-property fontified nil signal] 5))) run-with-timer 0 jit-lock-force-redisplay buffer-file-name buffer-file-truename start end next orig-start save-match-data-internal jit-lock-context-unfontify-pos] 8 (#$ . 10414)]) #@69 Force the display engine to re-render buffer BUF from START to END. (defalias 'jit-lock-force-redisplay #[(buf start end) "rq\210\306\307 \306\211 \306 \310\211 \f \310 \311\216\312\313\306$.\n\207" [buf inhibit-point-motion-hooks #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) put-text-property fontified deactivate-mark buffer-file-name buffer-file-truename start end] 6 (#$ . 11784)]) #@121 Return the start of the next chunk to fontify around position AROUND. Value is nil if there is nothing more to fontify. (defalias 'jit-lock-stealth-chunk-start #[(around) "\306\307 !?\205o \214~\210\310d\311\312$\313\311\"\314eS]\311\"\n\2044 \312=?\205N e\f\315\245Z]\202N \312=\203I \313\n\311\"\206B e\n\fZ]\202N \n\fZ]\211 \204W \202n \204_ \202n Z ZW\203m \202n -\207" [around next prev prop jit-lock-chunk-size start zerop buffer-size text-property-not-all fontified t previous-single-property-change get-text-property 2] 6 (#$ . 12325)]) (put 'jit-lock-stealth-chunk-start 'byte-optimizer 'byte-compile-inline-expand) #@218 Fontify buffers stealthily. This function is called repeatedly after Emacs has become idle for `jit-lock-stealth-time' seconds. Optional argument REPEAT is expected non-nil in a repeated invocation of this function. (defalias 'jit-lock-stealth-fontify #[(&optional repeat) "\204 \306 !\210\n\206$ \206$ \307\310 !\206$ \203 \f\202# \311 \211??\205>\f@\312\313\211\211 ! \" # $%\203L \314 @%V\203L &#\202)\315$!\203&r$q\210'\203 ` (\316\317 !?\205\346 \214~\210\320(d\321\322$ )\323(\321\" *\324e(S]\321\" +*\204\236 +\322=?\205\277 e(,\325\245Z]\202\277 +\322=\203\267 \323*\321\"\206\256 e*,Z]\202\277 *(,Z]\211 \204\311 )\202\345 )\204\322 \202\345 ( Z)(ZW\203\343 \202\345 )-)\211\203 -\205\365 \326\327 P\313 . /\330\216/\203 \331 .\332\333/\"\210\334 \211,\\\"\2100\206\312#+\202\"\fA)\202)\fA\f\205=\335 \336 \"\210\337 #\"\210\340 \322\"-\207" [repeat jit-lock-stealth-repeat-timer executing-kbd-macro memory-full jit-lock-stealth-buffers start cancel-timer window-minibuffer-p selected-window buffer-list 0 nil load-average buffer-live-p zerop buffer-size text-property-not-all fontified t previous-single-property-change get-text-property 2 "JIT stealth lock " buffer-name ((byte-code "\203 \203 \302\303 \"\210\202 \302\304!\210\304\207" [#1=#:with-temp-message #2=#:current-message message #3="%s" nil] 3)) current-message message #3# jit-lock-fontify-now timer-set-idle-time current-idle-time timer-inc-time timer-activate-when-idle message-log-max minibuffer-auto-raise delay buffer jit-lock-stealth-load jit-lock-stealth-time jit-lock-mode around next prev prop jit-lock-chunk-size jit-lock-stealth-verbose #2# #1# jit-lock-stealth-nice] 5 (#$ . 12975)]) #@28 Fontify what was deferred. (defalias 'jit-lock-deferred-fontify #[nil "\205s ?\205s \306\211\203i @\307\n!\203b r\nq\210\310 \311 \310\211 \310 \306\211 \306 \312\216e \313\314\"\315=\203U \316\317\314\306d$\211\314\306$\210\317\314\"\211\204: . A\211\204 *\306\211 \320\321!)\207" [jit-lock-defer-buffers memory-full buffer --dolist-tail-- inhibit-point-motion-hooks #1=#:modified nil buffer-live-p t buffer-modified-p ((byte-code "\204 \301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) get-text-property fontified defer put-text-property next-single-property-change sit-for 0 buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename pos jit-lock-defer-timer] 8 (#$ . 14714)]) #@57 Refresh fontification to take new context into account. (defalias 'jit-lock-context-fontify #[nil "?\205f \306 \307\211\205e \n@r q\210 \203\\ \214~\210 eY\203[ dW\203[ \310 \311\"\2038 \312 \311\"\2067 e\313 \314 \313\211 \313 \307\211 \307 \315\216\316 d\317#\210. d))\nA\211\204 \307*\207" [memory-full buffer --dolist-tail-- jit-lock-context-unfontify-pos inhibit-point-motion-hooks #1=#:modified buffer-list nil get-text-property jit-lock-defer-multiline previous-single-property-change t buffer-modified-p ((byte-code "\204 \301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) remove-text-properties (fontified nil jit-lock-defer-multiline nil) buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename] 5 (#$ . 15506)]) #@611 Hook that can extend the text to refontify after a change. This is run after every buffer change. The functions are called with the three arguments of `after-change-functions': START END OLD-LEN. The extended region to refontify is returned indirectly by modifying the variables `jit-lock-start' and `jit-lock-end'. Note that extending the region this way is not strictly necessary, except that the nature of the redisplay code tends to otherwise leave some of the rehighlighted text displayed with the old highlight until the next redisplay (see comment about repeated redisplay in `jit-lock-fontify-now'). (defvar jit-lock-after-change-extend-region-functions nil (#$ . 16328)) #@382 Mark the rest of the buffer as not fontified after a change. Installed on `after-change-functions'. START and END are the start and end of the changed text. OLD-LEN is the pre-change length. This function ensures that lines following the change will be refontified in case the syntax of those lines has changed. Refontification will take place when text is fontified stealthily. (defalias 'jit-lock-after-change #[(start end old-len) "\205M ?\205M \n \306 \307 \306\211 \306 \310\211 \310 \311\216\312\313\n $\210\f\nT]d^\314 \f\315\310$\210. \205L ^\211*\207" [jit-lock-mode memory-full start end jit-lock-end jit-lock-start t buffer-modified-p nil ((byte-code "\204 \301\302!\210\302\207" [#1=#:modified restore-buffer-modified-p nil] 2)) run-hook-with-args jit-lock-after-change-extend-region-functions put-text-property fontified inhibit-point-motion-hooks #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename old-len jit-lock-context-unfontify-pos] 6 (#$ . 17017)]) (provide 'jit-lock)