1;;; font-lock.el --- Electric font lock mode 2 3;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 4;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 5 6;; Author: jwz, then rms, then sm 7;; Maintainer: FSF 8;; Keywords: languages, faces 9 10;; This file is part of GNU Emacs. 11 12;; GNU Emacs is free software; you can redistribute it and/or modify 13;; it under the terms of the GNU General Public License as published by 14;; the Free Software Foundation; either version 2, or (at your option) 15;; any later version. 16 17;; GNU Emacs is distributed in the hope that it will be useful, 18;; but WITHOUT ANY WARRANTY; without even the implied warranty of 19;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20;; GNU General Public License for more details. 21 22;; You should have received a copy of the GNU General Public License 23;; along with GNU Emacs; see the file COPYING. If not, write to the 24;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 25;; Boston, MA 02110-1301, USA. 26 27;;; Commentary: 28 29;; Font Lock mode is a minor mode that causes your comments to be displayed in 30;; one face, strings in another, reserved words in another, and so on. 31;; 32;; Comments will be displayed in `font-lock-comment-face'. 33;; Strings will be displayed in `font-lock-string-face'. 34;; Regexps are used to display selected patterns in other faces. 35;; 36;; To make the text you type be fontified, use M-x font-lock-mode RET. 37;; When this minor mode is on, the faces of the current line are updated with 38;; every insertion or deletion. 39;; 40;; To turn Font Lock mode on automatically, add this to your ~/.emacs file: 41;; 42;; (add-hook 'emacs-lisp-mode-hook 'turn-on-font-lock) 43;; 44;; Or if you want to turn Font Lock mode on in many modes: 45;; 46;; (global-font-lock-mode t) 47;; 48;; Fontification for a particular mode may be available in a number of levels 49;; of decoration. The higher the level, the more decoration, but the more time 50;; it takes to fontify. See the variable `font-lock-maximum-decoration', and 51;; also the variable `font-lock-maximum-size'. Support modes for Font Lock 52;; mode can be used to speed up Font Lock mode. See `font-lock-support-mode'. 53 54;;; How Font Lock mode fontifies: 55 56;; When Font Lock mode is turned on in a buffer, it (a) fontifies the entire 57;; buffer and (b) installs one of its fontification functions on one of the 58;; hook variables that are run by Emacs after every buffer change (i.e., an 59;; insertion or deletion). Fontification means the replacement of `face' text 60;; properties in a given region; Emacs displays text with these `face' text 61;; properties appropriately. 62;; 63;; Fontification normally involves syntactic (i.e., strings and comments) and 64;; regexp (i.e., keywords and everything else) passes. There are actually 65;; three passes; (a) the syntactic keyword pass, (b) the syntactic pass and (c) 66;; the keyword pass. Confused? 67;; 68;; The syntactic keyword pass places `syntax-table' text properties in the 69;; buffer according to the variable `font-lock-syntactic-keywords'. It is 70;; necessary because Emacs' syntax table is not powerful enough to describe all 71;; the different syntactic constructs required by the sort of people who decide 72;; that a single quote can be syntactic or not depending on the time of day. 73;; (What sort of person could decide to overload the meaning of a quote?) 74;; Obviously the syntactic keyword pass must occur before the syntactic pass. 75;; 76;; The syntactic pass places `face' text properties in the buffer according to 77;; syntactic context, i.e., according to the buffer's syntax table and buffer 78;; text's `syntax-table' text properties. It involves using a syntax parsing 79;; function to determine the context of different parts of a region of text. A 80;; syntax parsing function is necessary because generally strings and/or 81;; comments can span lines, and so the context of a given region is not 82;; necessarily apparent from the content of that region. Because the keyword 83;; pass only works within a given region, it is not generally appropriate for 84;; syntactic fontification. This is the first fontification pass that makes 85;; changes visible to the user; it fontifies strings and comments. 86;; 87;; The keyword pass places `face' text properties in the buffer according to 88;; the variable `font-lock-keywords'. It involves searching for given regexps 89;; (or calling given search functions) within the given region. This is the 90;; second fontification pass that makes changes visible to the user; it 91;; fontifies language reserved words, etc. 92;; 93;; Oh, and the answer is, "Yes, obviously just about everything should be done 94;; in a single syntactic pass, but the only syntactic parser available 95;; understands only strings and comments." Perhaps one day someone will write 96;; some syntactic parsers for common languages and a son-of-font-lock.el could 97;; use them rather then relying so heavily on the keyword (regexp) pass. 98 99;;; How Font Lock mode supports modes or is supported by modes: 100 101;; Modes that support Font Lock mode do so by defining one or more variables 102;; whose values specify the fontification. Font Lock mode knows of these 103;; variable names from (a) the buffer local variable `font-lock-defaults', if 104;; non-nil, or (b) the global variable `font-lock-defaults-alist', if the major 105;; mode has an entry. (Font Lock mode is set up via (a) where a mode's 106;; patterns are distributed with the mode's package library, and (b) where a 107;; mode's patterns are distributed with font-lock.el itself. An example of (a) 108;; is Pascal mode, an example of (b) is Lisp mode. Normally, the mechanism is 109;; (a); (b) is used where it is not clear which package library should contain 110;; the pattern definitions.) Font Lock mode chooses which variable to use for 111;; fontification based on `font-lock-maximum-decoration'. 112;; 113;; Font Lock mode fontification behaviour can be modified in a number of ways. 114;; See the below comments and the comments distributed throughout this file. 115 116;;; Constructing patterns: 117 118;; See the documentation for the variable `font-lock-keywords'. 119;; 120;; Efficient regexps for use as MATCHERs for `font-lock-keywords' and 121;; `font-lock-syntactic-keywords' can be generated via the function 122;; `regexp-opt'. 123 124;;; Adding patterns for modes that already support Font Lock: 125 126;; Though Font Lock highlighting patterns already exist for many modes, it's 127;; likely there's something that you want fontified that currently isn't, even 128;; at the maximum fontification level. You can add highlighting patterns via 129;; `font-lock-add-keywords'. For example, say in some C 130;; header file you #define the token `and' to expand to `&&', etc., to make 131;; your C code almost readable. In your ~/.emacs there could be: 132;; 133;; (font-lock-add-keywords 'c-mode '("\\<\\(and\\|or\\|not\\)\\>")) 134;; 135;; Some modes provide specific ways to modify patterns based on the values of 136;; other variables. For example, additional C types can be specified via the 137;; variable `c-font-lock-extra-types'. 138 139;;; Adding patterns for modes that do not support Font Lock: 140 141;; Not all modes support Font Lock mode. If you (as a user of the mode) add 142;; patterns for a new mode, you must define in your ~/.emacs a variable or 143;; variables that specify regexp fontification. Then, you should indicate to 144;; Font Lock mode, via the mode hook setting `font-lock-defaults', exactly what 145;; support is required. For example, say Foo mode should have the following 146;; regexps fontified case-sensitively, and comments and strings should not be 147;; fontified automagically. In your ~/.emacs there could be: 148;; 149;; (defvar foo-font-lock-keywords 150;; '(("\\<\\(one\\|two\\|three\\)\\>" . font-lock-keyword-face) 151;; ("\\<\\(four\\|five\\|six\\)\\>" . font-lock-type-face)) 152;; "Default expressions to highlight in Foo mode.") 153;; 154;; (add-hook 'foo-mode-hook 155;; (lambda () 156;; (set (make-local-variable 'font-lock-defaults) 157;; '(foo-font-lock-keywords t)))) 158 159;;; Adding Font Lock support for modes: 160 161;; Of course, it would be better that the mode already supports Font Lock mode. 162;; The package author would do something similar to above. The mode must 163;; define at the top-level a variable or variables that specify regexp 164;; fontification. Then, the mode command should indicate to Font Lock mode, 165;; via `font-lock-defaults', exactly what support is required. For example, 166;; say Bar mode should have the following regexps fontified case-insensitively, 167;; and comments and strings should be fontified automagically. In bar.el there 168;; could be: 169;; 170;; (defvar bar-font-lock-keywords 171;; '(("\\<\\(uno\\|due\\|tre\\)\\>" . font-lock-keyword-face) 172;; ("\\<\\(quattro\\|cinque\\|sei\\)\\>" . font-lock-type-face)) 173;; "Default expressions to highlight in Bar mode.") 174;; 175;; and within `bar-mode' there could be: 176;; 177;; (set (make-local-variable 'font-lock-defaults) 178;; '(bar-font-lock-keywords nil t)) 179 180;; What is fontification for? You might say, "It's to make my code look nice." 181;; I think it should be for adding information in the form of cues. These cues 182;; should provide you with enough information to both (a) distinguish between 183;; different items, and (b) identify the item meanings, without having to read 184;; the items and think about it. Therefore, fontification allows you to think 185;; less about, say, the structure of code, and more about, say, why the code 186;; doesn't work. Or maybe it allows you to think less and drift off to sleep. 187;; 188;; So, here are my opinions/advice/guidelines: 189;; 190;; - Highlight conceptual objects, such as function and variable names, and 191;; different objects types differently, i.e., (a) and (b) above, highlight 192;; function names differently to variable names. 193;; - Keep the faces distinct from each other as far as possible. 194;; i.e., (a) above. 195;; - Use the same face for the same conceptual object, across all modes. 196;; i.e., (b) above, all modes that have items that can be thought of as, say, 197;; keywords, should be highlighted with the same face, etc. 198;; - Make the face attributes fit the concept as far as possible. 199;; i.e., function names might be a bold colour such as blue, comments might 200;; be a bright colour such as red, character strings might be brown, because, 201;; err, strings are brown (that was not the reason, please believe me). 202;; - Don't use a non-nil OVERRIDE unless you have a good reason. 203;; Only use OVERRIDE for special things that are easy to define, such as the 204;; way `...' quotes are treated in strings and comments in Emacs Lisp mode. 205;; Don't use it to, say, highlight keywords in commented out code or strings. 206;; - Err, that's it. 207 208;;; Code: 209 210(require 'syntax) 211 212;; Define core `font-lock' group. 213(defgroup font-lock '((jit-lock custom-group)) 214 "Font Lock mode text highlighting package." 215 :link '(custom-manual :tag "Emacs Manual" "(emacs)Font Lock") 216 :link '(custom-manual :tag "Elisp Manual" "(elisp)Font Lock Mode") 217 :group 'faces) 218 219(defgroup font-lock-faces nil 220 "Faces for highlighting text." 221 :prefix "font-lock-" 222 :group 'font-lock) 223 224(defgroup font-lock-extra-types nil 225 "Extra mode-specific type names for highlighting declarations." 226 :group 'font-lock) 227 228;; User variables. 229 230(defcustom font-lock-maximum-size 256000 231 "*Maximum size of a buffer for buffer fontification. 232Only buffers less than this can be fontified when Font Lock mode is turned on. 233If nil, means size is irrelevant. 234If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE), 235where MAJOR-MODE is a symbol or t (meaning the default). For example: 236 ((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576)) 237means that the maximum size is 250K for buffers in C or C++ modes, one megabyte 238for buffers in Rmail mode, and size is irrelevant otherwise." 239 :type '(choice (const :tag "none" nil) 240 (integer :tag "size") 241 (repeat :menu-tag "mode specific" :tag "mode specific" 242 :value ((t . nil)) 243 (cons :tag "Instance" 244 (radio :tag "Mode" 245 (const :tag "all" t) 246 (symbol :tag "name")) 247 (radio :tag "Size" 248 (const :tag "none" nil) 249 (integer :tag "size"))))) 250 :group 'font-lock) 251 252(defcustom font-lock-maximum-decoration t 253 "*Maximum decoration level for fontification. 254If nil, use the default decoration (typically the minimum available). 255If t, use the maximum decoration available. 256If a number, use that level of decoration (or if not available the maximum). 257If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL), 258where MAJOR-MODE is a symbol or t (meaning the default). For example: 259 ((c-mode . t) (c++-mode . 2) (t . 1)) 260means use the maximum decoration available for buffers in C mode, level 2 261decoration for buffers in C++ mode, and level 1 decoration otherwise." 262 :type '(choice (const :tag "default" nil) 263 (const :tag "maximum" t) 264 (integer :tag "level" 1) 265 (repeat :menu-tag "mode specific" :tag "mode specific" 266 :value ((t . t)) 267 (cons :tag "Instance" 268 (radio :tag "Mode" 269 (const :tag "all" t) 270 (symbol :tag "name")) 271 (radio :tag "Decoration" 272 (const :tag "default" nil) 273 (const :tag "maximum" t) 274 (integer :tag "level" 1))))) 275 :group 'font-lock) 276 277(defcustom font-lock-verbose 0 278 "*If non-nil, means show status messages for buffer fontification. 279If a number, only buffers greater than this size have fontification messages." 280 :type '(choice (const :tag "never" nil) 281 (other :tag "always" t) 282 (integer :tag "size")) 283 :group 'font-lock) 284 285 286;; Originally these variable values were face names such as `bold' etc. 287;; Now we create our own faces, but we keep these variables for compatibility 288;; and they give users another mechanism for changing face appearance. 289;; We now allow a FACENAME in `font-lock-keywords' to be any expression that 290;; returns a face. So the easiest thing is to continue using these variables, 291;; rather than sometimes evaling FACENAME and sometimes not. sm. 292(defvar font-lock-comment-face 'font-lock-comment-face 293 "Face name to use for comments.") 294 295(defvar font-lock-comment-delimiter-face 'font-lock-comment-delimiter-face 296 "Face name to use for comment delimiters.") 297 298(defvar font-lock-string-face 'font-lock-string-face 299 "Face name to use for strings.") 300 301(defvar font-lock-doc-face 'font-lock-doc-face 302 "Face name to use for documentation.") 303 304(defvar font-lock-keyword-face 'font-lock-keyword-face 305 "Face name to use for keywords.") 306 307(defvar font-lock-builtin-face 'font-lock-builtin-face 308 "Face name to use for builtins.") 309 310(defvar font-lock-function-name-face 'font-lock-function-name-face 311 "Face name to use for function names.") 312 313(defvar font-lock-variable-name-face 'font-lock-variable-name-face 314 "Face name to use for variable names.") 315 316(defvar font-lock-type-face 'font-lock-type-face 317 "Face name to use for type and class names.") 318 319(defvar font-lock-constant-face 'font-lock-constant-face 320 "Face name to use for constant and label names.") 321 322(defvar font-lock-warning-face 'font-lock-warning-face 323 "Face name to use for things that should stand out.") 324 325(defvar font-lock-negation-char-face 'font-lock-negation-char-face 326 "Face name to use for easy to overlook negation. 327This can be an \"!\" or the \"n\" in \"ifndef\".") 328 329(defvar font-lock-preprocessor-face 'font-lock-preprocessor-face 330 "Face name to use for preprocessor directives.") 331 332(defvar font-lock-reference-face 'font-lock-constant-face) 333(make-obsolete-variable 'font-lock-reference-face 'font-lock-constant-face) 334 335;; Fontification variables: 336 337(defvar font-lock-keywords nil 338 "A list of the keywords to highlight. 339There are two kinds of values: user-level, and compiled. 340 341A user-level keywords list is what a major mode or the user would 342set up. Normally the list would come from `font-lock-defaults'. 343through selection of a fontification level and evaluation of any 344contained expressions. You can also alter it by calling 345`font-lock-add-keywords' or `font-lock-remove-keywords' with MODE = nil. 346 347Each element in a user-level keywords list should have one of these forms: 348 349 MATCHER 350 (MATCHER . SUBEXP) 351 (MATCHER . FACENAME) 352 (MATCHER . HIGHLIGHT) 353 (MATCHER HIGHLIGHT ...) 354 (eval . FORM) 355 356where MATCHER can be either the regexp to search for, or the function name to 357call to make the search (called with one argument, the limit of the search; 358it should return non-nil, move point, and set `match-data' appropriately iff 359it succeeds; like `re-search-forward' would). 360MATCHER regexps can be generated via the function `regexp-opt'. 361 362FORM is an expression, whose value should be a keyword element, evaluated when 363the keyword is (first) used in a buffer. This feature can be used to provide a 364keyword that can only be generated when Font Lock mode is actually turned on. 365 366HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED. 367 368For highlighting single items, for example each instance of the word \"foo\", 369typically only MATCH-HIGHLIGHT is required. 370However, if an item or (typically) items are to be highlighted following the 371instance of another item (the anchor), for example each instance of the 372word \"bar\" following the word \"anchor\" then MATCH-ANCHORED may be required. 373 374MATCH-HIGHLIGHT should be of the form: 375 376 (SUBEXP FACENAME [OVERRIDE [LAXMATCH]]) 377 378SUBEXP is the number of the subexpression of MATCHER to be highlighted. 379 380FACENAME is an expression whose value is the face name to use. 381Instead of a face, FACENAME can evaluate to a property list 382of the form (face FACE PROP1 VAL1 PROP2 VAL2 ...) 383in which case all the listed text-properties will be set rather than 384just FACE. In such a case, you will most likely want to put those 385properties in `font-lock-extra-managed-props' or to override 386`font-lock-unfontify-region-function'. 387 388OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification can 389be overwritten. If `keep', only parts not already fontified are highlighted. 390If `prepend' or `append', existing fontification is merged with the new, in 391which the new or existing fontification, respectively, takes precedence. 392If LAXMATCH is non-nil, that means don't signal an error if there is 393no match for SUBEXP in MATCHER. 394 395For example, an element of the form highlights (if not already highlighted): 396 397 \"\\\\\\=<foo\\\\\\=>\" discrete occurrences of \"foo\" in the value of the 398 variable `font-lock-keyword-face'. 399 (\"fu\\\\(bar\\\\)\" . 1) substring \"bar\" within all occurrences of \"fubar\" in 400 the value of `font-lock-keyword-face'. 401 (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'. 402 (\"foo\\\\|bar\" 0 foo-bar-face t) 403 occurrences of either \"foo\" or \"bar\" in the value 404 of `foo-bar-face', even if already highlighted. 405 (fubar-match 1 fubar-face) 406 the first subexpression within all occurrences of 407 whatever the function `fubar-match' finds and matches 408 in the value of `fubar-face'. 409 410MATCH-ANCHORED should be of the form: 411 412 (MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...) 413 414where MATCHER is a regexp to search for or the function name to call to make 415the search, as for MATCH-HIGHLIGHT above, but with one exception; see below. 416PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after 417the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be 418used to initialize before, and cleanup after, MATCHER is used. Typically, 419PRE-MATCH-FORM is used to move to some position relative to the original 420MATCHER, before starting with MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might 421be used to move back, before resuming with MATCH-ANCHORED's parent's MATCHER. 422 423For example, an element of the form highlights (if not already highlighted): 424 425 (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face))) 426 427 discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent 428 discrete occurrences of \"item\" (on the same line) in the value of `item-face'. 429 (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is 430 initially searched for starting from the end of the match of \"anchor\", and 431 searching for subsequent instances of \"anchor\" resumes from where searching 432 for \"item\" concluded.) 433 434The above-mentioned exception is as follows. The limit of the MATCHER search 435defaults to the end of the line after PRE-MATCH-FORM is evaluated. 436However, if PRE-MATCH-FORM returns a position greater than the position after 437PRE-MATCH-FORM is evaluated, that position is used as the limit of the search. 438It is generally a bad idea to return a position greater than the end of the 439line, i.e., cause the MATCHER search to span lines. 440 441These regular expressions can match text which spans lines, although 442it is better to avoid it if possible since updating them while editing 443text is slower, and it is not guaranteed to be always correct when using 444support modes like jit-lock or lazy-lock. 445 446This variable is set by major modes via the variable `font-lock-defaults'. 447Be careful when composing regexps for this list; a poorly written pattern can 448dramatically slow things down! 449 450A compiled keywords list starts with t. It is produced internal 451by `font-lock-compile-keywords' from a user-level keywords list. 452Its second element is the user-level keywords list that was 453compiled. The remaining elements have the same form as 454user-level keywords, but normally their values have been 455optimized.") 456 457(defvar font-lock-keywords-alist nil 458 "Alist of additional `font-lock-keywords' elements for major modes. 459 460Each element has the form (MODE KEYWORDS . HOW). 461`font-lock-set-defaults' adds the elements in the list KEYWORDS to 462`font-lock-keywords' when Font Lock is turned on in major mode MODE. 463 464If HOW is nil, KEYWORDS are added at the beginning of 465`font-lock-keywords'. If it is `set', they are used to replace the 466value of `font-lock-keywords'. If HOW is any other non-nil value, 467they are added at the end. 468 469This is normally set via `font-lock-add-keywords' and 470`font-lock-remove-keywords'.") 471(put 'font-lock-keywords-alist 'risky-local-variable t) 472 473(defvar font-lock-removed-keywords-alist nil 474 "Alist of `font-lock-keywords' elements to be removed for major modes. 475 476Each element has the form (MODE . KEYWORDS). `font-lock-set-defaults' 477removes the elements in the list KEYWORDS from `font-lock-keywords' 478when Font Lock is turned on in major mode MODE. 479 480This is normally set via `font-lock-add-keywords' and 481`font-lock-remove-keywords'.") 482 483(defvar font-lock-keywords-only nil 484 "*Non-nil means Font Lock should not fontify comments or strings. 485This is normally set via `font-lock-defaults'.") 486 487(defvar font-lock-keywords-case-fold-search nil 488 "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive. 489This is normally set via `font-lock-defaults'.") 490(make-variable-buffer-local 'font-lock-keywords-case-fold-search) 491 492(defvar font-lock-syntactically-fontified 0 493 "Point up to which `font-lock-syntactic-keywords' has been applied. 494If nil, this is ignored, in which case the syntactic fontification may 495sometimes be slightly incorrect.") 496(make-variable-buffer-local 'font-lock-syntactically-fontified) 497 498(defvar font-lock-syntactic-face-function 499 (lambda (state) 500 (if (nth 3 state) font-lock-string-face font-lock-comment-face)) 501 "Function to determine which face to use when fontifying syntactically. 502The function is called with a single parameter (the state as returned by 503`parse-partial-sexp' at the beginning of the region to highlight) and 504should return a face. This is normally set via `font-lock-defaults'.") 505 506(defvar font-lock-syntactic-keywords nil 507 "A list of the syntactic keywords to put syntax properties on. 508The value can be the list itself, or the name of a function or variable 509whose value is the list. 510 511See `font-lock-keywords' for a description of the form of this list; 512only the differences are stated here. MATCH-HIGHLIGHT should be of the form: 513 514 (SUBEXP SYNTAX OVERRIDE LAXMATCH) 515 516where SYNTAX can be a string (as taken by `modify-syntax-entry'), a syntax 517table, a cons cell (as returned by `string-to-syntax') or an expression whose 518value is such a form. OVERRIDE cannot be `prepend' or `append'. 519 520Here are two examples of elements of `font-lock-syntactic-keywords' 521and what they do: 522 523 (\"\\\\$\\\\(#\\\\)\" 1 \".\") 524 525 gives a hash character punctuation syntax (\".\") when following a 526 dollar-sign character. Hash characters in other contexts will still 527 follow whatever the syntax table says about the hash character. 528 529 (\"\\\\('\\\\).\\\\('\\\\)\" 530 (1 \"\\\"\") 531 (2 \"\\\"\")) 532 533 gives a pair single-quotes, which surround a single character, a SYNTAX of 534 \"\\\"\" (meaning string quote syntax). Single-quote characters in other 535 contexts will not be affected. 536 537This is normally set via `font-lock-defaults'.") 538 539(defvar font-lock-syntax-table nil 540 "Non-nil means use this syntax table for fontifying. 541If this is nil, the major mode's syntax table is used. 542This is normally set via `font-lock-defaults'.") 543 544(defvar font-lock-beginning-of-syntax-function nil 545 "*Non-nil means use this function to move back outside all constructs. 546When called with no args it should move point backward to a place which 547is not in a string or comment and not within any bracket-pairs (or else, 548a place such that any bracket-pairs outside it can be ignored for Emacs 549syntax analysis and fontification). 550 551If this is nil, Font Lock uses `syntax-begin-function' to move back 552outside of any comment, string, or sexp. This variable is semi-obsolete; 553we recommend setting `syntax-begin-function' instead. 554 555This is normally set via `font-lock-defaults'.") 556 557(defvar font-lock-mark-block-function nil 558 "*Non-nil means use this function to mark a block of text. 559When called with no args it should leave point at the beginning of any 560enclosing textual block and mark at the end. 561This is normally set via `font-lock-defaults'.") 562 563(defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer 564 "Function to use for fontifying the buffer. 565This is normally set via `font-lock-defaults'.") 566 567(defvar font-lock-unfontify-buffer-function 'font-lock-default-unfontify-buffer 568 "Function to use for unfontifying the buffer. 569This is used when turning off Font Lock mode. 570This is normally set via `font-lock-defaults'.") 571 572(defvar font-lock-fontify-region-function 'font-lock-default-fontify-region 573 "Function to use for fontifying a region. 574It should take two args, the beginning and end of the region, and an optional 575third arg VERBOSE. If VERBOSE is non-nil, the function should print status 576messages. This is normally set via `font-lock-defaults'.") 577 578(defvar font-lock-unfontify-region-function 'font-lock-default-unfontify-region 579 "Function to use for unfontifying a region. 580It should take two args, the beginning and end of the region. 581This is normally set via `font-lock-defaults'.") 582 583(defvar font-lock-inhibit-thing-lock nil 584 "List of Font Lock mode related modes that should not be turned on. 585Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and 586`lazy-lock-mode'. This is normally set via `font-lock-defaults'.") 587 588(defvar font-lock-multiline nil 589 "Whether font-lock should cater to multiline keywords. 590If nil, don't try to handle multiline patterns. 591If t, always handle multiline patterns. 592If `undecided', don't try to handle multiline patterns until you see one. 593Major/minor modes can set this variable if they know which option applies.") 594 595(defvar font-lock-fontified nil) ; Whether we have fontified the buffer. 596 597;; Font Lock mode. 598 599(eval-when-compile 600 ;; 601 ;; We don't do this at the top-level as we only use non-autoloaded macros. 602 (require 'cl) 603 ;; 604 ;; Borrowed from lazy-lock.el. 605 ;; We use this to preserve or protect things when modifying text properties. 606 (defmacro save-buffer-state (varlist &rest body) 607 "Bind variables according to VARLIST and eval BODY restoring buffer state." 608 (declare (indent 1) (debug let)) 609 (let ((modified (make-symbol "modified"))) 610 `(let* ,(append varlist 611 `((,modified (buffer-modified-p)) 612 (buffer-undo-list t) 613 (inhibit-read-only t) 614 (inhibit-point-motion-hooks t) 615 (inhibit-modification-hooks t) 616 deactivate-mark 617 buffer-file-name 618 buffer-file-truename)) 619 (progn 620 ,@body) 621 (unless ,modified 622 (restore-buffer-modified-p nil))))) 623 ;; 624 ;; Shut up the byte compiler. 625 (defvar font-lock-face-attributes)) ; Obsolete but respected if set. 626 627(defun font-lock-mode-internal (arg) 628 ;; Turn on Font Lock mode. 629 (when arg 630 (add-hook 'after-change-functions 'font-lock-after-change-function t t) 631 (font-lock-set-defaults) 632 (font-lock-turn-on-thing-lock) 633 ;; Fontify the buffer if we have to. 634 (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size))) 635 (cond (font-lock-fontified 636 nil) 637 ((or (null max-size) (> max-size (buffer-size))) 638 (font-lock-fontify-buffer)) 639 (font-lock-verbose 640 (message "Fontifying %s...buffer size greater than font-lock-maximum-size" 641 (buffer-name)))))) 642 ;; Turn off Font Lock mode. 643 (unless font-lock-mode 644 (remove-hook 'after-change-functions 'font-lock-after-change-function t) 645 (font-lock-unfontify-buffer) 646 (font-lock-turn-off-thing-lock))) 647 648(defun font-lock-add-keywords (mode keywords &optional how) 649 "Add highlighting KEYWORDS for MODE. 650 651MODE should be a symbol, the major mode command name, such as `c-mode' 652or nil. If nil, highlighting keywords are added for the current buffer. 653KEYWORDS should be a list; see the variable `font-lock-keywords'. 654By default they are added at the beginning of the current highlighting list. 655If optional argument HOW is `set', they are used to replace the current 656highlighting list. If HOW is any other non-nil value, they are added at the 657end of the current highlighting list. 658 659For example: 660 661 (font-lock-add-keywords 'c-mode 662 '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend) 663 (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . font-lock-keyword-face))) 664 665adds two fontification patterns for C mode, to fontify `FIXME:' words, even in 666comments, and to fontify `and', `or' and `not' words as keywords. 667 668The above procedure will only add the keywords for C mode, not 669for modes derived from C mode. To add them for derived modes too, 670pass nil for MODE and add the call to c-mode-hook. 671 672For example: 673 674 (add-hook 'c-mode-hook 675 (lambda () 676 (font-lock-add-keywords nil 677 '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend) 678 (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . 679 font-lock-keyword-face))))) 680 681The above procedure may fail to add keywords to derived modes if 682some involved major mode does not follow the standard conventions. 683File a bug report if this happens, so the major mode can be corrected. 684 685Note that some modes have specialized support for additional patterns, e.g., 686see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types', 687`objc-font-lock-extra-types' and `java-font-lock-extra-types'." 688 (cond (mode 689 ;; If MODE is non-nil, add the KEYWORDS and HOW spec to 690 ;; `font-lock-keywords-alist' so `font-lock-set-defaults' uses them. 691 (let ((spec (cons keywords how)) cell) 692 (if (setq cell (assq mode font-lock-keywords-alist)) 693 (if (eq how 'set) 694 (setcdr cell (list spec)) 695 (setcdr cell (append (cdr cell) (list spec)))) 696 (push (list mode spec) font-lock-keywords-alist))) 697 ;; Make sure that `font-lock-removed-keywords-alist' does not 698 ;; contain the new keywords. 699 (font-lock-update-removed-keyword-alist mode keywords how)) 700 (t 701 ;; Otherwise set or add the keywords now. 702 ;; This is a no-op if it has been done already in this buffer 703 ;; for the correct major mode. 704 (font-lock-set-defaults) 705 (let ((was-compiled (eq (car font-lock-keywords) t))) 706 ;; Bring back the user-level (uncompiled) keywords. 707 (if was-compiled 708 (setq font-lock-keywords (cadr font-lock-keywords))) 709 ;; Now modify or replace them. 710 (if (eq how 'set) 711 (setq font-lock-keywords keywords) 712 (font-lock-remove-keywords nil keywords) ;to avoid duplicates 713 (let ((old (if (eq (car-safe font-lock-keywords) t) 714 (cdr font-lock-keywords) 715 font-lock-keywords))) 716 (setq font-lock-keywords (if how 717 (append old keywords) 718 (append keywords old))))) 719 ;; If the keywords were compiled before, compile them again. 720 (if was-compiled 721 (setq font-lock-keywords 722 (font-lock-compile-keywords font-lock-keywords))))))) 723 724(defun font-lock-update-removed-keyword-alist (mode keywords how) 725 "Update `font-lock-removed-keywords-alist' when adding new KEYWORDS to MODE." 726 ;; When font-lock is enabled first all keywords in the list 727 ;; `font-lock-keywords-alist' are added, then all keywords in the 728 ;; list `font-lock-removed-keywords-alist' are removed. If a 729 ;; keyword was once added, removed, and then added again it must be 730 ;; removed from the removed-keywords list. Otherwise the second add 731 ;; will not take effect. 732 (let ((cell (assq mode font-lock-removed-keywords-alist))) 733 (if cell 734 (if (eq how 'set) 735 ;; A new set of keywords is defined. Forget all about 736 ;; our old keywords that should be removed. 737 (setq font-lock-removed-keywords-alist 738 (delq cell font-lock-removed-keywords-alist)) 739 ;; Delete all previously removed keywords. 740 (dolist (kword keywords) 741 (setcdr cell (delete kword (cdr cell)))) 742 ;; Delete the mode cell if empty. 743 (if (null (cdr cell)) 744 (setq font-lock-removed-keywords-alist 745 (delq cell font-lock-removed-keywords-alist))))))) 746 747;; Written by Anders Lindgren <andersl@andersl.com>. 748;; 749;; Case study: 750;; (I) The keywords are removed from a major mode. 751;; In this case the keyword could be local (i.e. added earlier by 752;; `font-lock-add-keywords'), global, or both. 753;; 754;; (a) In the local case we remove the keywords from the variable 755;; `font-lock-keywords-alist'. 756;; 757;; (b) The actual global keywords are not known at this time. 758;; All keywords are added to `font-lock-removed-keywords-alist', 759;; when font-lock is enabled those keywords are removed. 760;; 761;; Note that added keywords are taken out of the list of removed 762;; keywords. This ensure correct operation when the same keyword 763;; is added and removed several times. 764;; 765;; (II) The keywords are removed from the current buffer. 766(defun font-lock-remove-keywords (mode keywords) 767 "Remove highlighting KEYWORDS for MODE. 768 769MODE should be a symbol, the major mode command name, such as `c-mode' 770or nil. If nil, highlighting keywords are removed for the current buffer. 771 772To make the removal apply to modes derived from MODE as well, 773pass nil for MODE and add the call to MODE-hook. This may fail 774for some derived modes if some involved major mode does not 775follow the standard conventions. File a bug report if this 776happens, so the major mode can be corrected." 777 (cond (mode 778 ;; Remove one keyword at the time. 779 (dolist (keyword keywords) 780 (let ((top-cell (assq mode font-lock-keywords-alist))) 781 ;; If MODE is non-nil, remove the KEYWORD from 782 ;; `font-lock-keywords-alist'. 783 (when top-cell 784 (dolist (keyword-list-how-pair (cdr top-cell)) 785 ;; `keywords-list-how-pair' is a cons with a list of 786 ;; keywords in the car top-cell and the original how 787 ;; argument in the cdr top-cell. 788 (setcar keyword-list-how-pair 789 (delete keyword (car keyword-list-how-pair)))) 790 ;; Remove keyword list/how pair when the keyword list 791 ;; is empty and how doesn't specify `set'. (If it 792 ;; should be deleted then previously deleted keywords 793 ;; would appear again.) 794 (let ((cell top-cell)) 795 (while (cdr cell) 796 (if (and (null (car (car (cdr cell)))) 797 (not (eq (cdr (car (cdr cell))) 'set))) 798 (setcdr cell (cdr (cdr cell))) 799 (setq cell (cdr cell))))) 800 ;; Final cleanup, remove major mode cell if last keyword 801 ;; was deleted. 802 (if (null (cdr top-cell)) 803 (setq font-lock-keywords-alist 804 (delq top-cell font-lock-keywords-alist)))) 805 ;; Remember the keyword in case it is not local. 806 (let ((cell (assq mode font-lock-removed-keywords-alist))) 807 (if cell 808 (unless (member keyword (cdr cell)) 809 (nconc cell (list keyword))) 810 (push (cons mode (list keyword)) 811 font-lock-removed-keywords-alist)))))) 812 (t 813 ;; Otherwise remove it immediately. 814 (font-lock-set-defaults) 815 (let ((was-compiled (eq (car font-lock-keywords) t))) 816 ;; Bring back the user-level (uncompiled) keywords. 817 (if was-compiled 818 (setq font-lock-keywords (cadr font-lock-keywords))) 819 820 ;; Edit them. 821 (setq font-lock-keywords (copy-sequence font-lock-keywords)) 822 (dolist (keyword keywords) 823 (setq font-lock-keywords 824 (delete keyword font-lock-keywords))) 825 826 ;; If the keywords were compiled before, compile them again. 827 (if was-compiled 828 (setq font-lock-keywords 829 (font-lock-compile-keywords font-lock-keywords))))))) 830 831;;; Font Lock Support mode. 832 833;; This is the code used to interface font-lock.el with any of its add-on 834;; packages, and provide the user interface. Packages that have their own 835;; local buffer fontification functions (see below) may have to call 836;; `font-lock-after-fontify-buffer' and/or `font-lock-after-unfontify-buffer' 837;; themselves. 838 839(defcustom font-lock-support-mode 'jit-lock-mode 840 "*Support mode for Font Lock mode. 841Support modes speed up Font Lock mode by being choosy about when fontification 842occurs. The default support mode, Just-in-time Lock mode (symbol 843`jit-lock-mode'), is recommended. 844 845Other, older support modes are Fast Lock mode (symbol `fast-lock-mode') and 846Lazy Lock mode (symbol `lazy-lock-mode'). See those modes for more info. 847However, they are no longer recommended, as Just-in-time Lock mode is better. 848 849If nil, means support for Font Lock mode is never performed. 850If a symbol, use that support mode. 851If a list, each element should be of the form (MAJOR-MODE . SUPPORT-MODE), 852where MAJOR-MODE is a symbol or t (meaning the default). For example: 853 ((c-mode . fast-lock-mode) (c++-mode . fast-lock-mode) (t . lazy-lock-mode)) 854means that Fast Lock mode is used to support Font Lock mode for buffers in C or 855C++ modes, and Lazy Lock mode is used to support Font Lock mode otherwise. 856 857The value of this variable is used when Font Lock mode is turned on." 858 :type '(choice (const :tag "none" nil) 859 (const :tag "fast lock" fast-lock-mode) 860 (const :tag "lazy lock" lazy-lock-mode) 861 (const :tag "jit lock" jit-lock-mode) 862 (repeat :menu-tag "mode specific" :tag "mode specific" 863 :value ((t . jit-lock-mode)) 864 (cons :tag "Instance" 865 (radio :tag "Mode" 866 (const :tag "all" t) 867 (symbol :tag "name")) 868 (radio :tag "Support" 869 (const :tag "none" nil) 870 (const :tag "fast lock" fast-lock-mode) 871 (const :tag "lazy lock" lazy-lock-mode) 872 (const :tag "JIT lock" jit-lock-mode))) 873 )) 874 :version "21.1" 875 :group 'font-lock) 876 877(defvar fast-lock-mode) 878(defvar lazy-lock-mode) 879(defvar jit-lock-mode) 880 881(defun font-lock-turn-on-thing-lock () 882 (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode))) 883 (cond ((eq thing-mode 'fast-lock-mode) 884 (fast-lock-mode t)) 885 ((eq thing-mode 'lazy-lock-mode) 886 (lazy-lock-mode t)) 887 ((eq thing-mode 'jit-lock-mode) 888 ;; Prepare for jit-lock 889 (remove-hook 'after-change-functions 890 'font-lock-after-change-function t) 891 (set (make-local-variable 'font-lock-fontify-buffer-function) 892 'jit-lock-refontify) 893 ;; Don't fontify eagerly (and don't abort if the buffer is large). 894 (set (make-local-variable 'font-lock-fontified) t) 895 ;; Use jit-lock. 896 (jit-lock-register 'font-lock-fontify-region 897 (not font-lock-keywords-only)) 898 ;; Tell jit-lock how we extend the region to refontify. 899 (add-hook 'jit-lock-after-change-extend-region-functions 900 'font-lock-extend-jit-lock-region-after-change 901 nil t))))) 902 903(defun font-lock-turn-off-thing-lock () 904 (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) 905 (fast-lock-mode -1)) 906 ((and (boundp 'jit-lock-mode) jit-lock-mode) 907 (jit-lock-unregister 'font-lock-fontify-region) 908 ;; Reset local vars to the non-jit-lock case. 909 (kill-local-variable 'font-lock-fontify-buffer-function)) 910 ((and (boundp 'lazy-lock-mode) lazy-lock-mode) 911 (lazy-lock-mode -1)))) 912 913(defun font-lock-after-fontify-buffer () 914 (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) 915 (fast-lock-after-fontify-buffer)) 916 ;; Useless now that jit-lock intercepts font-lock-fontify-buffer. -sm 917 ;; (jit-lock-mode 918 ;; (jit-lock-after-fontify-buffer)) 919 ((and (boundp 'lazy-lock-mode) lazy-lock-mode) 920 (lazy-lock-after-fontify-buffer)))) 921 922(defun font-lock-after-unfontify-buffer () 923 (cond ((and (boundp 'fast-lock-mode) fast-lock-mode) 924 (fast-lock-after-unfontify-buffer)) 925 ;; Useless as well. It's only called when: 926 ;; - turning off font-lock: it does not matter if we leave spurious 927 ;; `fontified' text props around since jit-lock-mode is also off. 928 ;; - font-lock-default-fontify-buffer fails: this is not run 929 ;; any more anyway. -sm 930 ;; 931 ;; (jit-lock-mode 932 ;; (jit-lock-after-unfontify-buffer)) 933 ((and (boundp 'lazy-lock-mode) lazy-lock-mode) 934 (lazy-lock-after-unfontify-buffer)))) 935 936;;; End of Font Lock Support mode. 937 938;;; Fontification functions. 939 940;; Rather than the function, e.g., `font-lock-fontify-region' containing the 941;; code to fontify a region, the function runs the function whose name is the 942;; value of the variable, e.g., `font-lock-fontify-region-function'. Normally, 943;; the value of this variable is, e.g., `font-lock-default-fontify-region' 944;; which does contain the code to fontify a region. However, the value of the 945;; variable could be anything and thus, e.g., `font-lock-fontify-region' could 946;; do anything. The indirection of the fontification functions gives major 947;; modes the capability of modifying the way font-lock.el fontifies. Major 948;; modes can modify the values of, e.g., `font-lock-fontify-region-function', 949;; via the variable `font-lock-defaults'. 950;; 951;; For example, Rmail mode sets the variable `font-lock-defaults' so that 952;; font-lock.el uses its own function for buffer fontification. This function 953;; makes fontification be on a message-by-message basis and so visiting an 954;; RMAIL file is much faster. A clever implementation of the function might 955;; fontify the headers differently than the message body. (It should, and 956;; correspondingly for Mail mode, but I can't be bothered to do the work. Can 957;; you?) This hints at a more interesting use... 958;; 959;; Languages that contain text normally contained in different major modes 960;; could define their own fontification functions that treat text differently 961;; depending on its context. For example, Perl mode could arrange that here 962;; docs are fontified differently than Perl code. Or Yacc mode could fontify 963;; rules one way and C code another. Neat! 964;; 965;; A further reason to use the fontification indirection feature is when the 966;; default syntactual fontification, or the default fontification in general, 967;; is not flexible enough for a particular major mode. For example, perhaps 968;; comments are just too hairy for `font-lock-fontify-syntactically-region' to 969;; cope with. You need to write your own version of that function, e.g., 970;; `hairy-fontify-syntactically-region', and make your own version of 971;; `hairy-fontify-region' call that function before calling 972;; `font-lock-fontify-keywords-region' for the normal regexp fontification 973;; pass. And Hairy mode would set `font-lock-defaults' so that font-lock.el 974;; would call your region fontification function instead of its own. For 975;; example, TeX modes could fontify {\foo ...} and \bar{...} etc. multi-line 976;; directives correctly and cleanly. (It is the same problem as fontifying 977;; multi-line strings and comments; regexps are not appropriate for the job.) 978 979(defvar font-lock-extend-after-change-region-function nil 980 "A function that determines the region to refontify after a change. 981 982This variable is either nil, or is a function that determines the 983region to refontify after a change. 984It is usually set by the major mode via `font-lock-defaults'. 985Font-lock calls this function after each buffer change. 986 987The function is given three parameters, the standard BEG, END, and OLD-LEN 988from `after-change-functions'. It should return either a cons of the beginning 989and end buffer positions \(in that order) of the region to refontify, or nil 990\(which directs the caller to fontify a default region). 991This function should preserve the match-data. 992The region it returns may start or end in the middle of a line.") 993 994(defun font-lock-fontify-buffer () 995 "Fontify the current buffer the way the function `font-lock-mode' would." 996 (interactive) 997 (font-lock-set-defaults) 998 (let ((font-lock-verbose (or font-lock-verbose (interactive-p)))) 999 (funcall font-lock-fontify-buffer-function))) 1000 1001(defun font-lock-unfontify-buffer () 1002 (funcall font-lock-unfontify-buffer-function)) 1003 1004(defun font-lock-fontify-region (beg end &optional loudly) 1005 (font-lock-set-defaults) 1006 (funcall font-lock-fontify-region-function beg end loudly)) 1007 1008(defun font-lock-unfontify-region (beg end) 1009 (save-buffer-state nil 1010 (funcall font-lock-unfontify-region-function beg end))) 1011 1012(defun font-lock-default-fontify-buffer () 1013 (let ((verbose (if (numberp font-lock-verbose) 1014 (> (buffer-size) font-lock-verbose) 1015 font-lock-verbose))) 1016 (with-temp-message 1017 (when verbose 1018 (format "Fontifying %s..." (buffer-name))) 1019 ;; Make sure we fontify etc. in the whole buffer. 1020 (save-restriction 1021 (widen) 1022 (condition-case nil 1023 (save-excursion 1024 (save-match-data 1025 (font-lock-fontify-region (point-min) (point-max) verbose) 1026 (font-lock-after-fontify-buffer) 1027 (setq font-lock-fontified t))) 1028 ;; We don't restore the old fontification, so it's best to unfontify. 1029 (quit (font-lock-unfontify-buffer))))))) 1030 1031(defun font-lock-default-unfontify-buffer () 1032 ;; Make sure we unfontify etc. in the whole buffer. 1033 (save-restriction 1034 (widen) 1035 (font-lock-unfontify-region (point-min) (point-max)) 1036 (font-lock-after-unfontify-buffer) 1037 (setq font-lock-fontified nil))) 1038 1039(defvar font-lock-dont-widen nil 1040 "If non-nil, font-lock will work on the non-widened buffer. 1041Useful for things like RMAIL and Info where the whole buffer is not 1042a very meaningful entity to highlight.") 1043 1044 1045(defvar font-lock-beg) (defvar font-lock-end) 1046(defvar font-lock-extend-region-functions 1047 '(font-lock-extend-region-wholelines 1048 ;; This use of font-lock-multiline property is unreliable but is just 1049 ;; a handy heuristic: in case you don't have a function that does 1050 ;; /identification/ of multiline elements, you may still occasionally 1051 ;; discover them by accident (or you may /identify/ them but not in all 1052 ;; cases), in which case the font-lock-multiline property can help make 1053 ;; sure you will properly *re*identify them during refontification. 1054 font-lock-extend-region-multiline) 1055 "Special hook run just before proceeding to fontify a region. 1056This is used to allow major modes to help font-lock find safe buffer positions 1057as beginning and end of the fontified region. Its most common use is to solve 1058the problem of /identification/ of multiline elements by providing a function 1059that tries to find such elements and move the boundaries such that they do 1060not fall in the middle of one. 1061Each function is called with no argument; it is expected to adjust the 1062dynamically bound variables `font-lock-beg' and `font-lock-end'; and return 1063non-nil iff it did make such an adjustment. 1064These functions are run in turn repeatedly until they all return nil. 1065Put first the functions more likely to cause a change and cheaper to compute.") 1066;; Mark it as a special hook which doesn't use any global setting 1067;; (i.e. doesn't obey the element t in the buffer-local value). 1068(make-variable-buffer-local 'font-lock-extend-region-functions) 1069 1070(defun font-lock-extend-region-multiline () 1071 "Move fontification boundaries away from any `font-lock-multiline' property." 1072 (let ((changed nil)) 1073 (when (and (> font-lock-beg (point-min)) 1074 (get-text-property (1- font-lock-beg) 'font-lock-multiline)) 1075 (setq changed t) 1076 (setq font-lock-beg (or (previous-single-property-change 1077 font-lock-beg 'font-lock-multiline) 1078 (point-min)))) 1079 ;; 1080 (when (get-text-property font-lock-end 'font-lock-multiline) 1081 (setq changed t) 1082 (setq font-lock-end (or (text-property-any font-lock-end (point-max) 1083 'font-lock-multiline nil) 1084 (point-max)))) 1085 changed)) 1086 1087(defun font-lock-extend-region-wholelines () 1088 "Move fontification boundaries to beginning of lines." 1089 (let ((changed nil)) 1090 (goto-char font-lock-beg) 1091 (unless (bolp) 1092 (setq changed t font-lock-beg (line-beginning-position))) 1093 (goto-char font-lock-end) 1094 (unless (bolp) 1095 (unless (eq font-lock-end 1096 (setq font-lock-end (line-beginning-position 2))) 1097 (setq changed t))) 1098 changed)) 1099 1100(defun font-lock-default-fontify-region (beg end loudly) 1101 (save-buffer-state 1102 ((parse-sexp-lookup-properties 1103 (or parse-sexp-lookup-properties font-lock-syntactic-keywords)) 1104 (old-syntax-table (syntax-table))) 1105 (unwind-protect 1106 (save-restriction 1107 (unless font-lock-dont-widen (widen)) 1108 ;; Use the fontification syntax table, if any. 1109 (when font-lock-syntax-table 1110 (set-syntax-table font-lock-syntax-table)) 1111 ;; Extend the region to fontify so that it starts and ends at 1112 ;; safe places. 1113 (let ((funs font-lock-extend-region-functions) 1114 (font-lock-beg beg) 1115 (font-lock-end end)) 1116 (while funs 1117 (setq funs (if (or (not (funcall (car funs))) 1118 (eq funs font-lock-extend-region-functions)) 1119 (cdr funs) 1120 ;; If there's been a change, we should go through 1121 ;; the list again since this new position may 1122 ;; warrant a different answer from one of the fun 1123 ;; we've already seen. 1124 font-lock-extend-region-functions))) 1125 (setq beg font-lock-beg end font-lock-end)) 1126 ;; Now do the fontification. 1127 (font-lock-unfontify-region beg end) 1128 (when font-lock-syntactic-keywords 1129 (font-lock-fontify-syntactic-keywords-region beg end)) 1130 (unless font-lock-keywords-only 1131 (font-lock-fontify-syntactically-region beg end loudly)) 1132 (font-lock-fontify-keywords-region beg end loudly)) 1133 ;; Clean up. 1134 (set-syntax-table old-syntax-table)))) 1135 1136;; The following must be rethought, since keywords can override fontification. 1137;; ;; Now scan for keywords, but not if we are inside a comment now. 1138;; (or (and (not font-lock-keywords-only) 1139;; (let ((state (parse-partial-sexp beg end nil nil 1140;; font-lock-cache-state))) 1141;; (or (nth 4 state) (nth 7 state)))) 1142;; (font-lock-fontify-keywords-region beg end)) 1143 1144(defvar font-lock-extra-managed-props nil 1145 "Additional text properties managed by font-lock. 1146This is used by `font-lock-default-unfontify-region' to decide 1147what properties to clear before refontifying a region.") 1148 1149(defun font-lock-default-unfontify-region (beg end) 1150 (remove-list-of-text-properties 1151 beg end (append 1152 font-lock-extra-managed-props 1153 (if font-lock-syntactic-keywords 1154 '(syntax-table face font-lock-multiline) 1155 '(face font-lock-multiline))))) 1156 1157;; Called when any modification is made to buffer text. 1158(defun font-lock-after-change-function (beg end old-len) 1159 (save-excursion 1160 (let ((inhibit-point-motion-hooks t) 1161 (inhibit-quit t) 1162 (region (if font-lock-extend-after-change-region-function 1163 (funcall font-lock-extend-after-change-region-function 1164 beg end old-len)))) 1165 (save-match-data 1166 (if region 1167 ;; Fontify the region the major mode has specified. 1168 (setq beg (car region) end (cdr region)) 1169 ;; Fontify the whole lines which enclose the region. 1170 ;; Actually, this is not needed because 1171 ;; font-lock-default-fontify-region already rounds up to a whole 1172 ;; number of lines. 1173 ;; (setq beg (progn (goto-char beg) (line-beginning-position)) 1174 ;; end (progn (goto-char end) (line-beginning-position 2))) 1175 (unless (eq end (point-max)) 1176 ;; Rounding up to a whole number of lines should include the 1177 ;; line right after `end'. Typical case: the first char of 1178 ;; the line was deleted. Or a \n was inserted in the middle 1179 ;; of a line. 1180 (setq end (1+ end)))) 1181 (font-lock-fontify-region beg end))))) 1182 1183(defvar jit-lock-start) (defvar jit-lock-end) 1184(defun font-lock-extend-jit-lock-region-after-change (beg end old-len) 1185 "Function meant for `jit-lock-after-change-extend-region-functions'. 1186This function does 2 things: 1187- extend the region so that it not only includes the part that was modified 1188 but also the surrounding text whose highlighting may change as a consequence. 1189- anticipate (part of) the region extension that will happen later in 1190 `font-lock-default-fontify-region', in order to avoid the need for 1191 double-redisplay in `jit-lock-fontify-now'." 1192 (save-excursion 1193 ;; First extend the region as font-lock-after-change-function would. 1194 (let ((region (if font-lock-extend-after-change-region-function 1195 (funcall font-lock-extend-after-change-region-function 1196 beg end old-len)))) 1197 (if region 1198 (setq beg (min jit-lock-start (car region)) 1199 end (max jit-lock-end (cdr region)))) 1200 ;; Then extend the region obeying font-lock-multiline properties, 1201 ;; indicating which part of the buffer needs to be refontified. 1202 ;; !!! This is the *main* user of font-lock-multiline property !!! 1203 ;; font-lock-after-change-function could/should also do that, but it 1204 ;; doesn't need to because font-lock-default-fontify-region does 1205 ;; it anyway. Here OTOH we have no guarantee that 1206 ;; font-lock-default-fontify-region will be executed on this region 1207 ;; any time soon. 1208 ;; Note: contrary to font-lock-default-fontify-region, we do not do 1209 ;; any loop here because we are not looking for a safe spot: we just 1210 ;; mark the text whose appearance may need to change as a result of 1211 ;; the buffer modification. 1212 (when (and (> beg (point-min)) 1213 (get-text-property (1- beg) 'font-lock-multiline)) 1214 (setq beg (or (previous-single-property-change 1215 beg 'font-lock-multiline) 1216 (point-min)))) 1217 (when (< end (point-max)) 1218 (setq end 1219 (if (get-text-property end 'font-lock-multiline) 1220 (or (text-property-any end (point-max) 1221 'font-lock-multiline nil) 1222 (point-max)) 1223 ;; Rounding up to a whole number of lines should include the 1224 ;; line right after `end'. Typical case: the first char of 1225 ;; the line was deleted. Or a \n was inserted in the middle 1226 ;; of a line. 1227 (1+ end)))) 1228 ;; Finally, pre-enlarge the region to a whole number of lines, to try 1229 ;; and anticipate what font-lock-default-fontify-region will do, so as to 1230 ;; avoid double-redisplay. 1231 ;; We could just run `font-lock-extend-region-functions', but since 1232 ;; the only purpose is to avoid the double-redisplay, we prefer to 1233 ;; do here only the part that is cheap and most likely to be useful. 1234 (when (memq 'font-lock-extend-region-wholelines 1235 font-lock-extend-region-functions) 1236 (goto-char beg) 1237 (setq jit-lock-start (min jit-lock-start (line-beginning-position))) 1238 (goto-char end) 1239 (setq jit-lock-end 1240 (max jit-lock-end 1241 (if (bolp) (point) (line-beginning-position 2)))))))) 1242 1243(defun font-lock-fontify-block (&optional arg) 1244 "Fontify some lines the way `font-lock-fontify-buffer' would. 1245The lines could be a function or paragraph, or a specified number of lines. 1246If ARG is given, fontify that many lines before and after point, or 16 lines if 1247no ARG is given and `font-lock-mark-block-function' is nil. 1248If `font-lock-mark-block-function' non-nil and no ARG is given, it is used to 1249delimit the region to fontify." 1250 (interactive "P") 1251 (let ((inhibit-point-motion-hooks t) font-lock-beginning-of-syntax-function 1252 deactivate-mark) 1253 ;; Make sure we have the right `font-lock-keywords' etc. 1254 (if (not font-lock-mode) (font-lock-set-defaults)) 1255 (save-excursion 1256 (save-match-data 1257 (condition-case error-data 1258 (if (or arg (not font-lock-mark-block-function)) 1259 (let ((lines (if arg (prefix-numeric-value arg) 16))) 1260 (font-lock-fontify-region 1261 (save-excursion (forward-line (- lines)) (point)) 1262 (save-excursion (forward-line lines) (point)))) 1263 (funcall font-lock-mark-block-function) 1264 (font-lock-fontify-region (point) (mark))) 1265 ((error quit) (message "Fontifying block...%s" error-data))))))) 1266 1267(unless (featurep 'facemenu) 1268 (error "facemenu must be loaded before font-lock")) 1269(define-key facemenu-keymap "\M-o" 'font-lock-fontify-block) 1270 1271;;; End of Fontification functions. 1272 1273;;; Additional text property functions. 1274 1275;; The following text property functions should be builtins. This means they 1276;; should be written in C and put with all the other text property functions. 1277;; In the meantime, those that are used by font-lock.el are defined in Lisp 1278;; below and given a `font-lock-' prefix. Those that are not used are defined 1279;; in Lisp below and commented out. sm. 1280 1281(defun font-lock-prepend-text-property (start end prop value &optional object) 1282 "Prepend to one property of the text from START to END. 1283Arguments PROP and VALUE specify the property and value to prepend to the value 1284already in place. The resulting property values are always lists. 1285Optional argument OBJECT is the string or buffer containing the text." 1286 (let ((val (if (listp value) value (list value))) next prev) 1287 (while (/= start end) 1288 (setq next (next-single-property-change start prop object end) 1289 prev (get-text-property start prop object)) 1290 (put-text-property start next prop 1291 (append val (if (listp prev) prev (list prev))) 1292 object) 1293 (setq start next)))) 1294 1295(defun font-lock-append-text-property (start end prop value &optional object) 1296 "Append to one property of the text from START to END. 1297Arguments PROP and VALUE specify the property and value to append to the value 1298already in place. The resulting property values are always lists. 1299Optional argument OBJECT is the string or buffer containing the text." 1300 (let ((val (if (listp value) value (list value))) next prev) 1301 (while (/= start end) 1302 (setq next (next-single-property-change start prop object end) 1303 prev (get-text-property start prop object)) 1304 (put-text-property start next prop 1305 (append (if (listp prev) prev (list prev)) val) 1306 object) 1307 (setq start next)))) 1308 1309(defun font-lock-fillin-text-property (start end prop value &optional object) 1310 "Fill in one property of the text from START to END. 1311Arguments PROP and VALUE specify the property and value to put where none are 1312already in place. Therefore existing property values are not overwritten. 1313Optional argument OBJECT is the string or buffer containing the text." 1314 (let ((start (text-property-any start end prop nil object)) next) 1315 (while start 1316 (setq next (next-single-property-change start prop object end)) 1317 (put-text-property start next prop value object) 1318 (setq start (text-property-any next end prop nil object))))) 1319 1320;; For completeness: this is to `remove-text-properties' as `put-text-property' 1321;; is to `add-text-properties', etc. 1322;;(defun remove-text-property (start end property &optional object) 1323;; "Remove a property from text from START to END. 1324;;Argument PROPERTY is the property to remove. 1325;;Optional argument OBJECT is the string or buffer containing the text. 1326;;Return t if the property was actually removed, nil otherwise." 1327;; (remove-text-properties start end (list property) object)) 1328 1329;; For consistency: maybe this should be called `remove-single-property' like 1330;; `next-single-property-change' (not `next-single-text-property-change'), etc. 1331;;(defun remove-single-text-property (start end prop value &optional object) 1332;; "Remove a specific property value from text from START to END. 1333;;Arguments PROP and VALUE specify the property and value to remove. The 1334;;resulting property values are not equal to VALUE nor lists containing VALUE. 1335;;Optional argument OBJECT is the string or buffer containing the text." 1336;; (let ((start (text-property-not-all start end prop nil object)) next prev) 1337;; (while start 1338;; (setq next (next-single-property-change start prop object end) 1339;; prev (get-text-property start prop object)) 1340;; (cond ((and (symbolp prev) (eq value prev)) 1341;; (remove-text-property start next prop object)) 1342;; ((and (listp prev) (memq value prev)) 1343;; (let ((new (delq value prev))) 1344;; (cond ((null new) 1345;; (remove-text-property start next prop object)) 1346;; ((= (length new) 1) 1347;; (put-text-property start next prop (car new) object)) 1348;; (t 1349;; (put-text-property start next prop new object)))))) 1350;; (setq start (text-property-not-all next end prop nil object))))) 1351 1352;;; End of Additional text property functions. 1353 1354;;; Syntactic regexp fontification functions. 1355 1356;; These syntactic keyword pass functions are identical to those keyword pass 1357;; functions below, with the following exceptions; (a) they operate on 1358;; `font-lock-syntactic-keywords' of course, (b) they are all `defun' as speed 1359;; is less of an issue, (c) eval of property value does not occur JIT as speed 1360;; is less of an issue, (d) OVERRIDE cannot be `prepend' or `append' as it 1361;; makes no sense for `syntax-table' property values, (e) they do not do it 1362;; LOUDLY as it is not likely to be intensive. 1363 1364(defun font-lock-apply-syntactic-highlight (highlight) 1365 "Apply HIGHLIGHT following a match. 1366HIGHLIGHT should be of the form MATCH-HIGHLIGHT, 1367see `font-lock-syntactic-keywords'." 1368 (let* ((match (nth 0 highlight)) 1369 (start (match-beginning match)) (end (match-end match)) 1370 (value (nth 1 highlight)) 1371 (override (nth 2 highlight))) 1372 (if (not start) 1373 ;; No match but we might not signal an error. 1374 (or (nth 3 highlight) 1375 (error "No match %d in highlight %S" match highlight)) 1376 (when (and (consp value) (not (numberp (car value)))) 1377 (setq value (eval value))) 1378 (when (stringp value) (setq value (string-to-syntax value))) 1379 ;; Flush the syntax-cache. I believe this is not necessary for 1380 ;; font-lock's use of syntax-ppss, but I'm not 100% sure and it can 1381 ;; still be necessary for other users of syntax-ppss anyway. 1382 (syntax-ppss-after-change-function start) 1383 (cond 1384 ((not override) 1385 ;; Cannot override existing fontification. 1386 (or (text-property-not-all start end 'syntax-table nil) 1387 (put-text-property start end 'syntax-table value))) 1388 ((eq override t) 1389 ;; Override existing fontification. 1390 (put-text-property start end 'syntax-table value)) 1391 ((eq override 'keep) 1392 ;; Keep existing fontification. 1393 (font-lock-fillin-text-property start end 'syntax-table value)))))) 1394 1395(defun font-lock-fontify-syntactic-anchored-keywords (keywords limit) 1396 "Fontify according to KEYWORDS until LIMIT. 1397KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords', 1398LIMIT can be modified by the value of its PRE-MATCH-FORM." 1399 (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights 1400 ;; Evaluate PRE-MATCH-FORM. 1401 (pre-match-value (eval (nth 1 keywords)))) 1402 ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line. 1403 (if (and (numberp pre-match-value) (> pre-match-value (point))) 1404 (setq limit pre-match-value) 1405 (setq limit (line-end-position))) 1406 (save-match-data 1407 ;; Find an occurrence of `matcher' before `limit'. 1408 (while (if (stringp matcher) 1409 (re-search-forward matcher limit t) 1410 (funcall matcher limit)) 1411 ;; Apply each highlight to this instance of `matcher'. 1412 (setq highlights lowdarks) 1413 (while highlights 1414 (font-lock-apply-syntactic-highlight (car highlights)) 1415 (setq highlights (cdr highlights))))) 1416 ;; Evaluate POST-MATCH-FORM. 1417 (eval (nth 2 keywords)))) 1418 1419(defun font-lock-fontify-syntactic-keywords-region (start end) 1420 "Fontify according to `font-lock-syntactic-keywords' between START and END. 1421START should be at the beginning of a line." 1422 ;; Ensure the beginning of the file is properly syntactic-fontified. 1423 (when (and font-lock-syntactically-fontified 1424 (< font-lock-syntactically-fontified start)) 1425 (setq start (max font-lock-syntactically-fontified (point-min))) 1426 (setq font-lock-syntactically-fontified end)) 1427 ;; If `font-lock-syntactic-keywords' is a symbol, get the real keywords. 1428 (when (symbolp font-lock-syntactic-keywords) 1429 (setq font-lock-syntactic-keywords (font-lock-eval-keywords 1430 font-lock-syntactic-keywords))) 1431 ;; If `font-lock-syntactic-keywords' is not compiled, compile it. 1432 (unless (eq (car font-lock-syntactic-keywords) t) 1433 (setq font-lock-syntactic-keywords (font-lock-compile-keywords 1434 font-lock-syntactic-keywords 1435 t))) 1436 ;; Get down to business. 1437 (let ((case-fold-search font-lock-keywords-case-fold-search) 1438 (keywords (cddr font-lock-syntactic-keywords)) 1439 keyword matcher highlights) 1440 (while keywords 1441 ;; Find an occurrence of `matcher' from `start' to `end'. 1442 (setq keyword (car keywords) matcher (car keyword)) 1443 (goto-char start) 1444 (while (if (stringp matcher) 1445 (re-search-forward matcher end t) 1446 (funcall matcher end)) 1447 ;; Apply each highlight to this instance of `matcher', which may be 1448 ;; specific highlights or more keywords anchored to `matcher'. 1449 (setq highlights (cdr keyword)) 1450 (while highlights 1451 (if (numberp (car (car highlights))) 1452 (font-lock-apply-syntactic-highlight (car highlights)) 1453 (font-lock-fontify-syntactic-anchored-keywords (car highlights) 1454 end)) 1455 (setq highlights (cdr highlights)))) 1456 (setq keywords (cdr keywords))))) 1457 1458;;; End of Syntactic regexp fontification functions. 1459 1460;;; Syntactic fontification functions. 1461 1462(defvar font-lock-comment-start-skip nil 1463 "If non-nil, Font Lock mode uses this instead of `comment-start-skip'.") 1464 1465(defvar font-lock-comment-end-skip nil 1466 "If non-nil, Font Lock mode uses this instead of `comment-end'.") 1467 1468(defun font-lock-fontify-syntactically-region (start end &optional loudly ppss) 1469 "Put proper face on each string and comment between START and END. 1470START should be at the beginning of a line." 1471 (let ((comment-end-regexp 1472 (or font-lock-comment-end-skip 1473 (regexp-quote 1474 (replace-regexp-in-string "^ *" "" comment-end)))) 1475 state face beg) 1476 (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name))) 1477 (goto-char start) 1478 ;; 1479 ;; Find the `start' state. 1480 (setq state (or ppss (syntax-ppss start))) 1481 ;; 1482 ;; Find each interesting place between here and `end'. 1483 (while 1484 (progn 1485 (when (or (nth 3 state) (nth 4 state)) 1486 (setq face (funcall font-lock-syntactic-face-function state)) 1487 (setq beg (max (nth 8 state) start)) 1488 (setq state (parse-partial-sexp (point) end nil nil state 1489 'syntax-table)) 1490 (when face (put-text-property beg (point) 'face face)) 1491 (when (and (eq face 'font-lock-comment-face) 1492 (or font-lock-comment-start-skip 1493 comment-start-skip)) 1494 ;; Find the comment delimiters 1495 ;; and use font-lock-comment-delimiter-face for them. 1496 (save-excursion 1497 (goto-char beg) 1498 (if (looking-at (or font-lock-comment-start-skip 1499 comment-start-skip)) 1500 (put-text-property beg (match-end 0) 'face 1501 font-lock-comment-delimiter-face))) 1502 (if (looking-back comment-end-regexp (point-at-bol) t) 1503 (put-text-property (match-beginning 0) (point) 'face 1504 font-lock-comment-delimiter-face)))) 1505 (< (point) end)) 1506 (setq state (parse-partial-sexp (point) end nil nil state 1507 'syntax-table))))) 1508 1509;;; End of Syntactic fontification functions. 1510 1511;;; Keyword regexp fontification functions. 1512 1513(defsubst font-lock-apply-highlight (highlight) 1514 "Apply HIGHLIGHT following a match. 1515HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'." 1516 (let* ((match (nth 0 highlight)) 1517 (start (match-beginning match)) (end (match-end match)) 1518 (override (nth 2 highlight))) 1519 (if (not start) 1520 ;; No match but we might not signal an error. 1521 (or (nth 3 highlight) 1522 (error "No match %d in highlight %S" match highlight)) 1523 (let ((val (eval (nth 1 highlight)))) 1524 (when (eq (car-safe val) 'face) 1525 (add-text-properties start end (cddr val)) 1526 (setq val (cadr val))) 1527 (cond 1528 ((not (or val (eq override t))) 1529 ;; If `val' is nil, don't do anything. It is important to do it 1530 ;; explicitly, because when adding nil via things like 1531 ;; font-lock-append-text-property, the property is actually 1532 ;; changed from <face> to (<face>) which is undesirable. --Stef 1533 nil) 1534 ((not override) 1535 ;; Cannot override existing fontification. 1536 (or (text-property-not-all start end 'face nil) 1537 (put-text-property start end 'face val))) 1538 ((eq override t) 1539 ;; Override existing fontification. 1540 (put-text-property start end 'face val)) 1541 ((eq override 'prepend) 1542 ;; Prepend to existing fontification. 1543 (font-lock-prepend-text-property start end 'face val)) 1544 ((eq override 'append) 1545 ;; Append to existing fontification. 1546 (font-lock-append-text-property start end 'face val)) 1547 ((eq override 'keep) 1548 ;; Keep existing fontification. 1549 (font-lock-fillin-text-property start end 'face val))))))) 1550 1551(defsubst font-lock-fontify-anchored-keywords (keywords limit) 1552 "Fontify according to KEYWORDS until LIMIT. 1553KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords', 1554LIMIT can be modified by the value of its PRE-MATCH-FORM." 1555 (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights 1556 (lead-start (match-beginning 0)) 1557 ;; Evaluate PRE-MATCH-FORM. 1558 (pre-match-value (eval (nth 1 keywords)))) 1559 ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line. 1560 (if (not (and (numberp pre-match-value) (> pre-match-value (point)))) 1561 (setq limit (line-end-position)) 1562 (setq limit pre-match-value) 1563 (when (and font-lock-multiline (>= limit (line-beginning-position 2))) 1564 ;; this is a multiline anchored match 1565 ;; (setq font-lock-multiline t) 1566 (put-text-property (if (= limit (line-beginning-position 2)) 1567 (1- limit) 1568 (min lead-start (point))) 1569 limit 1570 'font-lock-multiline t))) 1571 (save-match-data 1572 ;; Find an occurrence of `matcher' before `limit'. 1573 (while (and (< (point) limit) 1574 (if (stringp matcher) 1575 (re-search-forward matcher limit t) 1576 (funcall matcher limit))) 1577 ;; Apply each highlight to this instance of `matcher'. 1578 (setq highlights lowdarks) 1579 (while highlights 1580 (font-lock-apply-highlight (car highlights)) 1581 (setq highlights (cdr highlights))))) 1582 ;; Evaluate POST-MATCH-FORM. 1583 (eval (nth 2 keywords)))) 1584 1585(defun font-lock-fontify-keywords-region (start end &optional loudly) 1586 "Fontify according to `font-lock-keywords' between START and END. 1587START should be at the beginning of a line. 1588LOUDLY, if non-nil, allows progress-meter bar." 1589 (unless (eq (car font-lock-keywords) t) 1590 (setq font-lock-keywords 1591 (font-lock-compile-keywords font-lock-keywords))) 1592 (let ((case-fold-search font-lock-keywords-case-fold-search) 1593 (keywords (cddr font-lock-keywords)) 1594 (bufname (buffer-name)) (count 0) 1595 (pos (make-marker)) 1596 keyword matcher highlights) 1597 ;; 1598 ;; Fontify each item in `font-lock-keywords' from `start' to `end'. 1599 (while keywords 1600 (if loudly (message "Fontifying %s... (regexps..%s)" bufname 1601 (make-string (incf count) ?.))) 1602 ;; 1603 ;; Find an occurrence of `matcher' from `start' to `end'. 1604 (setq keyword (car keywords) matcher (car keyword)) 1605 (goto-char start) 1606 (while (and (< (point) end) 1607 (if (stringp matcher) 1608 (re-search-forward matcher end t) 1609 (funcall matcher end)) 1610 ;; Beware empty string matches since they will 1611 ;; loop indefinitely. 1612 (or (> (point) (match-beginning 0)) 1613 (progn (forward-char 1) t))) 1614 (when (and font-lock-multiline 1615 (>= (point) 1616 (save-excursion (goto-char (match-beginning 0)) 1617 (forward-line 1) (point)))) 1618 ;; this is a multiline regexp match 1619 ;; (setq font-lock-multiline t) 1620 (put-text-property (if (= (point) 1621 (save-excursion 1622 (goto-char (match-beginning 0)) 1623 (forward-line 1) (point))) 1624 (1- (point)) 1625 (match-beginning 0)) 1626 (point) 1627 'font-lock-multiline t)) 1628 ;; Apply each highlight to this instance of `matcher', which may be 1629 ;; specific highlights or more keywords anchored to `matcher'. 1630 (setq highlights (cdr keyword)) 1631 (while highlights 1632 (if (numberp (car (car highlights))) 1633 (font-lock-apply-highlight (car highlights)) 1634 (set-marker pos (point)) 1635 (font-lock-fontify-anchored-keywords (car highlights) end) 1636 ;; Ensure forward progress. `pos' is a marker because anchored 1637 ;; keyword may add/delete text (this happens e.g. in grep.el). 1638 (if (< (point) pos) (goto-char pos))) 1639 (setq highlights (cdr highlights)))) 1640 (setq keywords (cdr keywords))) 1641 (set-marker pos nil))) 1642 1643;;; End of Keyword regexp fontification functions. 1644 1645;; Various functions. 1646 1647(defun font-lock-compile-keywords (keywords &optional syntactic-keywords) 1648 "Compile KEYWORDS into the form (t KEYWORDS COMPILED...) 1649Here each COMPILED is of the form (MATCHER HIGHLIGHT ...) as shown in the 1650`font-lock-keywords' doc string. 1651If SYNTACTIC-KEYWORDS is non-nil, it means these keywords are used for 1652`font-lock-syntactic-keywords' rather than for `font-lock-keywords'." 1653 (if (not font-lock-set-defaults) 1654 ;; This should never happen. But some external packages sometimes 1655 ;; call font-lock in unexpected and incorrect ways. It's important to 1656 ;; stop processing at this point, otherwise we may end up changing the 1657 ;; global value of font-lock-keywords and break highlighting in many 1658 ;; other buffers. 1659 (error "Font-lock trying to use keywords before setting them up")) 1660 (if (eq (car-safe keywords) t) 1661 keywords 1662 (setq keywords 1663 (cons t (cons keywords 1664 (mapcar 'font-lock-compile-keyword keywords)))) 1665 (if (and (not syntactic-keywords) 1666 (let ((beg-function 1667 (or font-lock-beginning-of-syntax-function 1668 syntax-begin-function))) 1669 (or (eq beg-function 'beginning-of-defun) 1670 (get beg-function 'font-lock-syntax-paren-check))) 1671 (not beginning-of-defun-function)) 1672 ;; Try to detect when a string or comment contains something that 1673 ;; looks like a defun and would thus confuse font-lock. 1674 (nconc keywords 1675 `((,(if defun-prompt-regexp 1676 (concat "^\\(?:" defun-prompt-regexp "\\)?\\s(") 1677 "^\\s(") 1678 (0 1679 (if (memq (get-text-property (match-beginning 0) 'face) 1680 '(font-lock-string-face font-lock-doc-face 1681 font-lock-comment-face)) 1682 (list 'face font-lock-warning-face 1683 'help-echo "Looks like a toplevel defun: escape the parenthesis")) 1684 prepend))))) 1685 keywords)) 1686 1687(defun font-lock-compile-keyword (keyword) 1688 (cond ((nlistp keyword) ; MATCHER 1689 (list keyword '(0 font-lock-keyword-face))) 1690 ((eq (car keyword) 'eval) ; (eval . FORM) 1691 (font-lock-compile-keyword (eval (cdr keyword)))) 1692 ((eq (car-safe (cdr keyword)) 'quote) ; (MATCHER . 'FORM) 1693 ;; If FORM is a FACENAME then quote it. Otherwise ignore the quote. 1694 (if (symbolp (nth 2 keyword)) 1695 (list (car keyword) (list 0 (cdr keyword))) 1696 (font-lock-compile-keyword (cons (car keyword) (nth 2 keyword))))) 1697 ((numberp (cdr keyword)) ; (MATCHER . MATCH) 1698 (list (car keyword) (list (cdr keyword) 'font-lock-keyword-face))) 1699 ((symbolp (cdr keyword)) ; (MATCHER . FACENAME) 1700 (list (car keyword) (list 0 (cdr keyword)))) 1701 ((nlistp (nth 1 keyword)) ; (MATCHER . HIGHLIGHT) 1702 (list (car keyword) (cdr keyword))) 1703 (t ; (MATCHER HIGHLIGHT ...) 1704 keyword))) 1705 1706(defun font-lock-eval-keywords (keywords) 1707 "Evalulate KEYWORDS if a function (funcall) or variable (eval) name." 1708 (if (listp keywords) 1709 keywords 1710 (font-lock-eval-keywords (if (fboundp keywords) 1711 (funcall keywords) 1712 (eval keywords))))) 1713 1714(defun font-lock-value-in-major-mode (alist) 1715 "Return value in ALIST for `major-mode', or ALIST if it is not an alist. 1716Structure is ((MAJOR-MODE . VALUE) ...) where MAJOR-MODE may be t." 1717 (if (consp alist) 1718 (cdr (or (assq major-mode alist) (assq t alist))) 1719 alist)) 1720 1721(defun font-lock-choose-keywords (keywords level) 1722 "Return LEVELth element of KEYWORDS. 1723A LEVEL of nil is equal to a LEVEL of 0, a LEVEL of t is equal to 1724\(1- (length KEYWORDS))." 1725 (cond ((not (and (listp keywords) (symbolp (car keywords)))) 1726 keywords) 1727 ((numberp level) 1728 (or (nth level keywords) (car (last keywords)))) 1729 ((eq level t) 1730 (car (last keywords))) 1731 (t 1732 (car keywords)))) 1733 1734(defvar font-lock-set-defaults nil) ; Whether we have set up defaults. 1735 1736(defvar font-lock-mode-major-mode) 1737(defun font-lock-set-defaults () 1738 "Set fontification defaults appropriately for this mode. 1739Sets various variables using `font-lock-defaults' (or, if nil, using 1740`font-lock-defaults-alist') and `font-lock-maximum-decoration'." 1741 ;; Set fontification defaults iff not previously set for correct major mode. 1742 (unless (and font-lock-set-defaults 1743 (eq font-lock-mode-major-mode major-mode)) 1744 (setq font-lock-mode-major-mode major-mode) 1745 (set (make-local-variable 'font-lock-set-defaults) t) 1746 (make-local-variable 'font-lock-fontified) 1747 (make-local-variable 'font-lock-multiline) 1748 (let* ((defaults (or font-lock-defaults 1749 (cdr (assq major-mode 1750 (with-no-warnings 1751 font-lock-defaults-alist))))) 1752 (keywords 1753 (font-lock-choose-keywords (nth 0 defaults) 1754 (font-lock-value-in-major-mode font-lock-maximum-decoration))) 1755 (local (cdr (assq major-mode font-lock-keywords-alist))) 1756 (removed-keywords 1757 (cdr-safe (assq major-mode font-lock-removed-keywords-alist)))) 1758 (set (make-local-variable 'font-lock-defaults) defaults) 1759 ;; Syntactic fontification? 1760 (when (nth 1 defaults) 1761 (set (make-local-variable 'font-lock-keywords-only) t)) 1762 ;; Case fold during regexp fontification? 1763 (when (nth 2 defaults) 1764 (set (make-local-variable 'font-lock-keywords-case-fold-search) t)) 1765 ;; Syntax table for regexp and syntactic fontification? 1766 (when (nth 3 defaults) 1767 (set (make-local-variable 'font-lock-syntax-table) 1768 (copy-syntax-table (syntax-table))) 1769 (dolist (selem (nth 3 defaults)) 1770 ;; The character to modify may be a single CHAR or a STRING. 1771 (let ((syntax (cdr selem))) 1772 (dolist (char (if (numberp (car selem)) 1773 (list (car selem)) 1774 (mapcar 'identity (car selem)))) 1775 (modify-syntax-entry char syntax font-lock-syntax-table))))) 1776 ;; Syntax function for syntactic fontification? 1777 (when (nth 4 defaults) 1778 (set (make-local-variable 'font-lock-beginning-of-syntax-function) 1779 (nth 4 defaults))) 1780 ;; Variable alist? 1781 (dolist (x (nthcdr 5 defaults)) 1782 (set (make-local-variable (car x)) (cdr x))) 1783 ;; Set up `font-lock-keywords' last because its value might depend 1784 ;; on other settings (e.g. font-lock-compile-keywords uses 1785 ;; font-lock-beginning-of-syntax-function). 1786 (set (make-local-variable 'font-lock-keywords) 1787 (font-lock-eval-keywords keywords)) 1788 ;; Local fontification? 1789 (while local 1790 (font-lock-add-keywords nil (car (car local)) (cdr (car local))) 1791 (setq local (cdr local))) 1792 (when removed-keywords 1793 (font-lock-remove-keywords nil removed-keywords)) 1794 ;; Now compile the keywords. 1795 (unless (eq (car font-lock-keywords) t) 1796 (setq font-lock-keywords 1797 (font-lock-compile-keywords font-lock-keywords)))))) 1798 1799;;; Colour etc. support. 1800 1801;; Note that `defface' will not overwrite any faces declared above via 1802;; `custom-declare-face'. 1803(defface font-lock-comment-face 1804 '((((class grayscale) (background light)) 1805 (:foreground "DimGray" :weight bold :slant italic)) 1806 (((class grayscale) (background dark)) 1807 (:foreground "LightGray" :weight bold :slant italic)) 1808 (((class color) (min-colors 88) (background light)) 1809 (:foreground "Firebrick")) 1810 (((class color) (min-colors 88) (background dark)) 1811 (:foreground "chocolate1")) 1812 (((class color) (min-colors 16) (background light)) 1813 (:foreground "red")) 1814 (((class color) (min-colors 16) (background dark)) 1815 (:foreground "red1")) 1816 (((class color) (min-colors 8) (background light)) 1817 ) 1818 (((class color) (min-colors 8) (background dark)) 1819 ) 1820 (t (:weight bold :slant italic))) 1821 "Font Lock mode face used to highlight comments." 1822 :group 'font-lock-faces) 1823 1824(defface font-lock-comment-delimiter-face 1825 '((default :inherit font-lock-comment-face) 1826 (((class grayscale))) 1827 (((class color) (min-colors 16))) 1828 (((class color) (min-colors 8) (background light)) 1829 :foreground "red") 1830 (((class color) (min-colors 8) (background dark)) 1831 :foreground "red1")) 1832 "Font Lock mode face used to highlight comment delimiters." 1833 :group 'font-lock-faces) 1834 1835(defface font-lock-string-face 1836 '((((class grayscale) (background light)) (:foreground "DimGray" :slant italic)) 1837 (((class grayscale) (background dark)) (:foreground "LightGray" :slant italic)) 1838 (((class color) (min-colors 88) (background light)) (:foreground "RosyBrown")) 1839 (((class color) (min-colors 88) (background dark)) (:foreground "LightSalmon")) 1840 (((class color) (min-colors 16) (background light)) (:foreground "RosyBrown")) 1841 (((class color) (min-colors 16) (background dark)) (:foreground "LightSalmon")) 1842 (((class color) (min-colors 8)) (:foreground "green")) 1843 (t (:slant italic))) 1844 "Font Lock mode face used to highlight strings." 1845 :group 'font-lock-faces) 1846 1847(defface font-lock-doc-face 1848 '((t :inherit font-lock-string-face)) 1849 "Font Lock mode face used to highlight documentation." 1850 :group 'font-lock-faces) 1851 1852(defface font-lock-keyword-face 1853 '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) 1854 (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) 1855 (((class color) (min-colors 88) (background light)) (:foreground "Purple")) 1856 (((class color) (min-colors 88) (background dark)) (:foreground "Cyan1")) 1857 (((class color) (min-colors 16) (background light)) (:foreground "Purple")) 1858 (((class color) (min-colors 16) (background dark)) (:foreground "Cyan")) 1859 (((class color) (min-colors 8)) (:foreground "cyan" :weight bold)) 1860 (t (:weight bold))) 1861 "Font Lock mode face used to highlight keywords." 1862 :group 'font-lock-faces) 1863 1864(defface font-lock-builtin-face 1865 '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold)) 1866 (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) 1867 (((class color) (min-colors 88) (background light)) (:foreground "Orchid")) 1868 (((class color) (min-colors 88) (background dark)) (:foreground "LightSteelBlue")) 1869 (((class color) (min-colors 16) (background light)) (:foreground "Orchid")) 1870 (((class color) (min-colors 16) (background dark)) (:foreground "LightSteelBlue")) 1871 (((class color) (min-colors 8)) (:foreground "blue" :weight bold)) 1872 (t (:weight bold))) 1873 "Font Lock mode face used to highlight builtins." 1874 :group 'font-lock-faces) 1875 1876(defface font-lock-function-name-face 1877 '((((class color) (min-colors 88) (background light)) (:foreground "Blue1")) 1878 (((class color) (min-colors 88) (background dark)) (:foreground "LightSkyBlue")) 1879 (((class color) (min-colors 16) (background light)) (:foreground "Blue")) 1880 (((class color) (min-colors 16) (background dark)) (:foreground "LightSkyBlue")) 1881 (((class color) (min-colors 8)) (:foreground "blue" :weight bold)) 1882 (t (:inverse-video t :weight bold))) 1883 "Font Lock mode face used to highlight function names." 1884 :group 'font-lock-faces) 1885 1886(defface font-lock-variable-name-face 1887 '((((class grayscale) (background light)) 1888 (:foreground "Gray90" :weight bold :slant italic)) 1889 (((class grayscale) (background dark)) 1890 (:foreground "DimGray" :weight bold :slant italic)) 1891 (((class color) (min-colors 88) (background light)) (:foreground "DarkGoldenrod")) 1892 (((class color) (min-colors 88) (background dark)) (:foreground "LightGoldenrod")) 1893 (((class color) (min-colors 16) (background light)) (:foreground "DarkGoldenrod")) 1894 (((class color) (min-colors 16) (background dark)) (:foreground "LightGoldenrod")) 1895 (((class color) (min-colors 8)) (:foreground "yellow" :weight light)) 1896 (t (:weight bold :slant italic))) 1897 "Font Lock mode face used to highlight variable names." 1898 :group 'font-lock-faces) 1899 1900(defface font-lock-type-face 1901 '((((class grayscale) (background light)) (:foreground "Gray90" :weight bold)) 1902 (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold)) 1903 (((class color) (min-colors 88) (background light)) (:foreground "ForestGreen")) 1904 (((class color) (min-colors 88) (background dark)) (:foreground "PaleGreen")) 1905 (((class color) (min-colors 16) (background light)) (:foreground "ForestGreen")) 1906 (((class color) (min-colors 16) (background dark)) (:foreground "PaleGreen")) 1907 (((class color) (min-colors 8)) (:foreground "green")) 1908 (t (:weight bold :underline t))) 1909 "Font Lock mode face used to highlight type and classes." 1910 :group 'font-lock-faces) 1911 1912(defface font-lock-constant-face 1913 '((((class grayscale) (background light)) 1914 (:foreground "LightGray" :weight bold :underline t)) 1915 (((class grayscale) (background dark)) 1916 (:foreground "Gray50" :weight bold :underline t)) 1917 (((class color) (min-colors 88) (background light)) (:foreground "CadetBlue")) 1918 (((class color) (min-colors 88) (background dark)) (:foreground "Aquamarine")) 1919 (((class color) (min-colors 16) (background light)) (:foreground "CadetBlue")) 1920 (((class color) (min-colors 16) (background dark)) (:foreground "Aquamarine")) 1921 (((class color) (min-colors 8)) (:foreground "magenta")) 1922 (t (:weight bold :underline t))) 1923 "Font Lock mode face used to highlight constants and labels." 1924 :group 'font-lock-faces) 1925 1926(defface font-lock-warning-face 1927 '((((class color) (min-colors 88) (background light)) (:foreground "Red1" :weight bold)) 1928 (((class color) (min-colors 88) (background dark)) (:foreground "Pink" :weight bold)) 1929 (((class color) (min-colors 16) (background light)) (:foreground "Red1" :weight bold)) 1930 (((class color) (min-colors 16) (background dark)) (:foreground "Pink" :weight bold)) 1931 (((class color) (min-colors 8)) (:foreground "red")) 1932 (t (:inverse-video t :weight bold))) 1933 "Font Lock mode face used to highlight warnings." 1934 :group 'font-lock-faces) 1935 1936(defface font-lock-negation-char-face 1937 '((t nil)) 1938 "Font Lock mode face used to highlight easy to overlook negation." 1939 :group 'font-lock-faces) 1940 1941(defface font-lock-preprocessor-face 1942 '((t :inherit font-lock-builtin-face)) 1943 "Font Lock mode face used to highlight preprocessor directives." 1944 :group 'font-lock-faces) 1945 1946(defface font-lock-regexp-grouping-backslash 1947 '((t :inherit bold)) 1948 "Font Lock mode face for backslashes in Lisp regexp grouping constructs." 1949 :group 'font-lock-faces) 1950 1951(defface font-lock-regexp-grouping-construct 1952 '((t :inherit bold)) 1953 "Font Lock mode face used to highlight grouping constructs in Lisp regexps." 1954 :group 'font-lock-faces) 1955 1956;;; End of Colour etc. support. 1957 1958;;; Menu support. 1959 1960;; This section of code is commented out because Emacs does not have real menu 1961;; buttons. (We can mimic them by putting "( ) " or "(X) " at the beginning of 1962;; the menu entry text, but with Xt it looks both ugly and embarrassingly 1963;; amateur.) If/When Emacs gets real menus buttons, put in menu-bar.el after 1964;; the entry for "Text Properties" something like: 1965;; 1966;; (define-key menu-bar-edit-menu [font-lock] 1967;; (cons "Syntax Highlighting" font-lock-menu)) 1968;; 1969;; and remove a single ";" from the beginning of each line in the rest of this 1970;; section. Probably the mechanism for telling the menu code what are menu 1971;; buttons and when they are on or off needs tweaking. I have assumed that the 1972;; mechanism is via `menu-toggle' and `menu-selected' symbol properties. sm. 1973 1974;;;;;###autoload 1975;;(progn 1976;; ;; Make the Font Lock menu. 1977;; (defvar font-lock-menu (make-sparse-keymap "Syntax Highlighting")) 1978;; ;; Add the menu items in reverse order. 1979;; (define-key font-lock-menu [fontify-less] 1980;; '("Less In Current Buffer" . font-lock-fontify-less)) 1981;; (define-key font-lock-menu [fontify-more] 1982;; '("More In Current Buffer" . font-lock-fontify-more)) 1983;; (define-key font-lock-menu [font-lock-sep] 1984;; '("--")) 1985;; (define-key font-lock-menu [font-lock-mode] 1986;; '("In Current Buffer" . font-lock-mode)) 1987;; (define-key font-lock-menu [global-font-lock-mode] 1988;; '("In All Buffers" . global-font-lock-mode))) 1989;; 1990;;;;;###autoload 1991;;(progn 1992;; ;; We put the appropriate `menu-enable' etc. symbol property values on when 1993;; ;; font-lock.el is loaded, so we don't need to autoload the three variables. 1994;; (put 'global-font-lock-mode 'menu-toggle t) 1995;; (put 'font-lock-mode 'menu-toggle t) 1996;; (put 'font-lock-fontify-more 'menu-enable '(identity)) 1997;; (put 'font-lock-fontify-less 'menu-enable '(identity))) 1998;; 1999;; ;; Put the appropriate symbol property values on now. See above. 2000;;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode) 2001;;(put 'font-lock-mode 'menu-selected 'font-lock-mode) 2002;;(put 'font-lock-fontify-more 'menu-enable '(nth 2 font-lock-fontify-level)) 2003;;(put 'font-lock-fontify-less 'menu-enable '(nth 1 font-lock-fontify-level)) 2004;; 2005;;(defvar font-lock-fontify-level nil) ; For less/more fontification. 2006;; 2007;;(defun font-lock-fontify-level (level) 2008;; (let ((font-lock-maximum-decoration level)) 2009;; (when font-lock-mode 2010;; (font-lock-mode)) 2011;; (font-lock-mode) 2012;; (when font-lock-verbose 2013;; (message "Fontifying %s... level %d" (buffer-name) level)))) 2014;; 2015;;(defun font-lock-fontify-less () 2016;; "Fontify the current buffer with less decoration. 2017;;See `font-lock-maximum-decoration'." 2018;; (interactive) 2019;; ;; Check in case we get called interactively. 2020;; (if (nth 1 font-lock-fontify-level) 2021;; (font-lock-fontify-level (1- (car font-lock-fontify-level))) 2022;; (error "No less decoration"))) 2023;; 2024;;(defun font-lock-fontify-more () 2025;; "Fontify the current buffer with more decoration. 2026;;See `font-lock-maximum-decoration'." 2027;; (interactive) 2028;; ;; Check in case we get called interactively. 2029;; (if (nth 2 font-lock-fontify-level) 2030;; (font-lock-fontify-level (1+ (car font-lock-fontify-level))) 2031;; (error "No more decoration"))) 2032;; 2033;; ;; This should be called by `font-lock-set-defaults'. 2034;;(defun font-lock-set-menu () 2035;; ;; Activate less/more fontification entries if there are multiple levels for 2036;; ;; the current buffer. Sets `font-lock-fontify-level' to be of the form 2037;; ;; (CURRENT-LEVEL IS-LOWER-LEVEL-P IS-HIGHER-LEVEL-P) for menu activation. 2038;; (let ((keywords (or (nth 0 font-lock-defaults) 2039;; (nth 1 (assq major-mode font-lock-defaults-alist)))) 2040;; (level (font-lock-value-in-major-mode font-lock-maximum-decoration))) 2041;; (make-local-variable 'font-lock-fontify-level) 2042;; (if (or (symbolp keywords) (= (length keywords) 1)) 2043;; (font-lock-unset-menu) 2044;; (cond ((eq level t) 2045;; (setq level (1- (length keywords)))) 2046;; ((or (null level) (zerop level)) 2047;; ;; The default level is usually, but not necessarily, level 1. 2048;; (setq level (- (length keywords) 2049;; (length (member (eval (car keywords)) 2050;; (mapcar 'eval (cdr keywords)))))))) 2051;; (setq font-lock-fontify-level (list level (> level 1) 2052;; (< level (1- (length keywords)))))))) 2053;; 2054;; ;; This should be called by `font-lock-unset-defaults'. 2055;;(defun font-lock-unset-menu () 2056;; ;; Deactivate less/more fontification entries. 2057;; (setq font-lock-fontify-level nil)) 2058 2059;;; End of Menu support. 2060 2061;;; Various regexp information shared by several modes. 2062;; ;; Information specific to a single mode should go in its load library. 2063 2064;; Font Lock support for C, C++, Objective-C and Java modes is now in 2065;; cc-fonts.el (and required by cc-mode.el). However, the below function 2066;; should stay in font-lock.el, since it is used by other libraries. sm. 2067 2068(defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit) 2069 "Match, and move over, any declaration/definition item after point. 2070Matches after point, but ignores leading whitespace and `*' characters. 2071Does not move further than LIMIT. 2072 2073The expected syntax of a declaration/definition item is `word' (preceded by 2074optional whitespace and `*' characters and proceeded by optional whitespace) 2075optionally followed by a `('. Everything following the item (but belonging to 2076it) is expected to be skip-able by `scan-sexps', and items are expected to be 2077separated with a `,' and to be terminated with a `;'. 2078 2079Thus the regexp matches after point: word ( 2080 ^^^^ ^ 2081Where the match subexpressions are: 1 2 2082 2083The item is delimited by (match-beginning 1) and (match-end 1). 2084If (match-beginning 2) is non-nil, the item is followed by a `('. 2085 2086This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item." 2087 (when (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?") 2088 (when (and (match-end 2) (> (- (match-end 2) (match-beginning 2)) 1)) 2089 ;; If `word' is followed by a double open-paren, it's probably 2090 ;; a macro used for "int myfun P_ ((int arg1))". Let's go back one 2091 ;; word to try and match `myfun' rather than `P_'. 2092 (let ((pos (point))) 2093 (skip-chars-backward " \t\n") 2094 (skip-syntax-backward "w") 2095 (unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw+[ \t\n]*\\(((?\\)?") 2096 ;; Looks like it was something else, so go back to where we 2097 ;; were and reset the match data by rematching. 2098 (goto-char pos) 2099 (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?")))) 2100 (save-match-data 2101 (condition-case nil 2102 (save-restriction 2103 ;; Restrict to the LIMIT. 2104 (narrow-to-region (point-min) limit) 2105 (goto-char (match-end 1)) 2106 ;; Move over any item value, etc., to the next item. 2107 (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)")) 2108 (goto-char (or (scan-sexps (point) 1) (point-max)))) 2109 (goto-char (match-end 2))) 2110 (error t))))) 2111 2112;; C preprocessor(cpp) is used outside of C, C++ and Objective-C source file. 2113;; e.g. assembler code and GNU linker script in Linux kernel. 2114;; `cpp-font-lock-keywords' is handy for modes for the files. 2115;; 2116;; Here we cannot use `regexp-opt' because because regex-opt is not preloaded 2117;; while font-lock.el is preloaded to emacs. So values pre-calculated with 2118;; regexp-opt are used here. 2119 2120;; `cpp-font-lock-keywords-source-directives' is calculated from: 2121;; 2122;; (regexp-opt 2123;; '("define" "elif" "else" "endif" "error" "file" "if" "ifdef" 2124;; "ifndef" "import" "include" "line" "pragma" "undef" "warning")) 2125;; 2126(defconst cpp-font-lock-keywords-source-directives 2127 "define\\|e\\(?:l\\(?:if\\|se\\)\\|ndif\\|rror\\)\\|file\\|i\\(?:f\\(?:n?def\\)?\\|mport\\|nclude\\)\\|line\\|pragma\\|undef\\|warning" 2128 "Regular expressoin used in `cpp-font-lock-keywords'.") 2129 2130;; `cpp-font-lock-keywords-source-depth' is calculated from: 2131;; 2132;; (regexp-opt-depth (regexp-opt 2133;; '("define" "elif" "else" "endif" "error" "file" "if" "ifdef" 2134;; "ifndef" "import" "include" "line" "pragma" "undef" "warning"))) 2135;; 2136(defconst cpp-font-lock-keywords-source-depth 0 2137 "An integer representing regular expression depth of `cpp-font-lock-keywords-source-directives'. 2138Used in `cpp-font-lock-keywords'.") 2139 2140(defconst cpp-font-lock-keywords 2141 (let* ((directives cpp-font-lock-keywords-source-directives) 2142 (directives-depth cpp-font-lock-keywords-source-depth)) 2143 (list 2144 ;; 2145 ;; Fontify error directives. 2146 '("^#[ \t]*\\(?:error\\|warning\\)[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend) 2147 ;; 2148 ;; Fontify filenames in #include <...> preprocessor directives as strings. 2149 '("^#[ \t]*\\(?:import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)" 2150 1 font-lock-string-face prepend) 2151 ;; 2152 ;; Fontify function macro names. 2153 '("^#[ \t]*define[ \t]+\\([[:alpha:]_][[:alnum:]_$]*\\)(" 2154 (1 font-lock-function-name-face prepend) 2155 ;; 2156 ;; Macro arguments. 2157 ((lambda (limit) 2158 (re-search-forward 2159 "\\(?:\\([[:alpha:]_][[:alnum:]_]*\\)[,]?\\)" 2160 (or (save-excursion (re-search-forward ")" limit t)) 2161 limit) 2162 t)) 2163 nil nil (1 font-lock-variable-name-face prepend))) 2164 ;; 2165 ;; Fontify symbol names in #elif or #if ... defined preprocessor directives. 2166 '("^#[ \t]*\\(?:elif\\|if\\)\\>" 2167 ("\\<\\(defined\\)\\>[ \t]*(?\\([[:alpha:]_][[:alnum:]_]*\\)?" nil nil 2168 (1 font-lock-builtin-face prepend) (2 font-lock-variable-name-face prepend t))) 2169 ;; 2170 ;; Fontify otherwise as symbol names, and the preprocessor directive names. 2171 (list 2172 (concat "^\\(#[ \t]*\\(?:" directives 2173 "\\)\\)\\>[ \t!]*\\([[:alpha:]_][[:alnum:]_]*\\)?") 2174 '(1 font-lock-preprocessor-face prepend) 2175 (list (+ 2 directives-depth) 2176 'font-lock-variable-name-face nil t)))) 2177 "Font lock keyords for C preprocessor directives. 2178`c-mode', `c++-mode' and `objc-mode' have their own 2179font lock keyords for C preprocessor directives. This definition is for the 2180other modes in which C preprocessor directives are used. e.g. `asm-mode' and 2181`ld-script-mode'.") 2182 2183 2184;; Lisp. 2185 2186(defconst lisp-font-lock-keywords-1 2187 (eval-when-compile 2188 `(;; Definitions. 2189 (,(concat "(\\(def\\(" 2190 ;; Function declarations. 2191 "\\(advice\\|alias\\|generic\\|macro\\*?\\|method\\|" 2192 "setf\\|subst\\*?\\|un\\*?\\|" 2193 "ine-\\(condition\\|" 2194 "\\(?:derived\\|\\(?:global\\(?:ized\\)?-\\)?minor\\|generic\\)-mode\\|" 2195 "method-combination\\|setf-expander\\|skeleton\\|widget\\|" 2196 "function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|" 2197 ;; Variable declarations. 2198 "\\(const\\(ant\\)?\\|custom\\|varalias\\|face\\|parameter\\|var\\)\\|" 2199 ;; Structure declarations. 2200 "\\(class\\|group\\|theme\\|package\\|struct\\|type\\)" 2201 "\\)\\)\\>" 2202 ;; Any whitespace and defined object. 2203 "[ \t'\(]*" 2204 "\\(setf[ \t]+\\sw+)\\|\\sw+\\)?") 2205 (1 font-lock-keyword-face) 2206 (9 (cond ((match-beginning 3) font-lock-function-name-face) 2207 ((match-beginning 6) font-lock-variable-name-face) 2208 (t font-lock-type-face)) 2209 nil t)) 2210 ;; Emacs Lisp autoload cookies. 2211 ("^;;;###\\(autoload\\)" 1 font-lock-warning-face prepend) 2212 ;; Regexp negated char group. 2213 ("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend))) 2214 "Subdued level highlighting for Lisp modes.") 2215 2216(defconst lisp-font-lock-keywords-2 2217 (append lisp-font-lock-keywords-1 2218 (eval-when-compile 2219 `(;; Control structures. Emacs Lisp forms. 2220 (,(concat 2221 "(" (regexp-opt 2222 '("cond" "if" "while" "while-no-input" "let" "let*" 2223 "prog" "progn" "progv" "prog1" "prog2" "prog*" 2224 "inline" "lambda" "save-restriction" "save-excursion" 2225 "save-window-excursion" "save-selected-window" 2226 "save-match-data" "save-current-buffer" "unwind-protect" 2227 "condition-case" "track-mouse" 2228 "eval-after-load" "eval-and-compile" "eval-when-compile" 2229 "eval-when" "eval-at-startup" "eval-next-after-load" 2230 "with-case-table" "with-category-table" 2231 "with-current-buffer" "with-electric-help" 2232 "with-local-quit" "with-no-warnings" 2233 "with-output-to-string" "with-output-to-temp-buffer" 2234 "with-selected-window" "with-syntax-table" 2235 "with-temp-buffer" "with-temp-file" "with-temp-message" 2236 "with-timeout" "with-timeout-handler") t) 2237 "\\>") 2238 . 1) 2239 ;; Control structures. Common Lisp forms. 2240 (,(concat 2241 "(" (regexp-opt 2242 '("when" "unless" "case" "ecase" "typecase" "etypecase" 2243 "ccase" "ctypecase" "handler-case" "handler-bind" 2244 "restart-bind" "restart-case" "in-package" 2245 "break" "ignore-errors" 2246 "loop" "do" "do*" "dotimes" "dolist" "the" "locally" 2247 "proclaim" "declaim" "declare" "symbol-macrolet" 2248 "lexical-let" "lexical-let*" "flet" "labels" "compiler-let" 2249 "destructuring-bind" "macrolet" "tagbody" "block" "go" 2250 "multiple-value-bind" "multiple-value-prog1" 2251 "return" "return-from" 2252 "with-accessors" "with-compilation-unit" 2253 "with-condition-restarts" "with-hash-table-iterator" 2254 "with-input-from-string" "with-open-file" 2255 "with-open-stream" "with-output-to-string" 2256 "with-package-iterator" "with-simple-restart" 2257 "with-slots" "with-standard-io-syntax") t) 2258 "\\>") 2259 . 1) 2260 ;; Exit/Feature symbols as constants. 2261 (,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\>" 2262 "[ \t']*\\(\\sw+\\)?") 2263 (1 font-lock-keyword-face) 2264 (2 font-lock-constant-face nil t)) 2265 ;; Erroneous structures. 2266 ("(\\(abort\\|assert\\|warn\\|check-type\\|cerror\\|error\\|signal\\)\\>" 1 font-lock-warning-face) 2267 ;; Words inside \\[] tend to be for `substitute-command-keys'. 2268 ("\\\\\\\\\\[\\(\\sw+\\)\\]" 1 font-lock-constant-face prepend) 2269 ;; Words inside `' tend to be symbol names. 2270 ("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend) 2271 ;; Constant values. 2272 ("\\<:\\sw+\\>" 0 font-lock-builtin-face) 2273 ;; ELisp and CLisp `&' keywords as types. 2274 ("\\<\\&\\sw+\\>" . font-lock-type-face) 2275 ;; ELisp regexp grouping constructs 2276 ((lambda (bound) 2277 (catch 'found 2278 ;; The following loop is needed to continue searching after matches 2279 ;; that do not occur in strings. The associated regexp matches one 2280 ;; of `\\\\' `\\(' `\\(?:' `\\|' `\\)'. `\\\\' has been included to 2281 ;; avoid highlighting, for example, `\\(' in `\\\\('. 2282 (while (re-search-forward "\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?:\\)?\\|[|)]\\)\\)" bound t) 2283 (unless (match-beginning 2) 2284 (let ((face (get-text-property (1- (point)) 'face))) 2285 (when (or (and (listp face) 2286 (memq 'font-lock-string-face face)) 2287 (eq 'font-lock-string-face face)) 2288 (throw 'found t))))))) 2289 (1 'font-lock-regexp-grouping-backslash prepend) 2290 (3 'font-lock-regexp-grouping-construct prepend)) 2291;;; This is too general -- rms. 2292;;; A user complained that he has functions whose names start with `do' 2293;;; and that they get the wrong color. 2294;;; ;; CL `with-' and `do-' constructs 2295;;; ("(\\(\\(do-\\|with-\\)\\(\\s_\\|\\w\\)*\\)" 1 font-lock-keyword-face) 2296 ))) 2297 "Gaudy level highlighting for Lisp modes.") 2298 2299(defvar lisp-font-lock-keywords lisp-font-lock-keywords-1 2300 "Default expressions to highlight in Lisp modes.") 2301 2302(provide 'font-lock) 2303 2304;; arch-tag: 682327e4-64d8-4057-b20b-1fbb9f1fc54c 2305;;; font-lock.el ends here 2306