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

   1 ;; Electric Font Lock Mode
   2 ;; Copyright (C) 1992, 1993 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 (internal-find-face 'underline)
  58     (copy-face 'default 'underline))
  59 (set-face-underline-p 'underline t)
  60
  61 (defvar font-lock-comment-face
  62   'italic
  63   "Face to use for comments.")
  64
  65 (defvar font-lock-doc-string-face
  66   'italic
  67   "Face to use for documentation strings.")
  68
  69 (defvar font-lock-string-face
  70   'underline
  71   "Face to use for string constants.")
  72
  73 (defvar font-lock-function-name-face
  74   'bold-italic
  75   "Face to use for function names.")
  76
  77 (defvar font-lock-keyword-face
  78   'bold
  79   "Face to use for keywords.")
  80
  81 (defvar font-lock-type-face
  82   'italic
  83   "Face to use for data types.")
  84
  85 (make-variable-buffer-local 'font-lock-keywords)
  86 (defvar font-lock-keywords nil
  87   "*The keywords to highlight.
  88 If this is a list, then elements may be of the forms:
  89
  90   \"string\"                      ; A regexp to highlight in the
  91                                   ;  `font-lock-keyword-face'.
  92   (\"string\" . N)                ; Highlight subexpression N of the regexp.
  93   (\"string\" . face-name)        ; Use the named face
  94   (\"string\" N face-name)        ; Both of the above
  95   (\"string\" N face-name t)      ; This allows highlighting to override
  96                                   ;  already-highlighted regions.
  97   (\"string\" N face-name keep)   ; This allows highlighting to occur
  98                                   ; even if some parts of what STRING matches
  99                                   ; are already highlighted--but does not alter
 100                                   ; the existing highlighting of those parts.
 101
 102 These regular expressions should not match text which spans lines.
 103 While \\[font-lock-fontify-buffer] handles multi-line patterns correctly,
 104 updating when you edit the buffer does not,
 105 since it considers text one line at a time.
 106
 107 Be careful composing regexps for this list; the wrong pattern can dramatically
 108 slow things down!")
 109
 110 (defvar font-lock-keywords-case-fold-search nil
 111   "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.")
 112
 113 (defvar font-lock-verbose t
 114   "*Non-nil means `font-lock-fontify-buffer' should print status messages.")
 115
 116 ;;;###autoload
 117 (defvar font-lock-mode-hook nil
 118   "Function or functions to run on entry to Font Lock mode.")
 119
 120 ;;; These variables record, for each buffer,
 121 ;;; the parse state at a particular position, always the start of a line.
 122 ;;; This is used to make font-lock-fontify-region faster.
 123 (defvar font-lock-cache-position nil)
 124 (defvar font-lock-cache-state nil)
 125 (make-variable-buffer-local 'font-lock-cache-position)
 126 (make-variable-buffer-local 'font-lock-cache-state)
 127
 128 (defun font-lock-fontify-region (start end)
 129   "Put proper face on each string and comment between START and END."
 130   (save-excursion
 131     (goto-char start)
 132     (beginning-of-line)
 133     (setq end (min end (point-max)))
 134     (let ((buffer-read-only nil)
 135           state startline prev prevstate
 136           (modified (buffer-modified-p)))
 137       ;; Find the state at the line-beginning before START.
 138       (setq startline (point))
 139       (if (eq (point) font-lock-cache-position)
 140           (setq state font-lock-cache-state)
 141         ;; Find outermost containing sexp.
 142         (beginning-of-defun)
 143         ;; Find the state at STARTLINE.
 144         (while (< (point) startline)
 145           (setq state (parse-partial-sexp (point) startline 0)))
 146         (setq font-lock-cache-state state
 147               font-lock-cache-position (point)))
 148       ;; Now find the state precisely at START.
 149       (setq state (parse-partial-sexp (point) start nil nil state))
 150       ;; If the region starts inside a string, show the extent of it.
 151       (if (nth 3 state)
 152           (let ((beg (point)))
 153             (while (and (re-search-forward "\\s\"" end 'move)
 154                         (nth 3 (parse-partial-sexp beg (point)
 155                                                    nil nil state))))
 156             (put-text-property beg (point) 'face font-lock-string-face)
 157             (setq state (parse-partial-sexp beg (point) nil nil state))))
 158       ;; Likewise for a comment.
 159       (if (or (nth 4 state) (nth 7 state))
 160           (let ((beg (point)))
 161             (while (and (re-search-forward (if comment-end
 162                                                (concat "\\s>\\|"
 163                                                        (regexp-quote comment-end))
 164                                              "\\s>")
 165                                            end 'move)
 166                         (nth 3 (parse-partial-sexp beg (point)
 167                                                    nil nil state))))
 168             (put-text-property beg (point) 'face font-lock-comment-face)
 169             (setq state (parse-partial-sexp beg (point) nil nil state))))
 170       ;; Find each interesting place between here and END.
 171       (while (and (< (point) end)
 172                   (setq prev (point) prevstate state)
 173                   (re-search-forward (if comment-start-skip
 174                                          (concat "\\s\"\\|" comment-start-skip)
 175                                        "\\s\"")
 176                                      end t)
 177                   ;; Clear out the fonts of what we skip over.
 178                   (progn (remove-text-properties prev (point) '(face nil)) t)
 179                   ;; Verify the state at that place
 180                   ;; so we don't get fooled by \" or \;.
 181                   (setq state (parse-partial-sexp prev (point)
 182                                                   nil nil state)))
 183         (let ((here (point)))
 184           (if (or (nth 4 state) (nth 7 state))
 185               ;; We found a real comment start.
 186               (let ((beg (match-beginning 0)))
 187                 (goto-char beg)
 188                 (save-restriction
 189                   (narrow-to-region (point-min) end)
 190                   (condition-case nil
 191                       (progn
 192                         (forward-comment 1)
 193                         ;; forward-comment skips all whitespace,
 194                         ;; so go back to the real end of the comment.
 195                         (skip-chars-backward " \t"))
 196                     (error (goto-char end))))
 197                 (put-text-property beg (point) 'face font-lock-comment-face)
 198                 (setq state (parse-partial-sexp here (point) nil nil state)))
 199             (if (nth 3 state)
 200                 (let ((beg (match-beginning 0)))
 201                   (while (and (re-search-forward "\\s\"" end 'move)
 202                               (nth 3 (parse-partial-sexp here (point)
 203                                                          nil nil state))))
 204                   (put-text-property beg (point) 'face font-lock-string-face)
 205                   (setq state (parse-partial-sexp here (point) nil nil state))))
 206               ))
 207         ;; Make sure PREV is non-nil after the loop
 208         ;; only if it was set on the very last iteration.
 209         (setq prev nil))
 210       (and prev
 211            (remove-text-properties prev end '(face nil)))
 212       (set-buffer-modified-p modified))))
 213
 214 ;; This code used to be used to show a string on reaching the end of it.
 215 ;; It is probably not needed due to later changes to handle strings
 216 ;; starting before the region in question.
 217 ;;          (if (and (null (nth 3 state))
 218 ;;                   (eq (char-syntax (preceding-char)) ?\")
 219 ;;                   (save-excursion
 220 ;;                     (nth 3 (parse-partial-sexp prev (1- (point))
 221 ;;                                                nil nil prevstate))))
 222 ;;              ;; We found the end of a string.
 223 ;;              (save-excursion
 224 ;;                (setq foo2 (point))
 225 ;;                (let ((ept (point)))
 226 ;;                  (forward-sexp -1)
 227 ;;                  ;; Highlight the string when we see the end.
 228 ;;                  ;; Doing it at the start leads to trouble:
 229 ;;                  ;; either it fails to handle multiline strings
 230 ;;                  ;; or it can run away when an unmatched " is inserted.
 231 ;;                  (put-text-property (point) ept 'face
 232 ;;                                     (if (= (car state) 1)
 233 ;;                                         font-lock-doc-string-face
 234 ;;                                       font-lock-string-face)))))
 235
 236 (defun font-lock-unfontify-region (beg end)
 237   (let ((modified (buffer-modified-p))
 238         (buffer-read-only nil))
 239     (remove-text-properties beg end '(face nil))
 240     (set-buffer-modified-p modified)))
 241
 242 ;; Called when any modification is made to buffer text.
 243 (defun font-lock-after-change-function (beg end old-len)
 244   (save-excursion
 245     (save-match-data
 246       (goto-char beg)
 247       ;; Discard the cache info if text before it has changed.
 248       (and font-lock-cache-position
 249            (> font-lock-cache-position beg)
 250            (setq font-lock-cache-position nil))
 251       ;; Rescan till end of line.  yes!
 252       (goto-char end)
 253       (end-of-line)
 254       (setq end (point))
 255       (goto-char beg)
 256       (beginning-of-line)
 257       (setq beg (point))
 258       ;; First scan for strings and comments.
 259       ;; Must scan from line start in case of
 260       ;; inserting space into `intfoo () {}'.
 261       (font-lock-fontify-region beg (1+ end))
 262       ;; Now scan for keywords.
 263       (font-lock-hack-keywords beg end))))
 264 \f
 265 ;;; Fontifying arbitrary patterns
 266
 267 (defsubst font-lock-any-properties-p (start end)
 268   (or (get-text-property start 'face)
 269       (let ((next (next-single-property-change start 'face)))
 270         (and next (< next end)))))
 271
 272 (defun font-lock-hack-keywords (start end &optional loudly)
 273   (goto-char start)
 274   (let ((case-fold-search font-lock-keywords-case-fold-search)
 275         (rest font-lock-keywords)
 276         (count 0)
 277         (buffer-read-only nil)
 278         (modified (buffer-modified-p))
 279         first str match face s e allow-overlap-p)
 280     (while rest
 281       (setq first (car rest) rest (cdr rest))
 282       (goto-char start)
 283       (cond ((consp first)
 284              (setq str (car first))
 285              (cond ((consp (cdr first))
 286                     (setq match (nth 1 first)
 287                           face (eval (nth 2 first))
 288                           allow-overlap-p (nth 3 first)))
 289                    ((symbolp (cdr first))
 290                     (setq match 0 allow-overlap-p nil
 291                           face (eval (cdr first))))
 292                    (t
 293                     (setq match (cdr first)
 294                           allow-overlap-p nil
 295                           face font-lock-keyword-face))))
 296             (t
 297              (setq str first match 0 allow-overlap-p nil
 298                    face font-lock-keyword-face)))
 299       ;(message "regexp: %s" str)
 300       (while (re-search-forward str end t)
 301         (setq s (match-beginning match)
 302               e (match-end match))
 303         (or s (error "expression did not match subexpression %d" match))
 304         ;; don't fontify this keyword if we're already in some other context.
 305         (or (if allow-overlap-p nil (font-lock-any-properties-p s e))
 306             (if (not (memq allow-overlap-p '(t nil)))
 307                 (save-excursion
 308                   (goto-char s)
 309                   (save-restriction
 310                     (narrow-to-region s e)
 311                     (while (not (eobp))
 312                       (let ((next (next-single-property-change (point) 'face)))
 313                         (if (or (null next) (> next (point-max)))
 314                             (setq next (point-max)))
 315                         (if (not (get-text-property (point) 'face))
 316                             (put-text-property (point) next 'face face))
 317                         (goto-char next)))))
 318               (put-text-property s e 'face face))))
 319       (if loudly (message "Fontifying %s... (regexps...%s)"
 320                           (buffer-name)
 321                           (make-string (setq count (1+ count)) ?.))))
 322     (set-buffer-modified-p modified)))
 323 \f
 324 ;; The user level functions
 325
 326 (defvar font-lock-mode nil) ; for modeline
 327 (or (assq 'font-lock-mode minor-mode-alist)
 328     (setq minor-mode-alist
 329           (append minor-mode-alist
 330                   '((font-lock-mode " Font")))))
 331
 332 (defvar font-lock-fontified nil) ; whether we have hacked this buffer
 333 (put 'font-lock-fontified 'permanent-local t)
 334
 335 ;;;###autoload
 336 (defun font-lock-mode (&optional arg)
 337   "Toggle Font Lock mode.
 338 With arg, turn Font Lock mode on if and only if arg is positive.
 339
 340 When Font Lock mode is enabled, text is fontified as you type it:
 341
 342  - comments are displayed in `font-lock-comment-face';
 343      (That is a variable whose value should be a face name.)
 344  - strings are displayed in `font-lock-string-face';
 345  - documentation strings are displayed in `font-lock-doc-string-face';
 346  - function and variable names in their defining forms are displayed
 347    in `font-lock-function-name-face';
 348  - and certain other expressions are displayed in other faces
 349    according to the value of the variable `font-lock-keywords'.
 350
 351 When you turn Font Lock mode on/off, the buffer is fontified/defontified.
 352 To fontify a buffer without having newly typed text become fontified, you
 353 can use \\[font-lock-fontify-buffer]."
 354   (interactive "P")
 355   (let ((on-p (if (null arg)
 356                   (not font-lock-mode)
 357                 (> (prefix-numeric-value arg) 0))))
 358     (if (equal (buffer-name) " *Compiler Input*") ; hack for bytecomp...
 359         (setq on-p nil))
 360     (or (memq after-change-function
 361               '(nil font-lock-after-change-function))
 362         (error "after-change-function is %s" after-change-function))
 363     (set (make-local-variable 'after-change-function)
 364          (if on-p 'font-lock-after-change-function nil))
 365     (set (make-local-variable 'font-lock-mode) on-p)
 366     (cond (on-p
 367            (font-lock-set-defaults)
 368            (make-local-variable 'before-revert-hook)
 369            (make-local-variable 'after-revert-hook)
 370            ;; If buffer is reverted, must clean up the state.
 371            (add-hook 'before-revert-hook 'font-lock-revert-setup)
 372            (add-hook 'after-revert-hook 'font-lock-revert-cleanup)
 373            (run-hooks 'font-lock-mode-hook)
 374            (or font-lock-fontified (font-lock-fontify-buffer)))
 375           (font-lock-fontified
 376            (setq font-lock-fontified nil)
 377            (remove-hook 'before-revert-hook 'font-lock-revert-setup)
 378            (remove-hook 'after-revert-hook 'font-lock-revert-cleanup)
 379            (font-lock-unfontify-region (point-min) (point-max))))
 380     (force-mode-line-update)))
 381
 382 ;; If the buffer is about to be reverted, it won't be fontified.
 383 (defun font-lock-revert-setup ()
 384   (setq font-lock-fontified nil))
 385
 386 ;; If the buffer has just been reverted, we might not even be in font-lock
 387 ;; mode anymore, and if we are, the buffer may or may not have already been
 388 ;; refontified.  Refontify here if it looks like we need to.
 389 (defun font-lock-revert-cleanup ()
 390   (and font-lock-mode
 391        (not font-lock-fontified)
 392        (font-lock-mode 1)))
 393
 394 (defun font-lock-fontify-buffer ()
 395   "Fontify the current buffer the way `font-lock-mode' would:
 396
 397  - comments are displayed in `font-lock-comment-face';
 398  - strings are displayed in `font-lock-string-face';
 399  - documentation strings are displayed in `font-lock-doc-string-face';
 400  - function and variable names in their defining forms are displayed
 401    in `font-lock-function-name-face';
 402  - and certain other expressions are displayed in other faces
 403    according to the value of the variable `font-lock-keywords'.
 404
 405 This can take a while for large buffers."
 406   (interactive)
 407   (let ((was-on font-lock-mode)
 408         (font-lock-verbose (or font-lock-verbose (interactive-p))))
 409     (if font-lock-verbose (message "Fontifying %s..." (buffer-name)))
 410     ;; Turn it on to run hooks and get the right font-lock-keywords.
 411     (or was-on (font-lock-set-defaults))
 412     (font-lock-unfontify-region (point-min) (point-max))
 413     (if font-lock-verbose (message "Fontifying %s... (syntactically...)"
 414                                    (buffer-name)))
 415 ;;    (buffer-syntactic-context-flush-cache)
 416     (save-excursion
 417       (font-lock-fontify-region (point-min) (point-max))
 418       (if font-lock-verbose (message "Fontifying %s... (regexps...)"
 419                                      (buffer-name)))
 420       (font-lock-hack-keywords (point-min) (point-max) font-lock-verbose))
 421     (set (make-local-variable 'font-lock-fontified) t)
 422     (if font-lock-verbose (message "Fontifying %s... done." (buffer-name)))
 423     ))
 424
 425 \f
 426 ;;; Various mode-specific information.
 427
 428 (defun font-lock-set-defaults ()
 429   "Set `font-lock-keywords' to something appropriate for this mode."
 430   (if (not font-lock-keywords)          ; if not already set.
 431       (setq font-lock-keywords
 432             (cond ((eq major-mode 'lisp-mode)       lisp-font-lock-keywords)
 433                   ((eq major-mode 'emacs-lisp-mode) lisp-font-lock-keywords)
 434                   ((eq major-mode 'c-mode)          c-font-lock-keywords)
 435                   ((eq major-mode 'c++-c-mode)      c-font-lock-keywords)
 436                   ((eq major-mode 'c++-mode)        c++-font-lock-keywords)
 437                   ((eq major-mode 'perl-mode)       perl-font-lock-keywords)
 438                   ((eq major-mode 'tex-mode)        tex-font-lock-keywords)
 439                   ((eq major-mode 'texinfo-mode)    texi-font-lock-keywords)
 440                   (t nil)))))
 441
 442 (defconst lisp-font-lock-keywords-1
 443  '(;;
 444    ;; highlight defining forms.  This doesn't work too nicely for
 445    ;; (defun (setf foo) ...) but it does work for (defvar foo) which
 446    ;; is more important.
 447    ("^(def[-a-z]+\\s +\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face)
 448    ;;
 449    ;; highlight CL keywords
 450    ("\\s :\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
 451    ;;
 452    ;; this is highlights things like (def* (setf foo) (bar baz)), but may
 453    ;; be slower (I haven't really thought about it)
 454 ;   ("^(def[-a-z]+\\s +\\(\\s(\\S)*\\s)\\|\\S(\\S *\\)"
 455 ;    1 font-lock-function-name-face)
 456    )
 457  "For consideration as a value of `lisp-font-lock-keywords'.
 458 This does fairly subdued highlighting.")
 459
 460 (defconst lisp-font-lock-keywords-2
 461   (append
 462    lisp-font-lock-keywords-1
 463    '(;;
 464      ;; Highlight control structures
 465      ("(\\(cond\\|if\\|when\\|unless\\|[ec]?\\(type\\)?case\\)[ \t\n]" . 1)
 466      ("(\\(while\\|do\\|let*?\\|flet\\|labels\\|prog[nv12*]?\\)[ \t\n]" . 1)
 467      ("(\\(catch\\|\\throw\\|block\\|return\\|return-from\\)[ \t\n]" . 1)
 468      ("(\\(save-restriction\\|save-window-restriction\\)[ \t\n]" . 1)
 469      ("(\\(save-excursion\\|unwind-protect\\|condition-case\\)[ \t\n]" . 1)
 470      ;;
 471      ;; highlight function names in emacs-lisp docstrings (in the syntax
 472      ;; that substitute-command-keys understands.)
 473      ("\\\\\\\\\\[\\([^]\\\n]+\\)]" 1 font-lock-keyword-face t)
 474      ;;
 475      ;; highlight words inside `' which tend to be function names
 476      ("`\\([-a-zA-Z0-9_][-a-zA-Z0-9_][-a-zA-Z0-9_.]+\\)'"
 477       1 font-lock-keyword-face t)
 478      ))
 479  "For consideration as a value of `lisp-font-lock-keywords'.
 480 This does a lot more highlighting.")
 481
 482 ;; default to the gaudier variety?
 483 ;(defvar lisp-font-lock-keywords lisp-font-lock-keywords-2
 484 ;  "Additional expressions to highlight in Lisp modes.")
 485 (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
 486   "Additional expressions to highlight in Lisp modes.")
 487
 488
 489 (defconst c-font-lock-keywords-1 nil
 490  "For consideration as a value of `c-font-lock-keywords'.
 491 This does fairly subdued highlighting.")
 492
 493 (defconst c-font-lock-keywords-2 nil
 494  "For consideration as a value of `c-font-lock-keywords'.
 495 This does a lot more highlighting.")
 496
 497 (let ((storage "auto\\|extern\\|register\\|static\\|volatile")
 498       (prefixes "unsigned\\|short\\|long")
 499       (types (concat "int\\|char\\|float\\|double\\|void\\|struct\\|"
 500                      "union\\|enum\\|typedef"))
 501       (ctoken "[a-zA-Z0-9_:~*]+")
 502       )
 503   (setq c-font-lock-keywords-1
 504    (list
 505     ;; fontify preprocessor directives as comments.
 506     '("^#[ \t]*[a-z]+" . font-lock-comment-face)
 507     ;;
 508     ;; fontify names being defined.
 509     '("^#[ \t]*\\(define\\|undef\\)[ \t]+\\(\\(\\sw\\|\\s_\\)+\\)" 2
 510       font-lock-function-name-face)
 511     ;;
 512     ;; fontify other preprocessor lines.
 513     '("^#[ \t]*\\(if\\)[ \t]+\\([^\n]+\\)"
 514       2 font-lock-function-name-face keep)
 515     '("^#[ \t]*\\(endif\\|else\\)[ \t]+\\([^\n]+\\)"
 516       2 font-lock-function-name-face keep)
 517     '("^#[ \t]*\\(ifn?def\\)[ \t]+\\([^ \t\n]+\\)"
 518       2 font-lock-function-name-face t)
 519     ;;
 520     ;; fontify the filename in #include <...>
 521     ;; don't need to do this for #include "..." because those were
 522     ;; already fontified as strings by the syntactic pass.
 523     '("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face)
 524     ;;
 525     ;; fontify the names of functions being defined.
 526     (list (concat
 527            "^\\(" ctoken "[ \t]+\\)?"   ; type specs; there can be no
 528            "\\(" ctoken "[ \t]+\\)?"    ; more than 3 tokens, right?
 529            "\\(" ctoken "[ \t]+\\)?"
 530            "\\([*&]+[ \t]*\\)?"         ; pointer
 531            "\\(" ctoken "\\)[ \t]*(")           ; name
 532           5 'font-lock-function-name-face)
 533     ;;
 534     ;;
 535     ;; Fontify structure names (in structure definition form).
 536     (list (concat "^\\(typedef[ \t]+struct\\|struct\\|static[ \t]+struct\\)"
 537                   "[ \t]+\\(" ctoken "\\)[ \t]*\\(\{\\|$\\)")
 538           2 'font-lock-function-name-face)
 539     ;;
 540     ;; Fontify case clauses.  This is fast because its anchored on the left.
 541     '("case[ \t]+\\(\\(\\sw\\|\\s_\\)+\\):". 1)
 542     '("\\<\\(default\\):". 1)
 543     ))
 544
 545   (setq c-font-lock-keywords-2
 546    (append c-font-lock-keywords-1
 547     (list
 548      ;;
 549      ;; fontify all storage classes and type specifiers
 550      (cons (concat "\\<\\(" storage "\\)\\>") 'font-lock-type-face)
 551      (cons (concat "\\<\\(" types "\\)\\>") 'font-lock-type-face)
 552      (cons (concat "\\<\\(" prefixes "[ \t]+" types "\\)\\>")
 553            'font-lock-type-face)
 554      ;;
 555      ;; fontify all builtin tokens
 556      (cons (concat
 557             "[ \t]\\("
 558             (mapconcat 'identity
 559              '("for" "while" "do" "return" "goto" "case" "break" "switch"
 560                "if" "then" "else if" "else" "return" "default" "continue"
 561                "default"
 562                )
 563              "\\|")
 564             "\\)[ \t\n(){};,]")
 565            1)
 566      ;;
 567      ;; fontify case targets and goto-tags.  This is slow because the
 568      ;; expression is anchored on the right.
 569      "\\(\\(\\sw\\|\\s_\\)+\\):"
 570      ;;
 571      ;; Fontify variables declared with structures, or typedef names.
 572      '("}[ \t*]*\\(\\(\\sw\\|\\s_\\)+\\)[ \t]*[,;]"
 573        1 font-lock-function-name-face)
 574      ;;
 575      ;; Fontify global variables without a type.
 576 ;     '("^\\([_a-zA-Z0-9:~*]+\\)[ \t]*[[;={]" 1 font-lock-function-name-face)
 577
 578      )))
 579   )
 580
 581 ; default to the gaudier variety?
 582 ;(defvar c-font-lock-keywords c-font-lock-keywords-2
 583 ;  "Additional expressions to highlight in C mode.")
 584 (defvar c-font-lock-keywords c-font-lock-keywords-1
 585   "Additional expressions to highlight in C mode.")
 586
 587 (defvar c++-font-lock-keywords c-font-lock-keywords
 588   "Additional expressions to highlight in C++ mode.")
 589
 590
 591 (defvar perl-font-lock-keywords
 592   (list
 593    (cons (concat "[ \n\t{]*\\("
 594                  (mapconcat 'identity
 595                             '("if" "until" "while" "elsif" "else" "unless" "for"
 596                               "foreach" "continue" "exit" "die" "last" "goto" "next"
 597                               "redo" "return" "local" "exec")
 598                             "\\|")
 599                  "\\)[ \n\t;(]") 1)
 600    (mapconcat 'identity
 601               '("#endif" "#else" "#ifdef" "#ifndef" "#if" "#include"
 602                 "#define" "#undef")
 603               "\\|")
 604    '("^[ \n\t]*sub[ \t]+\\([^ \t{]+\\)[ \t]*[{]" 1 font-lock-function-name-face)
 605    '("[ \n\t{]*\\(eval\\)[ \n\t(;]" 1 font-lock-function-name-face)
 606    '("\\(--- .* ---\\|=== .* ===\\)" . font-lock-doc-string-face)
 607    )
 608   "Additional expressions to highlight in Perl mode.")
 609
 610 (defvar tex-font-lock-keywords
 611   (list
 612    '("\\(\\\\\\w+\\)" 1 font-lock-keyword-face t)
 613    '("{\\\\em\\([^}]+\\)}" 1 font-lock-comment-face t)
 614    '("{\\\\bf\\([^}]+\\)}" 1 font-lock-keyword-face t)
 615    '("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face t)
 616    '("\\\\\\(begin\\|end\\){\\([a-zA-Z0-9\\*]+\\)}"
 617      2 font-lock-function-name-face t)
 618    '("[^\\\\]\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 619 ;   '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 620    )
 621   "Additional expressions to highlight in TeX mode.")
 622
 623 (defvar texi-font-lock-keywords
 624   (list
 625    "@\\(@\\|[^}\t \n{]+\\)"                                     ;commands
 626    '("^\\(@c\\|@comment\\)[ \t].*$" . font-lock-comment-face)   ;comments
 627    '("^\\(*.*\\)[\t ]*$" 1 font-lock-function-name-face t)      ;menu items
 628    '("@\\(emph\\|strong\\|b\\|i\\){\\([^}]+\\)" 2 font-lock-comment-face t)
 629    '("@\\(file\\|kbd\\|key\\){\\([^}]+\\)" 2 font-lock-string-face t)
 630    '("@\\(samp\\|code\\|var\\){\\([^}]+\\)" 2 font-lock-function-name-face t)
 631    '("@\\(xref\\|pxref\\){\\([^}]+\\)" 2 font-lock-keyword-face t)
 632    '("@end *\\([a-zA-Z0-9]+\\)[ \t]*$" 1 font-lock-function-name-face t)
 633    '("@item \\(.*\\)$" 1 font-lock-function-name-face t)
 634    '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
 635    )
 636   "Additional expressions to highlight in TeXinfo mode.")
 637
 638 (provide 'font-lock)
 639
 640 ;;; font-lock.el ends here