;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:46:59 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/jit-lock.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`jit-lock.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #@55 *Jit-lock chunks of this many characters, or smaller. (custom-declare-variable 'jit-lock-chunk-size '500 '(#$ . -618) :type 'integer :group 'jit-lock) #@253 *Time in seconds to wait before beginning stealth fontification. Stealth fontification occurs if there is no input within this time. If nil, stealth fontification is never performed. The value of this variable is used when JIT Lock mode is turned on. (custom-declare-variable 'jit-lock-stealth-time '3 '(#$ . -776) :type '(choice (const :tag "never" nil) (number :tag "seconds")) :group 'jit-lock) #@454 *Time in seconds to pause between chunks of stealth fontification. Each iteration of stealth fontification is separated by this amount of time, thus reducing the demand that stealth fontification makes on the system. If nil, means stealth fontification is never paused. To reduce machine load during stealth fontification, at the cost of stealth taking longer to fontify, you could increase the value of this variable. See also `jit-lock-stealth-load'. (custom-declare-variable 'jit-lock-stealth-nice '0.125 '(#$ . -1182) :type '(choice (const :tag "never" nil) (number :tag "seconds")) :group 'jit-lock) #@529 *Load in percentage above which stealth fontification is suspended. Stealth fontification pauses when the system short-term load average (as returned by the function `load-average' if supported) goes above this level, thus reducing the demand that stealth fontification makes on the system. If nil, means stealth fontification is never suspended. To reduce machine load during stealth fontification, at the cost of stealth taking longer to fontify, you could reduce the value of this variable. See also `jit-lock-stealth-nice'. (custom-declare-variable 'jit-lock-stealth-load '(if (condition-case nil (load-average) (error)) 200) '(#$ . -1794) :type (if (condition-case nil (load-average) (error)) '(choice (const :tag "never" nil) (integer :tag "load")) '(const :format "%t: unsupported\n" nil)) :group 'jit-lock) #@71 *If non-nil, means stealth fontification should show status messages. (custom-declare-variable 'jit-lock-stealth-verbose 'nil '(#$ . -2615) :type 'boolean :group 'jit-lock) #@835 *If non-nil, means deferred fontification should be syntactically true. If nil, means deferred fontification occurs only on those lines modified. This means where modification on a line causes syntactic change on subsequent lines, those subsequent lines are not refontified to reflect their new context. If t, means deferred fontification occurs on those lines modified and all subsequent lines. This means those subsequent lines are refontified to reflect their new syntactic context, either immediately or when scrolling into them. If any other value, e.g., `syntax-driven', means deferred syntactically true fontification occurs only if syntactic fontification is performed using the buffer mode's syntax table, i.e., only if `font-lock-keywords-only' is nil. The value of this variable is used when JIT Lock mode is turned on. (custom-declare-variable 'jit-lock-defer-contextually ''syntax-driven '(#$ . -2795) :type '(choice (const :tag "never" nil) (const :tag "always" t) (other :tag "syntax-driven" syntax-driven)) :group 'jit-lock) #@49 Non-nil means Just-in-time Lock mode is active. (defvar jit-lock-mode nil (#$ . 3845)) (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 (#$ . 3983)) (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-first-unfontify-pos nil (#$ . 4205)) (make-variable-buffer-local 'jit-lock-first-unfontify-pos) #@60 Timer for stealth fontification in Just-in-time Lock mode. (defvar jit-lock-stealth-timer nil (#$ . 4433)) #@1594 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-defer-contextually' is non-nil. This means fontification updates the buffer corresponding to true syntactic context, after `jit-lock-stealth-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\203/\306 \210\n\203 \204\307\n\211\310#\f\311=\203# \206\"d\312\313\314\315\311$\210\312\316\317\"\207 \2039\320 !\210\315\321\313\314\311#\210\321\316\317\"\207" [arg jit-lock-mode jit-lock-stealth-time jit-lock-stealth-timer jit-lock-defer-contextually jit-lock-first-unfontify-pos jit-lock-refontify run-with-idle-timer jit-lock-stealth-fontify t add-hook after-change-functions jit-lock-after-change nil fontification-functions jit-lock-function cancel-timer remove-hook] 6 (#$ . 4548)]) #@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!\306L\210\310\306!\207" [fun contextual jit-lock-defer-contextually add-hook jit-lock-functions nil t make-local-variable jit-lock-mode] 5 (#$ . 6692)]) #@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 (#$ . 7210)]) #@70 Force refontification of the region BEG..END (default whole buffer). (defalias 'jit-lock-refontify #[(&optional beg end) "\306 \307\216\310\211\211\211\311\211\211\f \214~\210\312\206e\206%d\313#.\n\207" [#1=#:modified buffer-file-truename buffer-file-name deactivate-mark inhibit-modification-hooks inhibit-point-motion-hooks buffer-modified-p ((byte-code "\204\301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) t nil add-text-properties (fontified nil) inhibit-read-only buffer-undo-list beg end] 7 (#$ . 7450)]) #@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) "\205\n\303 \211\n\\\"\207" [jit-lock-mode start jit-lock-chunk-size jit-lock-fontify-now] 4 (#$ . 8002)]) #@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\216\310\211\211\211\311\211\211\212\214~\210\204!e\203-d^\202.d\311\312 \313\216\205|\314\315\310$\206K\211b\210\316\317!b\210\316 \320\321#\210\322\323#\210\314\315\311$\211\204>\311.\207" [#1=#:modified buffer-file-truename buffer-file-name deactivate-mark inhibit-modification-hooks inhibit-point-motion-hooks buffer-modified-p ((byte-code "\204\301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) t nil match-data ((set-match-data save-match-data-internal)) text-property-any fontified line-beginning-position 2 add-text-properties (fontified t) run-hook-with-args jit-lock-functions inhibit-read-only buffer-undo-list start end next save-match-data-internal] 8 (#$ . 8292)]) #@122 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 !?\205k\214~\210\310d\311\312$\313\311\"\314eS]\311\"\n\2042 ?\205Je\f\315\245Z]\202J \203E\313\n\311\"\206>e\n\fZ]\202J\n\fZ]\211\204S \202j \204[ \202j Z ZW\203i \202j -\207" [around next prev prop jit-lock-chunk-size start zerop buffer-size text-property-any fontified nil previous-single-property-change get-text-property 2] 6 (#$ . 9219)]) (put 'jit-lock-stealth-chunk-start 'byte-optimizer 'byte-compile-inline-expand) #@117 Fontify buffers stealthily. This functions is called after Emacs has been idle for `jit-lock-stealth-time' seconds. (defalias 'jit-lock-stealth-fontify #[nil "\206\306\307 !?\205^\310 \311\211 \205]\312 ?\205] @ Ar\fq\210 \203Y!\2054\313\314 P\311\"#\315\216#\203J\316 \"\317\320#\"\210$\203\211\214~\210$eY\203\210$dW\203\210\321 %\322\216\323\211\211\211\311\211\211&'()*+,\324$d\325\311$\210. d$)\311-\206\220\326`./0.1\327\330 !?\205!\214~\210\3311d\325\311$2\3321\325\"3\333e1S]\325\"43\204\3274?\205\366e15\334\245Z]\202\3664\203\356\3323\325\"\206\345e35Z]\202\366315Z]\2110\2042\202 2\204 0\202 10Z21ZW\2030\202 2-)\2110\203W\335/!\203W6\203F\336 @6V\203F\3357\206D\337!\210\312 \204\227\3400\2115\\\"\210\202\227.*\202+\207" [executing-kbd-macro message-log-max minibuffer-auto-raise buffers buffer jit-lock-mode window-minibuffer-p selected-window buffer-list nil input-pending-p "JIT stealth lock " buffer-name ((byte-code "\203 \203 \302\303 \"\210\302\207" [#1=#:with-temp-message #2=#:current-message message "%s"] 3)) current-message message "%s" buffer-modified-p ((byte-code "\204\301\302!\210\302\207" [#3=#:modified restore-buffer-modified-p nil] 2)) t put-text-property fontified 0 zerop buffer-size text-property-any previous-single-property-change get-text-property 2 sit-for load-average 30 jit-lock-fontify-now jit-lock-stealth-verbose #2# #1# jit-lock-first-unfontify-pos #3# buffer-file-truename buffer-file-name deactivate-mark inhibit-modification-hooks inhibit-point-motion-hooks inhibit-read-only buffer-undo-list jit-lock-stealth-nice point nice start around next prev prop jit-lock-chunk-size jit-lock-stealth-load jit-lock-stealth-time] 7 (#$ . 9857)]) #@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) "\205Y\212\306 \307\216\310\211\211\211\311\211\211b\210\312 \313\314\"\2036\315\314\"\2064eT]d^\316\317\311$\210. \205X^\211)\207" [jit-lock-mode #1=#:modified buffer-file-truename buffer-file-name deactivate-mark inhibit-modification-hooks buffer-modified-p ((byte-code "\204\301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) t nil line-beginning-position get-text-property font-lock-multiline previous-single-property-change put-text-property fontified inhibit-point-motion-hooks inhibit-read-only buffer-undo-list start end jit-lock-first-unfontify-pos] 7 (#$ . 11659)]) (provide 'jit-lock)