mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-23 10:34:07 +00:00
Initial revision
This commit is contained in:
Richard M. Stallman
parent
72a339d7e3
commit
030f4a352d
589
lisp/font-lock.el
Normal file
589
lisp/font-lock.el
Normal file
@ -0,0 +1,589 @@
|
||||
;; Electric Font Lock Mode
|
||||
;; Copyright (C) 1992, 1993 Free Software Foundation, Inc.
|
||||
|
||||
;; Author: jwz, then rms
|
||||
;; Maintainer: FSF
|
||||
;; Keywords: languages, faces
|
||||
|
||||
;; This file is part of GNU Emacs.
|
||||
|
||||
;; GNU Emacs is free software; you can redistribute it and/or modify
|
||||
;; it under the terms of the GNU General Public License as published by
|
||||
;; the Free Software Foundation; either version 2, or (at your option)
|
||||
;; any later version.
|
||||
|
||||
;; GNU Emacs is distributed in the hope that it will be useful,
|
||||
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
;; GNU General Public License for more details.
|
||||
|
||||
;; You should have received a copy of the GNU General Public License
|
||||
;; along with GNU Emacs; see the file COPYING. If not, write to
|
||||
;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
|
||||
;;; Commentary:
|
||||
|
||||
;; Font-lock-mode is a minor mode that causes your comments to be
|
||||
;; displayed in one face, strings in another, reserved words in another,
|
||||
;; documentation strings in another, and so on.
|
||||
;;
|
||||
;; Comments will be displayed in `font-lock-comment-face'.
|
||||
;; Strings will be displayed in `font-lock-string-face'.
|
||||
;; Doc strings will be displayed in `font-lock-doc-string-face'.
|
||||
;; Function and variable names (in their defining forms) will be
|
||||
;; displayed in `font-lock-function-name-face'.
|
||||
;; Reserved words will be displayed in `font-lock-keyword-face'.
|
||||
;;
|
||||
;; To make the text you type be fontified, use M-x font-lock-mode.
|
||||
;; When this minor mode is on, the fonts of the current line are
|
||||
;; updated with every insertion or deletion.
|
||||
;;
|
||||
;; To define new reserved words or other patterns to highlight, use
|
||||
;; the `font-lock-keywords' variable. This should be mode-local.
|
||||
;;
|
||||
;; To turn this on automatically, add this to your .emacs file:
|
||||
;;
|
||||
;; (setq emacs-lisp-mode-hook '(lambda () (font-lock-mode 1)))
|
||||
;;
|
||||
;; On a Sparc2, the initial fontification takes about 12 seconds for a 120k
|
||||
;; file of C code, using the default configuration. You can speed this up
|
||||
;; substantially by removing some of the patterns that are highlighted by
|
||||
;; default. Fontifying Lisp code is significantly faster, because Lisp has a
|
||||
;; more regular syntax than C, so the expressions don't have to be as hairy.
|
||||
|
||||
;;; Code:
|
||||
|
||||
(or (internal-find-face 'underline)
|
||||
(copy-face 'default 'underline))
|
||||
(set-face-underline-p 'underline t)
|
||||
|
||||
(defvar font-lock-comment-face
|
||||
'italic
|
||||
"Face to use for comments.")
|
||||
|
||||
(defvar font-lock-doc-string-face
|
||||
'italic
|
||||
"Face to use for documentation strings.")
|
||||
|
||||
(defvar font-lock-string-face
|
||||
'underline
|
||||
"Face to use for string constants.")
|
||||
|
||||
(defvar font-lock-function-face
|
||||
'bold-italic
|
||||
"Face to use for function names.")
|
||||
|
||||
(defvar font-lock-keyword-face
|
||||
'bold
|
||||
"Face to use for keywords.")
|
||||
|
||||
(defvar font-lock-type-face
|
||||
'italic
|
||||
"Face to use for data types.")
|
||||
|
||||
(make-variable-buffer-local 'font-lock-keywords)
|
||||
(defvar font-lock-keywords nil
|
||||
"*The keywords to highlight.
|
||||
If this is a list, then elements may be of the forms:
|
||||
|
||||
\"string\" ; a regexp to highlight in the
|
||||
; `font-lock-keyword-face'.
|
||||
(\"string\" . integer) ; match N of the regexp will be highlighted
|
||||
(\"string\" . face-name) ; use the named face
|
||||
(\"string\" integer face-name) ; both of the above
|
||||
(\"string\" integer face-name t) ; this allows highlighting to overlap
|
||||
; with already-highlighted regions.
|
||||
|
||||
These regular expressions should not match text which spans lines.
|
||||
While \\[font-lock-fontify-buffer] handles multi-line patterns correctly,
|
||||
updating when you edit the buffer does not,
|
||||
since it considers text one line at a time.
|
||||
|
||||
Be careful composing regexps for this list; the wrong pattern can dramatically
|
||||
slow things down!")
|
||||
|
||||
(defvar font-lock-keywords-case-fold-search nil
|
||||
"*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.")
|
||||
|
||||
(defvar font-lock-verbose t
|
||||
"*Non-nil means `font-lock-fontify-buffer' should print status messages.")
|
||||
|
||||
(defvar font-lock-mode-hook nil
|
||||
"Function or functions to run on entry to Font Lock mode.")
|
||||
|
||||
;;; These variables record, for each buffer,
|
||||
;;; the parse state at a particular position, always the start of a line.
|
||||
;;; This is used to make font-lock-fontify-region faster.
|
||||
(defvar font-lock-cache-position nil)
|
||||
(defvar font-lock-cache-state nil)
|
||||
(make-variable-buffer-local 'font-lock-cache-position)
|
||||
(make-variable-buffer-local 'font-lock-cache-state)
|
||||
|
||||
(defun font-lock-fontify-region (start end)
|
||||
"Put proper face on each string and comment between START and END."
|
||||
(save-excursion
|
||||
(goto-char start)
|
||||
(beginning-of-line)
|
||||
(setq end (min end (point-max)))
|
||||
(let (state startline prev prevstate)
|
||||
;; Find the state at the line-beginning before START.
|
||||
(setq startline (point))
|
||||
(if (eq (point) font-lock-cache-position)
|
||||
(setq state font-lock-cache-state)
|
||||
;; Find outermost containing sexp.
|
||||
(beginning-of-defun)
|
||||
;; Find the state at STARTLINE.
|
||||
(while (< (point) startline)
|
||||
(setq state (parse-partial-sexp (point) startline 0)))
|
||||
(setq font-lock-cache-state state
|
||||
font-lock-cache-position (point)))
|
||||
;; Now find the state precisely at START.
|
||||
(setq state (parse-partial-sexp (point) start nil nil state))
|
||||
;; If the region starts inside a string, show the extent of it.
|
||||
(if (nth 3 state)
|
||||
(let ((beg (point)))
|
||||
(while (and (re-search-forward "\\s\"" end 'move)
|
||||
(nth 3 (parse-partial-sexp beg (point)
|
||||
nil nil state))))
|
||||
(put-text-property beg (point) 'face font-lock-string-face)
|
||||
(setq state (parse-partial-sexp beg (point) nil nil state))))
|
||||
;; Likewise for a comment.
|
||||
(if (or (nth 4 state) (nth 7 state))
|
||||
(let ((beg (point)))
|
||||
(while (and (re-search-forward (if comment-end
|
||||
(concat "\\s>\\|"
|
||||
(regexp-quote comment-end))
|
||||
"\\s>")
|
||||
end 'move)
|
||||
(nth 3 (parse-partial-sexp beg (point)
|
||||
nil nil state))))
|
||||
(put-text-property beg (point) 'face font-lock-comment-face)
|
||||
(setq state (parse-partial-sexp beg (point) nil nil state))))
|
||||
;; Find each interesting place between here and END.
|
||||
(while (and (< (point) end)
|
||||
(setq prev (point) prevstate state)
|
||||
(re-search-forward (concat "\\s\"\\|" (regexp-quote comment-start)) end t)
|
||||
;; Clear out the fonts of what we skip over.
|
||||
(progn (remove-text-properties prev (point) '(face nil)) t)
|
||||
;; Verify the state at that place
|
||||
;; so we don't get fooled by \" or \;.
|
||||
(setq state (parse-partial-sexp prev (point)
|
||||
nil nil state)))
|
||||
(let ((here (point)))
|
||||
(if (or (nth 4 state) (nth 7 state))
|
||||
;; We found a real comment start.
|
||||
(let ((beg (match-beginning 0)))
|
||||
(goto-char beg)
|
||||
(save-restriction
|
||||
(narrow-to-region (point-min) end)
|
||||
(condition-case nil
|
||||
(progn
|
||||
(forward-comment 1)
|
||||
;; forward-comment skips all whitespace,
|
||||
;; so go back to the real end of the comment.
|
||||
(skip-chars-backward " \t"))
|
||||
(error (goto-char end))))
|
||||
(put-text-property beg (point) 'face font-lock-comment-face)
|
||||
(setq state (parse-partial-sexp here (point) nil nil state)))
|
||||
(if (nth 3 state)
|
||||
(let ((beg (match-beginning 0)))
|
||||
(while (and (re-search-forward "\\s\"" end 'move)
|
||||
(nth 3 (parse-partial-sexp here (point)
|
||||
nil nil state))))
|
||||
(put-text-property beg (point) 'face font-lock-string-face)
|
||||
(setq state (parse-partial-sexp here (point) nil nil state))))
|
||||
))
|
||||
;; Make sure PREV is non-nil after the loop
|
||||
;; only if it was set on the very last iteration.
|
||||
(setq prev nil))
|
||||
(and prev
|
||||
(remove-text-properties prev end '(face nil))))))
|
||||
|
||||
;; This code used to be used to show a string on reaching the end of it.
|
||||
;; It is probably not needed due to later changes to handle strings
|
||||
;; starting before the region in question.
|
||||
;; (if (and (null (nth 3 state))
|
||||
;; (eq (char-syntax (preceding-char)) ?\")
|
||||
;; (save-excursion
|
||||
;; (nth 3 (parse-partial-sexp prev (1- (point))
|
||||
;; nil nil prevstate))))
|
||||
;; ;; We found the end of a string.
|
||||
;; (save-excursion
|
||||
;; (setq foo2 (point))
|
||||
;; (let ((ept (point)))
|
||||
;; (forward-sexp -1)
|
||||
;; ;; Highlight the string when we see the end.
|
||||
;; ;; Doing it at the start leads to trouble:
|
||||
;; ;; either it fails to handle multiline strings
|
||||
;; ;; or it can run away when an unmatched " is inserted.
|
||||
;; (put-text-property (point) ept 'face
|
||||
;; (if (= (car state) 1)
|
||||
;; font-lock-doc-string-face
|
||||
;; font-lock-string-face)))))
|
||||
|
||||
(defun font-lock-unfontify-region (beg end)
|
||||
(remove-text-properties beg end '(face nil)))
|
||||
|
||||
;; Called when any modification is made to buffer text.
|
||||
(defun font-lock-after-change-function (beg end old-len)
|
||||
(save-excursion
|
||||
(save-match-data
|
||||
(goto-char beg)
|
||||
;; Discard the cache info if text before it has changed.
|
||||
(and font-lock-cache-position
|
||||
(> font-lock-cache-position beg)
|
||||
(setq font-lock-cache-position nil))
|
||||
;; Rescan till end of line. yes!
|
||||
(goto-char end)
|
||||
(end-of-line)
|
||||
(setq end (point))
|
||||
;; First scan for strings and comments.
|
||||
(font-lock-fontify-region beg (1+ end))
|
||||
(goto-char beg)
|
||||
(beginning-of-line)
|
||||
(setq beg (point))
|
||||
;; Now scan for keywords.
|
||||
(font-lock-hack-keywords beg end))))
|
||||
|
||||
;;; Fontifying arbitrary patterns
|
||||
|
||||
(defsubst font-lock-any-properties-p (start end)
|
||||
(or (get-text-property start 'font-lock)
|
||||
(let ((next (next-single-property-change start 'font-lock)))
|
||||
(and next (< next end)))))
|
||||
|
||||
(defun font-lock-hack-keywords (start end &optional loudly)
|
||||
(goto-char start)
|
||||
(let ((case-fold-search font-lock-keywords-case-fold-search)
|
||||
(rest font-lock-keywords)
|
||||
(count 0)
|
||||
first str match face s e allow-overlap-p)
|
||||
(while rest
|
||||
(setq first (car rest) rest (cdr rest))
|
||||
(goto-char start)
|
||||
(cond ((consp first)
|
||||
(setq str (car first))
|
||||
(cond ((consp (cdr first))
|
||||
(setq match (nth 1 first)
|
||||
face (nth 2 first)
|
||||
allow-overlap-p (nth 3 first)))
|
||||
((symbolp (cdr first))
|
||||
(setq match 0 allow-overlap-p nil
|
||||
face (cdr first)))
|
||||
(t
|
||||
(setq match (cdr first)
|
||||
allow-overlap-p nil
|
||||
face font-lock-keyword-face))))
|
||||
(t
|
||||
(setq str first match 0 allow-overlap-p nil
|
||||
face font-lock-keyword-face)))
|
||||
;(message "regexp: %s" str)
|
||||
(while (re-search-forward str end t)
|
||||
(setq s (match-beginning match)
|
||||
e (match-end match))
|
||||
(or s (error "expression did not match subexpression %d" match))
|
||||
;; don't fontify this keyword if we're already in some other context.
|
||||
(or (if allow-overlap-p nil (font-lock-any-properties-p s e))
|
||||
(progn
|
||||
(put-text-property s e 'face face))))
|
||||
(if loudly (message "Fontifying %s... (regexps...%s)"
|
||||
(buffer-name)
|
||||
(make-string (setq count (1+ count)) ?.))))))
|
||||
|
||||
|
||||
;; The user level functions
|
||||
|
||||
(defvar font-lock-mode nil) ; for modeline
|
||||
(or (assq 'font-lock-mode minor-mode-alist)
|
||||
(setq minor-mode-alist
|
||||
(append minor-mode-alist
|
||||
'((font-lock-mode " Font")))))
|
||||
|
||||
(defvar font-lock-fontified nil) ; whether we have hacked this buffer
|
||||
(put 'font-lock-fontified 'permanent-local t)
|
||||
|
||||
;;;###autoload
|
||||
(defun font-lock-mode (&optional arg)
|
||||
"Toggle Font Lock mode.
|
||||
With arg, turn Font Lock mode on if and only if arg is positive.
|
||||
|
||||
When Font Lock mode is enabled, text is fontified as you type it:
|
||||
|
||||
- comments are displayed in `font-lock-comment-face';
|
||||
(That is a variable whose value should be a face name.)
|
||||
- strings are displayed in `font-lock-string-face';
|
||||
- documentation strings are displayed in `font-lock-doc-string-face';
|
||||
- function and variable names in their defining forms are displayed
|
||||
in `font-lock-function-name-face';
|
||||
- and certain other expressions are displayed in other faces
|
||||
according to the value of the variable `font-lock-keywords'.
|
||||
|
||||
When you turn Font Lock mode on/off, the buffer is fontified/defontified.
|
||||
To fontify a buffer without having newly typed text become fontified, you
|
||||
can use \\[font-lock-fontify-buffer]."
|
||||
(interactive "P")
|
||||
(let ((on-p (if (null arg)
|
||||
(not font-lock-mode)
|
||||
(> (prefix-numeric-value arg) 0))))
|
||||
(if (equal (buffer-name) " *Compiler Input*") ; hack for bytecomp...
|
||||
(setq on-p nil))
|
||||
(or (memq after-change-function
|
||||
'(nil font-lock-after-change-function))
|
||||
(error "after-change-function is %s" after-change-function))
|
||||
(set (make-local-variable 'after-change-function)
|
||||
(if on-p 'font-lock-after-change-function nil))
|
||||
(set (make-local-variable 'font-lock-mode) on-p)
|
||||
(cond (on-p
|
||||
(font-lock-set-defaults)
|
||||
(run-hooks 'font-lock-mode-hook)
|
||||
(or font-lock-fontified (font-lock-fontify-buffer)))
|
||||
(font-lock-fontified
|
||||
(setq font-lock-fontified nil)
|
||||
(font-lock-unfontify-region (point-min) (point-max))))
|
||||
(force-mode-line-update)))
|
||||
|
||||
|
||||
(defun font-lock-fontify-buffer ()
|
||||
"Fontify the current buffer the way `font-lock-mode' would:
|
||||
|
||||
- comments are displayed in `font-lock-comment-face';
|
||||
- strings are displayed in `font-lock-string-face';
|
||||
- documentation strings are displayed in `font-lock-doc-string-face';
|
||||
- function and variable names in their defining forms are displayed
|
||||
in `font-lock-function-name-face';
|
||||
- and certain other expressions are displayed in other faces
|
||||
according to the value of the variable `font-lock-keywords'.
|
||||
|
||||
This can take a while for large buffers."
|
||||
(interactive)
|
||||
(let ((was-on font-lock-mode)
|
||||
(font-lock-verbose (or font-lock-verbose (interactive-p))))
|
||||
(if font-lock-verbose (message "Fontifying %s..." (buffer-name)))
|
||||
;; Turn it on to run hooks and get the right font-lock-keywords.
|
||||
(or was-on (font-lock-mode 1))
|
||||
(font-lock-unfontify-region (point-min) (point-max))
|
||||
(if font-lock-verbose (message "Fontifying %s... (syntactically...)"
|
||||
(buffer-name)))
|
||||
;; (buffer-syntactic-context-flush-cache)
|
||||
(save-excursion
|
||||
(font-lock-fontify-region (point-min) (point-max))
|
||||
(if font-lock-verbose (message "Fontifying %s... (regexps...)"
|
||||
(buffer-name)))
|
||||
(font-lock-hack-keywords (point-min) (point-max) font-lock-verbose))
|
||||
(or was-on (font-lock-mode 0)) ; turn it off if it was off.
|
||||
(set (make-local-variable 'font-lock-fontified) t)
|
||||
(if font-lock-verbose (message "Fontifying %s... done." (buffer-name)))
|
||||
))
|
||||
|
||||
|
||||
;;; Various mode-specific information.
|
||||
|
||||
(defun font-lock-set-defaults ()
|
||||
"sets font-lock-keywords to something appropriate for this mode."
|
||||
(setq font-lock-keywords
|
||||
(cond ((eq major-mode 'lisp-mode) lisp-font-lock-keywords)
|
||||
((eq major-mode 'emacs-lisp-mode) lisp-font-lock-keywords)
|
||||
((eq major-mode 'c-mode) c-font-lock-keywords)
|
||||
((eq major-mode 'c++-c-mode) c-font-lock-keywords)
|
||||
((eq major-mode 'c++-mode) c++-font-lock-keywords)
|
||||
((eq major-mode 'perl-mode) perl-font-lock-keywords)
|
||||
((eq major-mode 'tex-mode) tex-font-lock-keywords)
|
||||
((eq major-mode 'texinfo-mode) texi-font-lock-keywords)
|
||||
(t nil))))
|
||||
|
||||
(defconst lisp-font-lock-keywords-1
|
||||
'(;;
|
||||
;; highlight defining forms. This doesn't work too nicely for
|
||||
;; (defun (setf foo) ...) but it does work for (defvar foo) which
|
||||
;; is more important.
|
||||
("^(def[-a-z]+\\s +\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face)
|
||||
;;
|
||||
;; highlight CL keywords
|
||||
("\\s :\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
|
||||
;;
|
||||
;; this is highlights things like (def* (setf foo) (bar baz)), but may
|
||||
;; be slower (I haven't really thought about it)
|
||||
; ("^(def[-a-z]+\\s +\\(\\s(\\S)*\\s)\\|\\S(\\S *\\)"
|
||||
; 1 font-lock-function-name-face)
|
||||
)
|
||||
"For consideration as a value of `lisp-font-lock-keywords'.
|
||||
This does fairly subdued highlighting.")
|
||||
|
||||
(defconst lisp-font-lock-keywords-2
|
||||
(append
|
||||
lisp-font-lock-keywords-1
|
||||
'(;;
|
||||
;; Highlight control structures
|
||||
("(\\(cond\\|if\\|when\\|unless\\|[ec]?\\(type\\)?case\\)[ \t\n]" . 1)
|
||||
("(\\(while\\|do\\|let*?\\|flet\\|labels\\|prog[nv12*]?\\)[ \t\n]" . 1)
|
||||
("(\\(catch\\|\\throw\\|block\\|return\\|return-from\\)[ \t\n]" . 1)
|
||||
("(\\(save-restriction\\|save-window-restriction\\)[ \t\n]" . 1)
|
||||
("(\\(save-excursion\\|unwind-protect\\|condition-case\\)[ \t\n]" . 1)
|
||||
;;
|
||||
;; highlight function names in emacs-lisp docstrings (in the syntax
|
||||
;; that substitute-command-keys understands.)
|
||||
("\\\\\\\\\\[\\([^]\\\n]+\\)]" 1 font-lock-keyword-face t)
|
||||
;;
|
||||
;; highlight words inside `' which tend to be function names
|
||||
("`\\([-a-zA-Z0-9_][-a-zA-Z0-9_][-a-zA-Z0-9_.]+\\)'"
|
||||
1 font-lock-keyword-face t)
|
||||
))
|
||||
"For consideration as a value of `lisp-font-lock-keywords'.
|
||||
This does a lot more highlighting.")
|
||||
|
||||
;; default to the gaudier variety?
|
||||
;(defvar lisp-font-lock-keywords lisp-font-lock-keywords-2
|
||||
; "Additional expressions to highlight in Lisp modes.")
|
||||
(defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
|
||||
"Additional expressions to highlight in Lisp modes.")
|
||||
|
||||
|
||||
(defconst c-font-lock-keywords-1 nil
|
||||
"For consideration as a value of `c-font-lock-keywords'.
|
||||
This does fairly subdued highlighting.")
|
||||
|
||||
(defconst c-font-lock-keywords-2 nil
|
||||
"For consideration as a value of `c-font-lock-keywords'.
|
||||
This does a lot more highlighting.")
|
||||
|
||||
(let ((storage "auto\\|extern\\|register\\|static\\|volatile")
|
||||
(prefixes "unsigned\\|short\\|long")
|
||||
(types (concat "int\\|char\\|float\\|double\\|void\\|struct\\|"
|
||||
"union\\|enum\\|typedef"))
|
||||
(ctoken "[a-zA-Z0-9_:~*]+")
|
||||
)
|
||||
(setq c-font-lock-keywords-1
|
||||
(list
|
||||
;; fontify preprocessor directives as comments.
|
||||
'("^#[ \t]*[a-z]+" . font-lock-comment-face)
|
||||
;;
|
||||
;; fontify names being defined.
|
||||
'("^#[ \t]*\\(define\\|undef\\)[ \t]+\\(\\(\\sw\\|\\s_\\)+\\)" 2
|
||||
font-lock-function-name-face)
|
||||
;;
|
||||
;; fontify other preprocessor lines.
|
||||
'("^#[ \t]*\\(if\\|ifn?def\\)[ \t]+\\([^\n]+\\)"
|
||||
2 font-lock-function-name-face t)
|
||||
;;
|
||||
;; fontify the filename in #include <...>
|
||||
;; don't need to do this for #include "..." because those were
|
||||
;; already fontified as strings by the syntactic pass.
|
||||
'("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face)
|
||||
;;
|
||||
;; fontify the names of functions being defined.
|
||||
(list (concat
|
||||
"^\\(" ctoken "[ \t]+\\)?" ; type specs; there can be no
|
||||
"\\(" ctoken "[ \t]+\\)?" ; more than 3 tokens, right?
|
||||
"\\(" ctoken "[ \t]+\\)?"
|
||||
"\\(\\*+[ \t]*\\)?" ; pointer
|
||||
"\\(" ctoken "\\)[ \t]*(") ; name
|
||||
5 'font-lock-function-name-face)
|
||||
;;
|
||||
;;
|
||||
;; Fontify structure names (in structure definition form).
|
||||
(list (concat "^\\(typedef[ \t]+struct\\|struct\\|static[ \t]+struct\\)"
|
||||
"[ \t]+\\(" ctoken "\\)[ \t]*\\(\{\\|$\\)")
|
||||
2 'font-lock-function-name-face)
|
||||
;;
|
||||
;; Fontify case clauses. This is fast because its anchored on the left.
|
||||
'("case[ \t]+\\(\\(\\sw\\|\\s_\\)+\\):". 1)
|
||||
'("\\<\\(default\\):". 1)
|
||||
))
|
||||
|
||||
(setq c-font-lock-keywords-2
|
||||
(append c-font-lock-keywords-1
|
||||
(list
|
||||
;;
|
||||
;; fontify all storage classes and type specifiers
|
||||
(cons (concat "\\<\\(" storage "\\)\\>") 'font-lock-type-face)
|
||||
(cons (concat "\\<\\(" types "\\)\\>") 'font-lock-type-face)
|
||||
(cons (concat "\\<\\(" prefixes "[ \t]+" types "\\)\\>")
|
||||
'font-lock-type-face)
|
||||
;;
|
||||
;; fontify all builtin tokens
|
||||
(cons (concat
|
||||
"[ \t]\\("
|
||||
(mapconcat 'identity
|
||||
'("for" "while" "do" "return" "goto" "case" "break" "switch"
|
||||
"if" "then" "else if" "else" "return" "default" "continue"
|
||||
"default"
|
||||
)
|
||||
"\\|")
|
||||
"\\)[ \t\n(){};,]")
|
||||
1)
|
||||
;;
|
||||
;; fontify case targets and goto-tags. This is slow because the
|
||||
;; expression is anchored on the right.
|
||||
"\\(\\(\\sw\\|\\s_\\)+\\):"
|
||||
;;
|
||||
;; Fontify variables declared with structures, or typedef names.
|
||||
'("}[ \t*]*\\(\\(\\sw\\|\\s_\\)+\\)[ \t]*[,;]"
|
||||
1 font-lock-function-name-face)
|
||||
;;
|
||||
;; Fontify global variables without a type.
|
||||
; '("^\\([_a-zA-Z0-9:~*]+\\)[ \t]*[[;={]" 1 font-lock-function-name-face)
|
||||
|
||||
)))
|
||||
)
|
||||
|
||||
; default to the gaudier variety?
|
||||
;(defvar c-font-lock-keywords c-font-lock-keywords-2
|
||||
; "Additional expressions to highlight in C mode.")
|
||||
(defvar c-font-lock-keywords c-font-lock-keywords-1
|
||||
"Additional expressions to highlight in C mode.")
|
||||
|
||||
(defvar c++-font-lock-keywords c-font-lock-keywords
|
||||
"Additional expressions to highlight in C++ mode.")
|
||||
|
||||
|
||||
(defvar perl-font-lock-keywords
|
||||
(list
|
||||
(concat "[ \n\t{]*\\("
|
||||
(mapconcat 'identity
|
||||
'("if" "until" "while" "elsif" "else" "unless" "for"
|
||||
"foreach" "continue" "exit" "die" "last" "goto" "next"
|
||||
"redo" "return" "local" "exec")
|
||||
"\\|")
|
||||
"\\)[ \n\t;(]")
|
||||
(mapconcat 'identity
|
||||
'("#endif" "#else" "#ifdef" "#ifndef" "#if" "#include"
|
||||
"#define" "#undef")
|
||||
"\\|")
|
||||
'("^[ \n\t]*sub[ \t]+\\([^ \t{]+\\)\\{" . font-lock-function-name-face)
|
||||
'("[ \n\t{]*\\(eval\\)[ \n\t(;]" . font-lock-function-name-face)
|
||||
'("\\(--- .* ---\\|=== .* ===\\)" . font-lock-doc-string-face)
|
||||
)
|
||||
"Additional expressions to highlight in Perl mode.")
|
||||
|
||||
(defvar tex-font-lock-keywords
|
||||
(list
|
||||
'("\\(\\\\\\w+\\)" 1 font-lock-keyword-face t)
|
||||
'("{\\\\em\\([^}]+\\)}" 1 font-lock-comment-face t)
|
||||
'("{\\\\bf\\([^}]+\\)}" 1 font-lock-keyword-face t)
|
||||
'("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face t)
|
||||
'("\\\\\\(begin\\|end\\){\\([a-zA-Z0-9\\*]+\\)}"
|
||||
2 font-lock-function-name-face t)
|
||||
'("[^\\\\]\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
|
||||
; '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
|
||||
)
|
||||
"Additional expressions to highlight in TeX mode.")
|
||||
|
||||
(defvar texi-font-lock-keywords
|
||||
(list
|
||||
"@\\(@\\|[^}\t \n{]+\\)" ;commands
|
||||
'("^\\(@c\\|@comment\\)[ \t].*$" . font-lock-comment-face) ;comments
|
||||
'("^\\(*.*\\)[\t ]*$" 1 font-lock-function-name-face t) ;menu items
|
||||
'("@\\(emph\\|strong\\|b\\|i\\){\\([^}]+\\)" 2 font-lock-comment-face t)
|
||||
'("@\\(file\\|kbd\\|key\\){\\([^}]+\\)" 2 font-lock-string-face t)
|
||||
'("@\\(samp\\|code\\|var\\){\\([^}]+\\)" 2 font-lock-function-name-face t)
|
||||
'("@\\(xref\\|pxref\\){\\([^}]+\\)" 2 font-lock-keyword-face t)
|
||||
'("@end *\\([a-zA-Z0-9]+\\)[ \t]*$" 1 font-lock-function-name-face t)
|
||||
'("@item \\(.*\\)$" 1 font-lock-function-name-face t)
|
||||
'("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t)
|
||||
)
|
||||
"Additional expressions to highlight in TeXinfo mode.")
|
||||
|
||||
(provide 'font-lock)
|
||||
|
||||
;;; font-lock.el ends here
|
||||
Loading…
Reference in New Issue
Block a user