code.delx.au - gnu-emacs/blob - lisp/font-lock.el

   1 ;; Electric Font Lock Mode
   2 ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
   3
   4 ;; Author: jwz, then rms
   5 ;; Maintainer: FSF
   6 ;; Keywords: languages, faces
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to
  22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24
  25 ;;; Commentary:
  26
  27 ;; Font-lock-mode is a minor mode that causes your comments to be
  28 ;; displayed in one face, strings in another, reserved words in another,
  29 ;; documentation strings in another, and so on.
  30 ;;
  31 ;; Comments will be displayed in `font-lock-comment-face'.
  32 ;; Strings will be displayed in `font-lock-string-face'.
  33 ;; Doc strings will be displayed in `font-lock-doc-string-face'.
  34 ;; Function and variable names (in their defining forms) will be
  35 ;;  displayed in `font-lock-function-name-face'.
  36 ;; Reserved words will be displayed in `font-lock-keyword-face'.
  37 ;;
  38 ;; To make the text you type be fontified, use M-x font-lock-mode.
  39 ;; When this minor mode is on, the fonts of the current line are
  40 ;; updated with every insertion or deletion.
  41 ;;
  42 ;; To define new reserved words or other patterns to highlight, use
  43 ;; the `font-lock-keywords' variable.  This should be mode-local.
  44 ;;
  45 ;; To turn this on automatically, add this to your .emacs file:
  46 ;;
  47 ;;      (setq emacs-lisp-mode-hook '(lambda () (font-lock-mode 1)))
  48 ;;
  49 ;; On a Sparc2, the initial fontification takes about 12 seconds for a 120k
  50 ;; file of C code, using the default configuration.  You can speed this up
  51 ;; substantially by removing some of the patterns that are highlighted by
  52 ;; default.  Fontifying Lisp code is significantly faster, because Lisp has a
  53 ;; more regular syntax than C, so the expressions don't have to be as hairy.
  54
  55 ;;; Code:
  56
  57 (or window-system
  58     (error "Can't fontify on an ASCII terminal"))
  59
  60 (defvar font-lock-comment-face
  61   'italic
  62   "Face to use for comments.")
  63
  64 (defvar font-lock-doc-string-face
  65   'italic
  66   "Face to use for documentation strings.")
  67
  68 (defvar font-lock-string-face
  69   'underline
  70   "Face to use for string constants.")
  71
  72 (defvar font-lock-function-name-face
  73   'bold-italic
  74   "Face to use for function names.")
  75
  76 (defvar font-lock-keyword-face
  77   'bold
  78   "Face to use for keywords.")
  79
  80 (defvar font-lock-type-face
  81   'italic
  82   "Face to use for data types.")
  83
  84 (defvar font-lock-no-comments nil
  85   "Non-nil means Font-Lock shouldn't check for comments or strings.")
  86
  87 (make-variable-buffer-local 'font-lock-keywords)
  88 (defvar font-lock-keywords nil
  89   "*The keywords to highlight.
  90 If this is a list, then elements may be of the forms:
  91
  92   \"string\"                      ; A regexp to highlight in the
  93                                   ;  `font-lock-keyword-face'.
  94   (\"string\" . N)                ; Highlight subexpression N of the regexp.
  95   (\"string\" . face-name)        ; Use the named face
  96   (\"string\" N face-name)        ; Both of the above
  97   (\"string\" N face-name t)      ; This allows highlighting to override
  98                                   ;  already-highlighted regions.
  99   (\"string\" N face-name keep)   ; This allows highlighting to occur
 100                                   ; even if some parts of what STRING matches
 101                                   ; are already highlighted--but does not alter
 102                                   ; the existing highlighting of those parts.
 103
 104 These regular expressions should not match text which spans lines.
 105 While \\[font-lock-fontify-buffer] handles multi-line patterns correctly,
 106 updating when you edit the buffer does not,
 107 since it considers text one line at a time.
 108
 109 Be careful composing regexps for this list; the wrong pattern can dramatically
 110 slow things down!")
 111
 112 (defvar font-lock-keywords-case-fold-search nil
 113   "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.")
 114
 115 (defvar font-lock-syntax-table nil
 116   "*Non-nil means use this syntax table for fontifying.
 117 If this is nil, the major mode's syntax table is used.")
 118
 119 (defvar font-lock-verbose t
 120   "*Non-nil means `font-lock-fontify-buffer' should print status messages.")
 121
 122 ;;;###autoload
 123 (defvar font-lock-mode-hook nil
 124   "Function or functions to run on entry to Font Lock mode.")
 125
 126 ;;; These variables record, for each buffer,
 127 ;;; the parse state at a particular position, always the start of a line.
 128 ;;; This is used to make font-lock-fontify-region faster.
 129 (defvar font-lock-cache-position nil)
 130 (defvar font-lock-cache-state nil)
 131 (make-variable-buffer-local 'font-lock-cache-position)
 132 (make-variable-buffer-local 'font-lock-cache-state)
 133
 134 (defun font-lock-fontify-region (start end)
 135   "Put proper face on each string and comment between START and END."
 136   (save-excursion
 137     (goto-char start)
 138     (beginning-of-line)
 139     (setq end (min end (point-max)))
 140     (let ((buffer-read-only nil)
 141           state startline prev prevstate
 142           (modified (buffer-modified-p)))
 143       ;; Find the state at the line-beginning before START.
 144       (setq startline (point))
 145       (if (eq (point) font-lock-cache-position)
 146           (setq state font-lock-cache-state)
 147         ;; Find outermost containing sexp.
 148         (beginning-of-defun)
 149         ;; Find the state at STARTLINE.
 150         (while (< (point) startline)
 151           (setq state (parse-partial-sexp (point) startline 0)))
 152         (setq font-lock-cache-state state
 153               font-lock-cache-position (point)))
 154       ;; Now find the state precisely at START.
 155       (setq state (parse-partial-sexp (point) start nil nil state))
 156       ;; If the region starts inside a string, show the extent of it.
 157       (if (nth 3 state)
 158           (let ((beg (point)))
 159             (while (and (re-search-forward "\\s\"" end 'move)
 160                         (nth 3 (parse-partial-sexp beg (point)
 161                                                    nil nil state))))
 162             (put-text-property beg (point) 'face font-lock-string-face)
 163             (setq state (parse-partial-sexp beg (point) nil nil state))))
 164       ;; Likewise for a comment.
 165       (if (or (nth 4 state) (nth 7 state))
 166           (let ((beg (point)))
 167             (while (and (re-search-forward (if comment-end
 168                                                (concat "\\s>\\|"
 169                                                        (regexp-quote comment-end))
 170                                              "\\s>")
 171                                            end 'move)
 172                         (nth 3 (parse-partial-sexp beg (point)
 173                                                    nil nil state))))
 174             (put-text-property beg (point) 'face font-lock-comment-face)
 175             (setq state (parse-partial-sexp beg (point) nil nil state))))
 176       ;; Find each interesting place between here and END.
 177       (while (and (< (point) end)
 178                   (setq prev (point) prevstate state)
 179                   (re-search-forward (if comment-start-skip
 180                                          (concat "\\s\"\\|" comment-start-skip)
 181                                        "\\s\"")
 182                                      end t)
 183                   ;; Clear out the fonts of what we skip over.
 184                   (progn (remove-text-properties prev (point) '(face nil)) t)
 185                   ;; Verify the state at that place
 186                   ;; so we don't get fooled by \" or \;.
 187                   (setq state (parse-partial-sexp prev (point)
 188                                                   nil nil state)))
 189         (let ((here (point)))
 190           (if (or (nth 4 state) (nth 7 state))
 191               ;; We found a real comment start.
 192               (let ((beg (match-beginning 0)))
 193                 (goto-char beg)
 194                 (save-restriction
 195                   (narrow-to-region (point-min) end)
 196                   (condition-case nil
 197                       (progn
 198                         (forward-comment 1)
 199                         ;; forward-comment skips all whitespace,
 200                         ;; so go back to the real end of the comment.
 201                         (skip-chars-backward " \t"))
 202                     (error (goto-char end))))
 203                 (put-text-property beg (point) 'face font-lock-comment-face)
 204                 (setq state (parse-partial-sexp here (point) nil nil state)))
 205             (if (nth 3 state)
 206                 (let ((beg (match-beginning 0)))
 207                   (while (and (re-search-forward "\\s\"" end 'move)
 208                               (nth 3 (parse-partial-sexp here (point)
 209                                                          nil nil state))))
 210                   (put-text-property beg (point) 'face font-lock-string-face)
 211                   (setq state (parse-partial-sexp here (point) nil nil state))))
 212               ))
 213         ;; Make sure PREV is non-nil after the loop
 214         ;; only if it was set on the very last iteration.
 215         (setq prev nil))
 216       (and prev
 217            (remove-text-properties prev end '(face nil)))
 218       (and (buffer-modified-p)
 219            (not modified)
 220            (set-buffer-modified-p nil)))))
 221
 222 ;; This code used to be used to show a string on reaching the end of it.
 223 ;; It is probably not needed due to later changes to handle strings
 224 ;; starting before the region in question.
 225 ;;          (if (and (null (nth 3 state))
 226 ;;                   (eq (char-syntax (preceding-char)) ?\")
 227 ;;                   (save-excursion
 228 ;;                     (nth 3 (parse-partial-sexp prev (1- (point))
 229 ;;                                                nil nil prevstate))))
 230 ;;              ;; We found the end of a string.
 231 ;;              (save-excursion
 232 ;;                (setq foo2 (point))
 233 ;;                (let ((ept (point)))
 234 ;;                  (forward-sexp -1)
 235 ;;                  ;; Highlight the string when we see the end.
 236 ;;                  ;; Doing it at the start leads to trouble:
 237 ;;                  ;; either it fails to handle multiline strings
 238 ;;                  ;; or it can run away when an unmatched " is inserted.
 239 ;;                  (put-text-property (point) ept 'face
 240 ;;                                     (if (= (car state) 1)
 241 ;;                                         font-lock-doc-string-face
 242 ;;                                       font-lock-string-face)))))
 243
 244 (defun font-lock-unfontify-region (beg end)
 245   (let ((modified (buffer-modified-p))
 246         (buffer-read-only nil))
 247     (remove-text-properties beg end '(face nil))
 248     (set-buffer-modified-p modified)))
 249
 250 ;; Called when any modification is made to buffer text.
 251 (defun font-lock-after-change-function (beg end old-len)
 252   (save-excursion
 253     (save-match-data
 254       (goto-char beg)
 255       ;; Discard the cache info if text before it has changed.
 256       (and font-lock-cache-position
 257            (> font-lock-cache-position beg)
 258            (setq font-lock-cache-position nil))
 259       ;; Rescan till end of line.  yes!
 260       (goto-char end)
 261       (end-of-line)
 262       (setq end (point))
 263       (goto-char beg)
 264       (beginning-of-line)
 265       (setq beg (point))
 266       ;; First scan for strings and comments.
 267       ;; Must scan from line start in case of
 268       ;; inserting space into `intfoo () {}'.
 269       (if font-lock-no-comments
 270           (remove-text-properties beg (min (1+ end) (point-max)) '(face nil))
 271         (font-lock-fontify-region beg (min (1+ end) (point-max))))
 272       ;; Now scan for keywords.
 273       (font-lock-hack-keywords beg end))))
 274 \f
 275 ;;; Fontifying arbitrary patterns
 276
 277 (defsubst font-lock-any-properties-p (start end)
 278   (or (get-text-property start 'face)
 279       (let ((next (next-single-property-change start 'face)))
 280         (and next (< next end)))))
 281
 282 (defun font-lock-hack-keywords (start end &optional loudly)
 283   (goto-char start)
 284   (let ((case-fold-search font-lock-keywords-case-fold-search)
 285         (rest font-lock-keywords)
 286         (count 0)
 287         (buffer-read-only nil)
 288         (modified (buffer-modified-p))
 289         first str match face s e allow-overlap-p
 290         (old-syntax (syntax-table)))
 291     (unwind-protect
 292         (progn
 293           (if font-lock-syntax-table
 294               (set-syntax-table font-lock-syntax-table))
 295           (while rest
 296             (setq first (car rest) rest (cdr rest))
 297             (goto-char start)
 298             (cond ((consp first)
 299                    (setq str (car first))
 300                    (cond ((consp (cdr first))
 301                           (setq match (nth 1 first)
 302                                 face (eval (nth 2 first))
 303                                 allow-overlap-p (nth 3 first)))
 304                          ((symbolp (cdr first))
 305                           (setq match 0 allow-overlap-p nil
 306                                 face (eval (cdr first))))
 307                          (t
 308                           (setq match (cdr first)
 309                                 allow-overlap-p nil
 310                                 face font-lock-keyword-face))))
 311                   (t
 312                    (setq str first match 0 allow-overlap-p nil
 313                          face font-lock-keyword-face)))
 314             ;(message "regexp: %s" str)
 315             (while (re-search-forward str end t)
 316               (setq s (match-beginning match)
 317                     e (match-end match))
 318               (or s (error "expression did not match subexpression %d" match))
 319               ;; don't fontify this keyword if we're already in some other context.
 320               (or (if allow-overlap-p nil (font-lock-any-properties-p s e))
 321                   (if (not (memq allow-overlap-p '(t nil)))
 322                       (save-excursion
 323                         (goto-char s)
 324                         (while (< (point) e)
 325                           (let ((next (next-single-property-change (point) 'face
 326                                                                    nil e)))
 327                             (if (or (null next) (> next e))
 328                                 (setq next e))
 329                             (if (not (get-text-property (point) 'face))
 330                                 (put-text-property (point) next 'face face))
 331                             (goto-char next))))
 332                     (put-text-property s e 'face face))))
 333             (if loudly (message "Fontifying %s... (regexps...%s)"
 334                                 (buffer-name)
 335                                 (make-string (setq count (1+ count)) ?.)))))
 336       (set-syntax-table old-syntax))
 337     (and (buffer-modified-p)
 338          (not modified)
 339          (set-buffer-modified-p nil))))
 340 \f
 341 ;; The user level functions
 342
 343 (defvar font-lock-mode nil) ; for modeline
 344 (or (assq 'font-lock-mode minor-mode-alist)
 345     (setq minor-mode-alist
 346           (append minor-mode-alist
 347                   '((font-lock-mode " Font")))))
 348
 349 (defvar font-lock-fontified nil) ; whether we have hacked this buffer
 350 (put 'font-lock-fontified 'permanent-local t)
 351
 352 ;;;###autoload
 353 (defun font-lock-mode (&optional arg)
 354   "Toggle Font Lock mode.
 355 With arg, turn Font Lock mode on if and only if arg is positive.
 356
 357 When Font Lock mode is enabled, text is fontified as you type it:
 358
 359  - comments are displayed in `font-lock-comment-face';
 360      (That is a variable whose value should be a face name.)
 361  - strings are displayed in `font-lock-string-face';
 362  - documentation strings are displayed in `font-lock-doc-string-face';
 363  - function and variable names in their defining forms are displayed
 364    in `font-lock-function-name-face';
 365  - and certain other expressions are displayed in other faces
 366    according to the value of the variable `font-lock-keywords'.
 367
 368 When you turn Font Lock mode on/off, the buffer is fontified/defontified.
 369 To fontify a buffer without having newly typed text become fontified, you
 370 can use \\[font-lock-fontify-buffer]."
 371   (interactive "P")
 372   (let ((on-p (if (null arg)
 373                   (not font-lock-mode)
 374                 (> (prefix-numeric-value arg) 0))))
 375     (if (equal (buffer-name) " *Compiler Input*") ; hack for bytecomp...
 376         (setq on-p nil))
 377     (make-local-variable 'after-change-functions)
 378     (if on-p
 379         (or (memq 'font-lock-after-change-function after-change-functions)
 380             (setq after-change-functions (cons 'font-lock-after-change-function
 381                                                after-change-functions)))
 382       (setq after-change-functions
 383             (delq 'font-lock-after-change-function
 384                   (copy-sequence after-change-functions))))
 385     (set (make-local-variable 'font-lock-mode) on-p)
 386     (make-local-variable 'font-lock-no-comments)
 387     (cond (on-p
 388            (font-lock-set-defaults)
 389            (make-local-variable 'before-revert-hook)
 390            (make-local-variable 'after-revert-hook)
 391            ;; If buffer is reverted, must clean up the state.
 392            (add-hook 'before-revert-hook 'font-lock-revert-setup)
 393            (add-hook 'after-revert-hook 'font-lock-revert-cleanup)
 394            (run-hooks 'font-lock-mode-hook)
 395            (or font-lock-fontified (font-lock-fontify-buffer)))
 396           (font-lock-fontified
 397            (setq font-lock-fontified nil)
 398            (remove-hook 'before-revert-hook 'font-lock-revert-setup)
 399            (remove-hook 'after-revert-hook 'font-lock-revert-cleanup)
 400            (font-lock-unfontify-region (point-min) (point-max))))
 401     (force-mode-line-update)))
 402
 403 ;; If the buffer is about to be reverted, it won't be fontified.
 404 (defun font-lock-revert-setup ()
 405   (setq font-lock-fontified nil))
 406
 407 ;; If the buffer has just been reverted, we might not even be in font-lock
 408 ;; mode anymore, and if we are, the buffer may or may not have already been
 409 ;; refontified.  Refontify here if it looks like we need to.
 410 (defun font-lock-revert-cleanup ()
 411   (and font-lock-mode
 412        (not font-lock-fontified)
 413        (font-lock-mode 1)))
 414
 415 (defun font-lock-fontify-buffer ()
 416   "Fontify the current buffer the way `font-lock-mode' would:
 417
 418  - comments are displayed in `font-lock-comment-face';
 419  - strings are displayed in `font-lock-string-face';
 420  - documentation strings are displayed in `font-lock-doc-string-face';
 421  - function and variable names in their defining forms are displayed
 422    in `font-lock-function-name-face';
 423  - and certain other expressions are displayed in other faces
 424    according to the value of the variable `font-lock-keywords'.
 425
 426 This can take a while for large buffers."
 427   (interactive)
 428   (let ((was-on font-lock-mode)
 429         (font-lock-verbose (or font-lock-verbose (interactive-p))))
 430     (if font-lock-verbose (message "Fontifying %s..." (buffer-name)))
 431     ;; Turn it on to run hooks and get the right font-lock-keywords.
 432     (or was-on (font-lock-set-defaults))
 433     (font-lock-unfontify-region (point-min) (point-max))
 434     (if (and font-lock-verbose (not font-lock-no-comments))
 435         (message "Fontifying %s... (syntactically...)" (buffer-name)))
 436     (save-excursion
 437       (or font-lock-no-comments
 438           (font-lock-fontify-region (point-min) (point-max)))
 439       (if font-lock-verbose (message "Fontifying %s... (regexps...)"
 440                                      (buffer-name)))
 441       (font-lock-hack-keywords (point-min) (point-max) font-lock-verbose))
 442     (set (make-local-variable 'font-lock-fontified) t)
 443     (if font-lock-verbose (message "Fontifying %s... done." (buffer-name)))
 444     ))
 445
 446 \f
 447 ;;; Various mode-specific information.
 448
 449 (defconst lisp-font-lock-keywords-1
 450  '(;;
 451    ;; highlight defining forms.  This doesn't work too nicely for
 452    ;; (defun (setf foo) ...) but it does work for (defvar foo) which
 453    ;; is more important.
 454    ("^(def[-a-z]+\\s +\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face)
 455    ;;
 456    ;; highlight CL keywords
 457    ("\\s :\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
 458    ;;
 459    ;; this is highlights things like (def* (setf foo) (bar baz)), but may
 460    ;; be slower (I haven't really thought about it)
 461 ;   ("^(def[-a-z]+\\s +\\(\\s(\\S)*\\s)\\|\\S(\\S *\\)"
 462 ;    1 font-lock-function-name-face)
 463    )
 464  "For consideration as a value of `lisp-font-lock-keywords'.
 465 This does fairly subdued highlighting.")
 466
 467 (defconst lisp-font-lock-keywords-2
 468   (append
 469    lisp-font-lock-keywords-1
 470    '(;;
 471      ;; Highlight control structures
 472      ("(\\(cond\\|if\\|when\\|unless\\|[ec]?\\(type\\)?case\\)[ \t\n]" . 1)
 473      ("(\\(while\\|do\\|let\\*?\\|flet\\|labels\\|prog[nv12*]?\\)[ \t\n]" . 1)
 474      ("(\\(catch\\|\\throw\\|block\\|return\\|return-from\\)[ \t\n]" . 1)
 475      ("(\\(save-restriction\\|save-window-restriction\\)[ \t\n]" . 1)
 476      ("(\\(save-excursion\\|unwind-protect\\|condition-case\\)[ \t\n]" . 1)
 477      ;;
 478      ;; highlight function names in emacs-lisp docstrings (in the syntax
 479      ;; that substitute-command-keys understands.)
 480      ("\\\\\\\\\\[\\([^]\\\n]+\\)]" 1 font-lock-keyword-face t)
 481      ;;
 482      ;; highlight words inside `' which tend to be function names
 483      ("`\\([-a-zA-Z0-9_][-a-zA-Z0-9_][-a-zA-Z0-9_.]+\\)'"
 484       1 font-lock-keyword-face t)
 485      ))
 486  "For consideration as a value of `lisp-font-lock-keywords'.
 487 This does a lot more highlighting.")
 488
 489 ;; default to the gaudier variety?
 490 ;(defvar lisp-font-lock-keywords lisp-font-lock-keywords-2
 491 ;  "Additional expressions to highlight in Lisp modes.")
 492 (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
 493   "Additional expressions to highlight in Lisp modes.")
 494
 495
 496 (defconst c-font-lock-keywords-1 nil
 497  "For consideration as a value of `c-font-lock-keywords'.
 498 This does fairly subdued highlighting.")
 499
 500 (defconst c-font-lock-keywords-2 nil
 501  "For consideration as a value of `c-font-lock-keywords'.
 502 This does a lot more highlighting.")
 503
 504 (defconst c++-font-lock-keywords-1 nil
 505  "For consideration as a value of `c++-font-lock-keywords'.
 506 This does fairly subdued highlighting.")
 507
 508 (defconst c++-font-lock-keywords-2 nil
 509  "For consideration as a value of `c++-font-lock-keywords'.
 510 This does a lot more highlighting.")
 511
 512 (let* ((storage "auto\\|extern\\|register\\|static\\|typedef")
 513        (struct "struct\\|union\\|enum")
 514        (prefixes "signed\\|unsigned\\|short\\|long")
 515        (types (concat prefixes "\\|int\\|char\\|float\\|double\\|void"))
 516        (ctoken "[a-zA-Z0-9_:~*]+")
 517        (c++-things (concat
 518                     "const\\|class\\|protected:\\|private:\\|public:\\|inline\\|"
 519                     "new\\|delete")))
 520  (setq c-font-lock-keywords-1
 521   (list
 522    ;; fontify preprocessor directives as comments.
 523    '("^#[ \t]*[a-z]+" . font-lock-comment-face)
 524    ;;
 525    ;; fontify names being defined.
 526    '("^#[ \t]*\\(define\\|undef\\)[ \t]+\\(\\(\\sw\\|\\s_\\)+\\)" 2
 527      font-lock-function-name-face)
 528    ;;
 529    ;; fontify other preprocessor lines.
 530    '("^#[ \t]*\\(if\\|elif\\|else\\|endif\\)[ \t]+\\([^\n]+\\)"
 531      2 font-lock-function-name-face keep)
 532    '("^#[ \t]*\\(ifn?def\\)[ \t]+\\([^ \t\n]+\\)"
 533      2 font-lock-function-name-face t)
 534    ;;
 535    ;; fontify the filename in #include <...>
 536    ;; don't need to do this for #include "..." because those were
 537    ;; already fontified as strings by the syntactic pass.
 538    '("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face)
 539    ;;
 540    ;; fontify the names of functions being defined.
 541    (list (concat
 542           "^\\(" ctoken "[ \t]+\\)?"    ; type specs; there can be no
 543           "\\(" ctoken "[ \t]+\\)?"     ; more than 3 tokens, right?
 544           "\\(" ctoken "[ \t]+\\)?"
 545           "\\([*&]+[ \t]*\\)?"          ; pointer
 546           "\\(" ctoken "\\)[ \t]*(")            ; name
 547     5 'font-lock-function-name-face)
 548    ;;
 549    ;;
 550    ;; Fontify structure names (in structure definition form).
 551    (list (concat "^\\(" storage "\\)?[ \t]*\\<\\(" struct "\\)"
 552           "[ \t]+\\(" ctoken "\\)[ \t]*\\(\{\\|$\\)")
 553     3 'font-lock-function-name-face)
 554    ;;
 555    ;; Fontify declarations of simple identifiers (including typedefs).
 556    ;; (Should this be in c-font-lock-keywords-2 instead?)
 557    (list (concat "^[ \t]*\\(\\(" storage "\\)[ \t]+\\)?\\(\\(\\(" prefixes
 558           "\\)\\>[ \t]*\\)*\\(" types "\\)\\)[ \t]+\\(" ctoken
 559           "\\)[ \t]*[=;]")
 560     7 'font-lock-function-name-face 'keep)
 561    ;;
 562    ;; And likewise for structs
 563    (list (concat "^[ \t]*\\(\\(" storage "\\)[ \t]+\\)?\\(" struct
 564           "\\)[ \t]+" ctoken "[ \t]+\\(" ctoken "\\);")
 565     4 'font-lock-function-name-face 'keep)
 566    ;;
 567    ;; Fontify case clauses.  This is fast because its anchored on the left.
 568    '("case[ \t]+\\(\\(\\sw\\|\\s_\\)+\\):". 1)
 569    '("\\<\\(default\\):". 1)
 570    ))
 571
 572  (setq c-font-lock-keywords-2
 573   (append c-font-lock-keywords-1
 574    (list
 575     ;;
 576     ;; fontify all storage classes and type specifiers
 577     (cons (concat "\\<\\(" storage "\\)\\>") 'font-lock-type-face)
 578     (cons (concat "\\<\\(" types "\\)\\>") 'font-lock-type-face)
 579     (cons (concat "\\<\\(\\(\\(" prefixes "\\)\\>[ \t]*\\)*\\(" types
 580            "\\)\\)\\>")
 581      'font-lock-type-face)
 582     (list (concat "\\<\\(" struct "\\)[ \t]+" ctoken)
 583      0 'font-lock-type-face 'keep)
 584     ;;
 585     ;; fontify all builtin tokens
 586     (cons (concat
 587            "[ \t]\\("
 588            (mapconcat 'identity
 589             '("for" "while" "do" "return" "goto" "case" "break" "switch"
 590               "if" "else" "default" "continue" "default")
 591             "\\|")
 592            "\\)[ \t\n(){};,]")
 593      1)
 594     ;;
 595     ;; fontify case targets and goto-tags.  This is slow because the
 596     ;; expression is anchored on the right.
 597     '("[ \t\n]\\(\\(\\sw\\|\\s_\\)+\\):" . 1)
 598     ;;
 599     ;; Fontify variables declared with structures, or typedef names.
 600     '("}[ \t*]*\\(\\(\\sw\\|\\s_\\)+\\)[ \t]*[,;]"
 601       1 font-lock-function-name-face)
 602     ;;
 603     ;; Fontify global variables without a type.
 604 ;    '("^\\([_a-zA-Z0-9:~*]+\\)[ \t]*[[;={]" 1 font-lock-function-name-face)
 605     )))
 606
 607  (setq c++-font-lock-keywords-1
 608        (cons
 609         (concat "\\(" c++-things "\\)[ \t\n]")
 610         c-font-lock-keywords-1))
 611  (setq c++-font-lock-keywords-2
 612        (cons
 613         (cons (concat "\\<\\(" c++-things "\\)\\>") 'font-lock-type-face)
 614         c-font-lock-keywords-2))
 615  )
 616
 617 ; default to the gaudier variety?
 618 (defvar c-font-lock-keywords c-font-lock-keywords-1
 619   "Additional expressions to highlight in C mode.")
 620
 621 (defvar c++-font-lock-keywords c++-font-lock-keywords-1
 622   "Additional expressions to highlight in C++ mode.")
 623
 624
 625 (defvar perl-font-lock-keywords
 626   (list
 627    (cons (concat "[ \n\t{]*\\("
 628                  (mapconcat 'identity
 629                             '("if" "until" "while" "elsif" "else" "unless" "for"
 630                               "foreach" "continue" "exit" "die" "last" "goto" "next"
 631                               "redo" "return" "local" "exec")
 632                             "\\|")
 633                  "\\)[ \n\t;(]") 1)
 634    (mapconcat 'identity
 635               '("#endif" "#else" "#ifdef" "#ifndef" "#if" "#include"
 636                 "#define" "#undef")
 637               "\\|")
 638    '("^[ \n\t]*sub[ \t]+\\([^ \t{]+\\)[ \t]*[{]" 1 font-lock-function-name-face)
 639    '("[ \n\t{]*\\(eval\\)[ \n\t(;]" 1 font-lock-function-name-face)
 640    '("\\(--- .* ---\\|=== .* ===\\)" . font-lock-doc-string-face)
 641    )
 642   "Additional expressions to highlight in Perl mode.")
 643
 644 (defvar tex-font-lock-keywords
 645   (list
 646    '("\\(\\\\\\([a-zA-Z@]+\\|.\\)\\)" 1 font-lock-keyword-face t)
 647    '("{\\\\em\\([^}]+\\)}" 1 font-lock-comment-face t)
 648    '("{\\\\bf\\([^}]+\\)}" 1 font-lock-keyword-face t)
 649    '("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face t)
 650    '("\\\\\\(begin\\|end\\){\\([a-zA-Z0-9\\*]+\\)}"
 651      2 font-lock-function-name-face t)
 652    '("[^\\\\]\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 653 ;   '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 654    )
 655   "Additional expressions to highlight in TeX mode.")
 656
 657 (defvar texi-font-lock-keywords
 658   (list
 659    "@\\(@\\|[^}\t \n{]+\\)"                                     ;commands
 660    '("^\\(@c\\|@comment\\)[ \t].*$" . font-lock-comment-face)   ;comments
 661    '("^\\(*.*\\)[\t ]*$" 1 font-lock-function-name-face t)      ;menu items
 662    '("@\\(emph\\|strong\\|b\\|i\\){\\([^}]+\\)" 2 font-lock-comment-face t)
 663    '("@\\(file\\|kbd\\|key\\){\\([^}]+\\)" 2 font-lock-string-face t)
 664    '("@\\(samp\\|code\\|var\\){\\([^}]+\\)" 2 font-lock-function-name-face t)
 665    '("@\\(xref\\|pxref\\){\\([^}]+\\)" 2 font-lock-keyword-face t)
 666    '("@end *\\([a-zA-Z0-9]+\\)[ \t]*$" 1 font-lock-function-name-face t)
 667    '("@item \\(.*\\)$" 1 font-lock-function-name-face t)
 668    '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 669    )
 670   "Additional expressions to highlight in TeXinfo mode.")
 671
 672 (defvar shell-font-lock-keywords
 673   (list (cons shell-prompt-pattern 'font-lock-keyword-face)
 674         '("[ \t]\\([+-][^ \t\n]+\\)" 1 font-lock-comment-face)
 675         '("^[^ \t]+:.*$" . font-lock-string-face)
 676         '("^\\[[1-9][0-9]*\\]" . font-lock-string-face))
 677   "Additional expressions to highlight in Shell mode.")
 678
 679 (defvar dired-font-lock-keywords
 680   '(;; Put directory headers in italics.
 681     ("^  \\(/.+\\)$" 1 font-lock-type-face)
 682     ;; Put symlinks in bold italics.
 683     ("\\([^ ]+\\) -> [^ ]+$" . font-lock-function-name-face)
 684     ;; Put marks in bold.
 685     ("^\\([^ ]\\).*$" 1 font-lock-keyword-face t)
 686     ;; Put files that are subdirectories in bold.
 687     ("^..d.* \\([^ ]+\\)$" 1 font-lock-keyword-face))
 688   "Additional expressions to highlight in Dired mode.")
 689
 690 (defvar rmail-font-lock-keywords
 691   '(;; Put From field in bold.
 692     ("^From: \\(.*\\)$" 1 font-lock-keyword-face)
 693     ;; Put subject in bold italics
 694     ("^Subject: \\(.*\\)$" 1 font-lock-function-name-face))
 695   "Additional expressions to highlight in Rmail mode.")
 696
 697 (defvar rmail-summary-font-lock-keywords
 698   '(("^\\s *[0-9]+D.*$" . font-lock-doc-string-face)
 699     ("^\\s *[0-9]+-.*$" . font-lock-keyword-face))
 700   "Additional expressions to highlight in Rmail Summary mode.")
 701
 702 (defvar compilation-mode-font-lock-keywords
 703   '(("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 1 font-lock-function-name-face))
 704 ;;;  ("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 0 font-lock-keyword-face keep)
 705   "Additional expressions to highlight in Compilation mode.")
 706
 707 (defun font-lock-set-defaults ()
 708   "Set `font-lock-keywords' to something appropriate for this mode."
 709   (if (memq major-mode '(rmail-mode dired-mode compilation-mode shell-mode))
 710       (setq font-lock-no-comments t))
 711   (if (not font-lock-keywords)          ; if not already set.
 712       (setq font-lock-keywords
 713             (cond ((eq major-mode 'lisp-mode)       lisp-font-lock-keywords)
 714                   ((eq major-mode 'emacs-lisp-mode) lisp-font-lock-keywords)
 715                   ((eq major-mode 'c-mode)
 716                    (make-local-variable 'font-lock-syntax-table)
 717                    (setq font-lock-syntax-table
 718                          (copy-syntax-table (syntax-table)))
 719                    (modify-syntax-entry ?_ "w" font-lock-syntax-table)
 720                    c-font-lock-keywords)
 721                   ((eq major-mode 'c++-c-mode)
 722                    (make-local-variable 'font-lock-syntax-table)
 723                    (setq font-lock-syntax-table
 724                          (copy-syntax-table (syntax-table)))
 725                    (modify-syntax-entry ?_ "w" font-lock-syntax-table)
 726                    c-font-lock-keywords)
 727                   ((eq major-mode 'c++-mode)        c++-font-lock-keywords)
 728                   ((eq major-mode 'perl-mode)       perl-font-lock-keywords)
 729                   ((eq major-mode 'plain-tex-mode)  tex-font-lock-keywords)
 730                   ((eq major-mode 'latex-mode)      tex-font-lock-keywords)
 731                   ((eq major-mode 'slitex-mode)     tex-font-lock-keywords)
 732                   ((eq major-mode 'texinfo-mode)    texi-font-lock-keywords)
 733                   ((eq major-mode 'shell-mode)      shell-font-lock-keywords)
 734                   ((eq major-mode 'dired-mode)      dired-font-lock-keywords)
 735                   ((eq major-mode 'rmail-mode)      rmail-font-lock-keywords)
 736                   ((eq major-mode 'rmail-summary-mode)
 737                    rmail-summary-font-lock-keywords)
 738                   ((eq major-mode 'compilation-mode)
 739                    compilation-mode-font-lock-keywords)
 740                   (t nil)))))
 741
 742 (provide 'font-lock)
 743
 744 ;;; font-lock.el ends here