@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002,
-@c 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001,
+@c 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/modes
@node Modes, Documentation, Keymaps, Top
@cindex normal hook
Most of the hooks in Emacs are @dfn{normal hooks}. These variables
-contain lists of functions to be called with no arguments. When the
-hook name ends in @samp{-hook}, that tells you it is normal. We try to
-make all hooks normal, as much as possible, so that you can use them in
-a uniform way.
-
- Every major mode function is supposed to run a normal hook called the
-@dfn{mode hook} as the last step of initialization. This makes it easy
-for a user to customize the behavior of the mode, by overriding the
-buffer-local variable assignments already made by the mode. Most
-minor modes also run a mode hook at their end. But hooks are used in
-other contexts too. For example, the hook @code{suspend-hook} runs
-just before Emacs suspends itself (@pxref{Suspending Emacs}).
+contain lists of functions to be called with no arguments. By
+convention, whenever the hook name ends in @samp{-hook}, that tells
+you it is normal. We try to make all hooks normal, as much as
+possible, so that you can use them in a uniform way.
+
+ Every major mode function is supposed to run a normal hook called
+the @dfn{mode hook} as the one of the last steps of initialization.
+This makes it easy for a user to customize the behavior of the mode,
+by overriding the buffer-local variable assignments already made by
+the mode. Most minor mode functions also run a mode hook at the end.
+But hooks are used in other contexts too. For example, the hook
+@code{suspend-hook} runs just before Emacs suspends itself
+(@pxref{Suspending Emacs}).
The recommended way to add a hook function to a normal hook is by
calling @code{add-hook} (see below). The hook functions may be any of
@cindex abnormal hook
If the hook variable's name does not end with @samp{-hook}, that
-indicates it is probably an @dfn{abnormal hook}. Then you should look at its
-documentation to see how to use the hook properly.
+indicates it is probably an @dfn{abnormal hook}. That means the hook
+functions are called with arguments, or their return values are used
+in some way. The hook's documentation says how the functions are
+called. You can use @code{add-hook} to add a function to an abnormal
+hook, but you must write the function to follow the hook's calling
+convention.
- If the variable's name ends in @samp{-functions} or @samp{-hooks},
-then the value is a list of functions, but it is abnormal in that either
-these functions are called with arguments or their values are used in
-some way. You can use @code{add-hook} to add a function to the list,
-but you must take care in writing the function. (A few of these
-variables, notably those ending in @samp{-hooks}, are actually
-normal hooks which were named before we established the convention of
-using @samp{-hook} for them.)
-
- If the variable's name ends in @samp{-function}, then its value
-is just a single function, not a list of functions.
+ By convention, abnormal hook names end in @samp{-functions} or
+@samp{-hooks}. If the variable's name ends in @samp{-function}, then
+its value is just a single function, not a list of functions.
Here's an example that uses a mode hook to turn on Auto Fill mode when
in Lisp Interaction mode:
symbol that is a normal hook variable. These arguments are processed
in the order specified.
-If a hook variable has a non-@code{nil} value, that value may be a
-function or a list of functions. (The former option is considered
-obsolete.) If the value is a function (either a lambda expression or
-a symbol with a function definition), it is called. If it is a list
-that isn't a function, its elements are called, consecutively. All
-the hook functions are called with no arguments.
+If a hook variable has a non-@code{nil} value, that value should be a
+list of functions. @code{run-hooks} calls all the functions, one by
+one, with no arguments.
+
+The hook variable's value can also be a single function---either a
+lambda expression or a symbol with a function definition---which
+@code{run-hooks} calls. But this usage is obsolete.
@end defun
@defun run-hook-with-args hook &rest args
It is best to design your hook functions so that the order in which they
are executed does not matter. Any dependence on the order is ``asking
-for trouble''. However, the order is predictable: normally,
+for trouble.'' However, the order is predictable: normally,
@var{function} goes at the front of the hook list, so it will be
executed first (barring another @code{add-hook} call). If the optional
argument @var{append} is non-@code{nil}, the new hook function goes at
@menu
* Major Mode Basics::
* Major Mode Conventions:: Coding conventions for keymaps, etc.
-* Example Major Modes:: Text mode and Lisp modes.
* Auto Major Mode:: How Emacs chooses the major mode automatically.
* Mode Help:: Finding out how to use a mode.
* Derived Modes:: Defining a new major mode based on another major
* Generic Modes:: Defining a simple major mode that supports
comment syntax and Font Lock mode.
* Mode Hooks:: Hooks run at the end of major mode functions.
+* Example Major Modes:: Text mode and Lisp modes.
@end menu
@node Major Mode Basics
idea. In practice, writing a major mode is easy (in contrast to
writing a minor mode, which is often difficult).
- If the new mode is similar to an old one, it is often unwise to modify
-the old one to serve two purposes, since it may become harder to use and
-maintain. Instead, copy and rename an existing major mode definition
-and alter the copy---or define a @dfn{derived mode} (@pxref{Derived
-Modes}). For example, Rmail Edit mode, which is in
-@file{emacs/lisp/mail/rmailedit.el}, is a major mode that is very similar to
-Text mode except that it provides two additional commands. Its
-definition is distinct from that of Text mode, but uses that of Text mode.
+ If the new mode is similar to an old one, it is often unwise to
+modify the old one to serve two purposes, since it may become harder
+to use and maintain. Instead, copy and rename an existing major mode
+definition and alter the copy---or use @code{define-derived-mode} to
+define a @dfn{derived mode} (@pxref{Derived Modes}). For example,
+Rmail Edit mode is a major mode that is very similar to Text mode
+except that it provides two additional commands. Its definition is
+distinct from that of Text mode, but uses that of Text mode.
Even if the new mode is not an obvious derivative of any other mode,
it is convenient to use @code{define-derived-mode} with a @code{nil}
@node Major Mode Conventions
@subsection Major Mode Conventions
+@cindex major mode conventions
+@cindex conventions for writing major modes
The code for existing major modes follows various coding conventions,
including conventions for local keymap and syntax table initialization,
global names, and hooks. Please follow these conventions when you
-define a new major mode.
+define a new major mode. (Fundamental mode is an exception to many
+of these conventions, because its definition is to present the global
+state of Emacs.)
This list of conventions is only partial, because each major mode
should aim for consistency in general with other Emacs major modes.
@item
The major mode command should start by calling
-@code{kill-all-local-variables}. This is what gets rid of the
-buffer-local variables of the major mode previously in effect.
+@code{kill-all-local-variables}. This runs the normal hook
+@code{change-major-mode-hook}, then gets rid of the buffer-local
+variables of the major mode previously in effect. @xref{Creating
+Buffer-Local}.
@item
The major mode command should set the variable @code{major-mode} to the
letters and other printing characters as special commands.
@item
-Major modes must not define @key{RET} to do anything other than insert
-a newline. The command to insert a newline and then indent is
-@kbd{C-j}. Please keep this distinction uniform for all major modes.
+Major modes modes for editing text should not define @key{RET} to do
+anything other than insert a newline. However, it is ok for
+specialized modes for text that users don't directly edit, such as
+Dired and Info modes, to redefine @key{RET} to do something entirely
+different.
@item
Major modes should not alter options that are primarily a matter of user
@item
@cindex mode hook
@cindex major mode hook
-Each major mode should have a @dfn{mode hook} named
-@code{@var{modename}-mode-hook}. The major mode command should run that
-hook, with @code{run-mode-hooks}, as the very last thing it
-does. @xref{Mode Hooks}.
+Each major mode should have a normal @dfn{mode hook} named
+@code{@var{modename}-mode-hook}. The very last thing the major mode command
+should do is to call @code{run-mode-hooks}. This runs the mode hook,
+and then runs the normal hook @code{after-change-major-mode-hook}.
+@xref{Mode Hooks}.
@item
The major mode command may start by calling some other major mode
Even if you never load the file more than once, someone else will.
@end itemize
-@node Example Major Modes
-@subsection Major Mode Examples
-
- Text mode is perhaps the simplest mode besides Fundamental mode.
-Here are excerpts from @file{text-mode.el} that illustrate many of
-the conventions listed above:
-
-@smallexample
-@group
-;; @r{Create the syntax table for this mode.}
-(defvar text-mode-syntax-table
- (let ((st (make-syntax-table)))
- (modify-syntax-entry ?\" ". " st)
- (modify-syntax-entry ?\\ ". " st)
- ;; We add `p' so that M-c on 'hello' leads to 'Hello' rather than 'hello'.
- (modify-syntax-entry ?' "w p" st)
- st)
- "Syntax table used while in `text-mode'.")
-@end group
-
-;; @r{Create the keymap for this mode.}
-@group
-(defvar text-mode-map
- (let ((map (make-sparse-keymap)))
- (define-key map "\e\t" 'ispell-complete-word)
- (define-key map "\es" 'center-line)
- (define-key map "\eS" 'center-paragraph)
- map)
- "Keymap for `text-mode'.
-Many other modes, such as `mail-mode', `outline-mode' and `indented-text-mode',
-inherit all the commands defined in this map.")
-@end group
-@end smallexample
-
- Here is how the actual mode command is defined now:
-
-@smallexample
-@group
-(define-derived-mode text-mode nil "Text"
- "Major mode for editing text written for humans to read.
-In this mode, paragraphs are delimited only by blank or white lines.
-You can thus get the full benefit of adaptive filling
- (see the variable `adaptive-fill-mode').
-\\@{text-mode-map@}
-Turning on Text mode runs the normal hook `text-mode-hook'."
-@end group
-@group
- (make-local-variable 'text-mode-variant)
- (setq text-mode-variant t)
- ;; @r{These two lines are a feature added recently.}
- (set (make-local-variable 'require-final-newline)
- mode-require-final-newline)
- (set (make-local-variable 'indent-line-function) 'indent-relative))
-@end group
-@end smallexample
-
- But here is how it was defined formerly, before
-@code{define-derived-mode} existed:
-
-@smallexample
-@group
-;; @r{This isn't needed nowadays, since @code{define-derived-mode} does it.}
-(defvar text-mode-abbrev-table nil
- "Abbrev table used while in text mode.")
-(define-abbrev-table 'text-mode-abbrev-table ())
-@end group
-
-@group
-(defun text-mode ()
- "Major mode for editing text intended for humans to read...
- Special commands: \\@{text-mode-map@}
-@end group
-@group
-Turning on text-mode runs the hook `text-mode-hook'."
- (interactive)
- (kill-all-local-variables)
- (use-local-map text-mode-map)
-@end group
-@group
- (setq local-abbrev-table text-mode-abbrev-table)
- (set-syntax-table text-mode-syntax-table)
-@end group
-@group
- ;; @r{These four lines are absent from the current version}
- ;; @r{not because this is done some other way, but rather}
- ;; @r{because nowadays Text mode uses the normal definition of paragraphs.}
- (make-local-variable 'paragraph-start)
- (setq paragraph-start (concat "[ \t]*$\\|" page-delimiter))
- (make-local-variable 'paragraph-separate)
- (setq paragraph-separate paragraph-start)
- (make-local-variable 'indent-line-function)
- (setq indent-line-function 'indent-relative-maybe)
-@end group
-@group
- (setq mode-name "Text")
- (setq major-mode 'text-mode)
- (run-mode-hooks 'text-mode-hook)) ; @r{Finally, this permits the user to}
- ; @r{customize the mode with a hook.}
-@end group
-@end smallexample
-
-@cindex @file{lisp-mode.el}
- The three Lisp modes (Lisp mode, Emacs Lisp mode, and Lisp
-Interaction mode) have more features than Text mode and the code is
-correspondingly more complicated. Here are excerpts from
-@file{lisp-mode.el} that illustrate how these modes are written.
-
-@cindex syntax table example
-@smallexample
-@group
-;; @r{Create mode-specific table variables.}
-(defvar lisp-mode-syntax-table nil "")
-(defvar lisp-mode-abbrev-table nil "")
-@end group
-
-@group
-(defvar emacs-lisp-mode-syntax-table
- (let ((table (make-syntax-table)))
- (let ((i 0))
-@end group
-
-@group
- ;; @r{Set syntax of chars up to @samp{0} to say they are}
- ;; @r{part of symbol names but not words.}
- ;; @r{(The digit @samp{0} is @code{48} in the @acronym{ASCII} character set.)}
- (while (< i ?0)
- (modify-syntax-entry i "_ " table)
- (setq i (1+ i)))
- ;; @r{@dots{} similar code follows for other character ranges.}
-@end group
-@group
- ;; @r{Then set the syntax codes for characters that are special in Lisp.}
- (modify-syntax-entry ? " " table)
- (modify-syntax-entry ?\t " " table)
- (modify-syntax-entry ?\f " " table)
- (modify-syntax-entry ?\n "> " table)
-@end group
-@group
- ;; @r{Give CR the same syntax as newline, for selective-display.}
- (modify-syntax-entry ?\^m "> " table)
- (modify-syntax-entry ?\; "< " table)
- (modify-syntax-entry ?` "' " table)
- (modify-syntax-entry ?' "' " table)
- (modify-syntax-entry ?, "' " table)
-@end group
-@group
- ;; @r{@dots{}likewise for many other characters@dots{}}
- (modify-syntax-entry ?\( "() " table)
- (modify-syntax-entry ?\) ")( " table)
- (modify-syntax-entry ?\[ "(] " table)
- (modify-syntax-entry ?\] ")[ " table))
- table))
-@end group
-@group
-;; @r{Create an abbrev table for lisp-mode.}
-(define-abbrev-table 'lisp-mode-abbrev-table ())
-@end group
-@end smallexample
-
- Much code is shared among the three Lisp modes. The following
-function sets various variables; it is called by each of the major Lisp
-mode functions:
-
-@smallexample
-@group
-(defun lisp-mode-variables (lisp-syntax)
- (when lisp-syntax
- (set-syntax-table lisp-mode-syntax-table))
- (setq local-abbrev-table lisp-mode-abbrev-table)
- @dots{}
-@end group
-@end smallexample
-
- Functions such as @code{forward-paragraph} use the value of the
-@code{paragraph-start} variable. Since Lisp code is different from
-ordinary text, the @code{paragraph-start} variable needs to be set
-specially to handle Lisp. Also, comments are indented in a special
-fashion in Lisp and the Lisp modes need their own mode-specific
-@code{comment-indent-function}. The code to set these variables is the
-rest of @code{lisp-mode-variables}.
-
-@smallexample
-@group
- (make-local-variable 'paragraph-start)
- (setq paragraph-start (concat page-delimiter "\\|$" ))
- (make-local-variable 'paragraph-separate)
- (setq paragraph-separate paragraph-start)
- @dots{}
-@end group
-@group
- (make-local-variable 'comment-indent-function)
- (setq comment-indent-function 'lisp-comment-indent))
- @dots{}
-@end group
-@end smallexample
-
- Each of the different Lisp modes has a slightly different keymap. For
-example, Lisp mode binds @kbd{C-c C-z} to @code{run-lisp}, but the other
-Lisp modes do not. However, all Lisp modes have some commands in
-common. The following code sets up the common commands:
-
-@smallexample
-@group
-(defvar shared-lisp-mode-map ()
- "Keymap for commands shared by all sorts of Lisp modes.")
-
-;; @r{Putting this @code{if} after the @code{defvar} is an older style.}
-(if shared-lisp-mode-map
- ()
- (setq shared-lisp-mode-map (make-sparse-keymap))
- (define-key shared-lisp-mode-map "\e\C-q" 'indent-sexp)
- (define-key shared-lisp-mode-map "\177"
- 'backward-delete-char-untabify))
-@end group
-@end smallexample
-
-@noindent
-And here is the code to set up the keymap for Lisp mode:
-
-@smallexample
-@group
-(defvar lisp-mode-map ()
- "Keymap for ordinary Lisp mode...")
-
-(if lisp-mode-map
- ()
- (setq lisp-mode-map (make-sparse-keymap))
- (set-keymap-parent lisp-mode-map shared-lisp-mode-map)
- (define-key lisp-mode-map "\e\C-x" 'lisp-eval-defun)
- (define-key lisp-mode-map "\C-c\C-z" 'run-lisp))
-@end group
-@end smallexample
-
- Finally, here is the complete major mode function definition for
-Lisp mode.
-
-@smallexample
-@group
-(defun lisp-mode ()
- "Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
-Commands:
-Delete converts tabs to spaces as it moves back.
-Blank lines separate paragraphs. Semicolons start comments.
-\\@{lisp-mode-map@}
-Note that `run-lisp' may be used either to start an inferior Lisp job
-or to switch back to an existing one.
-@end group
-
-@group
-Entry to this mode calls the value of `lisp-mode-hook'
-if that value is non-nil."
- (interactive)
- (kill-all-local-variables)
-@end group
-@group
- (use-local-map lisp-mode-map) ; @r{Select the mode's keymap.}
- (setq major-mode 'lisp-mode) ; @r{This is how @code{describe-mode}}
- ; @r{finds out what to describe.}
- (setq mode-name "Lisp") ; @r{This goes into the mode line.}
- (lisp-mode-variables t) ; @r{This defines various variables.}
- (make-local-variable 'comment-start-skip)
- (setq comment-start-skip
- "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *")
- (make-local-variable 'font-lock-keywords-case-fold-search)
- (setq font-lock-keywords-case-fold-search t)
-@end group
-@group
- (setq imenu-case-fold-search t)
- (set-syntax-table lisp-mode-syntax-table)
- (run-mode-hooks 'lisp-mode-hook)) ; @r{This permits the user to use a}
- ; @r{hook to customize the mode.}
-@end group
-@end smallexample
-
@node Auto Major Mode
@subsection How Emacs Chooses a Major Mode
+@cindex major mode, automatic selection
Based on information in the file name or in the file itself, Emacs
automatically selects a major mode for the new buffer when a file is
@code{auto-mode-alist} gets to decide the mode.
@end defvar
+@defvar file-start-mode-alist
+This works like @code{magic-mode-alist}, except that it is handled
+only if @code{auto-mode-alist} does not specify a mode for this file.
+@end defvar
+
@defvar auto-mode-alist
This variable contains an association list of file name patterns
(regular expressions) and corresponding major mode commands. Usually,
the convention used for non-keyword arguments that a @code{nil} value
is equivalent with not specifying the argument.)
-@item :abbrev-table
-You can use this to explicitly specify an abbrev table for the new
-mode. If you specify a @code{nil} value, the new mode uses the same
-abbrev table as @var{parent}, or @code{fundamental-mode-abbrev-table}
-if @var{parent} is @code{nil}. (Again, a @code{nil} value is
-@emph{not} equivalent to not specifying this keyword.)
+@item :abbrev-table
+You can use this to explicitly specify an abbrev table for the new
+mode. If you specify a @code{nil} value, the new mode uses the same
+abbrev table as @var{parent}, or @code{fundamental-mode-abbrev-table}
+if @var{parent} is @code{nil}. (Again, a @code{nil} value is
+@emph{not} equivalent to not specifying this keyword.)
+
+@item :group
+If this is specified, the value should be the customization group for
+this mode. (Not all major modes have one.) Only the (still
+experimental and unadvertised) command @code{customize-mode} currently
+uses this. @code{define-derived-mode} does @emph{not} automatically
+define the specified customization group.
+@end table
+
+Here is a hypothetical example:
+
+@example
+(define-derived-mode hypertext-mode
+ text-mode "Hypertext"
+ "Major mode for hypertext.
+\\@{hypertext-mode-map@}"
+ (setq case-fold-search nil))
+
+(define-key hypertext-mode-map
+ [down-mouse-3] 'do-hyper-link)
+@end example
+
+Do not write an @code{interactive} spec in the definition;
+@code{define-derived-mode} does that automatically.
+@end defmac
+
+@node Generic Modes
+@subsection Generic Modes
+@cindex generic mode
+
+ @dfn{Generic modes} are simple major modes with basic support for
+comment syntax and Font Lock mode. To define a generic mode, use the
+macro @code{define-generic-mode}. See the file @file{generic-x.el}
+for some examples of the use of @code{define-generic-mode}.
+
+@defmac define-generic-mode mode comment-list keyword-list font-lock-list auto-mode-list function-list &optional docstring
+This macro defines a generic mode command named @var{mode} (a symbol,
+not quoted). The optional argument @var{docstring} is the
+documentation for the mode command. If you do not supply it,
+@code{define-generic-mode} generates one by default.
+
+The argument @var{comment-list} is a list in which each element is
+either a character, a string of one or two characters, or a cons cell.
+A character or a string is set up in the mode's syntax table as a
+``comment starter.'' If the entry is a cons cell, the @sc{car} is set
+up as a ``comment starter'' and the @sc{cdr} as a ``comment ender.''
+(Use @code{nil} for the latter if you want comments to end at the end
+of the line.) Note that the syntax table mechanism has limitations
+about what comment starters and enders are actually possible.
+@xref{Syntax Tables}.
+
+The argument @var{keyword-list} is a list of keywords to highlight
+with @code{font-lock-keyword-face}. Each keyword should be a string.
+Meanwhile, @var{font-lock-list} is a list of additional expressions to
+highlight. Each element of this list should have the same form as an
+element of @code{font-lock-keywords}. @xref{Search-based
+Fontification}.
+
+The argument @var{auto-mode-list} is a list of regular expressions to
+add to the variable @code{auto-mode-alist}. They are added by the execution
+of the @code{define-generic-mode} form, not by expanding the macro call.
+
+Finally, @var{function-list} is a list of functions for the mode
+command to call for additional setup. It calls these functions just
+before it runs the mode hook variable @code{@var{mode}-hook}.
+@end defmac
+
+@node Mode Hooks
+@subsection Mode Hooks
+
+ Every major mode function should finish by running its mode hook and
+the mode-independent normal hook @code{after-change-major-mode-hook}.
+It does this by calling @code{run-mode-hooks}. If the major mode is a
+derived mode, that is if it calls another major mode (the parent mode)
+in its body, it should do this inside @code{delay-mode-hooks} so that
+the parent won't run these hooks itself. Instead, the derived mode's
+call to @code{run-mode-hooks} runs the parent's mode hook too.
+@xref{Major Mode Conventions}.
+
+ Emacs versions before Emacs 22 did not have @code{delay-mode-hooks}.
+When user-implemented major modes have not been updated to use it,
+they won't entirely follow these conventions: they may run the
+parent's mode hook too early, or fail to run
+@code{after-change-major-mode-hook}. If you encounter such a major
+mode, please correct it to follow these conventions.
+
+ When you defined a major mode using @code{define-derived-mode}, it
+automatically makes sure these conventions are followed. If you
+define a major mode ``by hand,'' not using @code{define-derived-mode},
+use the following functions to handle these conventions automatically.
+
+@defun run-mode-hooks &rest hookvars
+Major modes should run their mode hook using this function. It is
+similar to @code{run-hooks} (@pxref{Hooks}), but it also runs
+@code{after-change-major-mode-hook}.
+
+When this function is called during the execution of a
+@code{delay-mode-hooks} form, it does not run the hooks immediately.
+Instead, it arranges for the next call to @code{run-mode-hooks} to run
+them.
+@end defun
+
+@defmac delay-mode-hooks body@dots{}
+When one major mode command calls another, it should do so inside of
+@code{delay-mode-hooks}.
+
+This macro executes @var{body}, but tells all @code{run-mode-hooks}
+calls during the execution of @var{body} to delay running their hooks.
+The hooks will actually run during the next call to
+@code{run-mode-hooks} after the end of the @code{delay-mode-hooks}
+construct.
+@end defmac
+
+@defvar after-change-major-mode-hook
+This is a normal hook run by @code{run-mode-hooks}. It is run at the
+very end of every properly-written major mode function.
+@end defvar
+
+@node Example Major Modes
+@subsection Major Mode Examples
+
+ Text mode is perhaps the simplest mode besides Fundamental mode.
+Here are excerpts from @file{text-mode.el} that illustrate many of
+the conventions listed above:
+
+@smallexample
+@group
+;; @r{Create the syntax table for this mode.}
+(defvar text-mode-syntax-table
+ (let ((st (make-syntax-table)))
+ (modify-syntax-entry ?\" ". " st)
+ (modify-syntax-entry ?\\ ". " st)
+ ;; Add `p' so M-c on `hello' leads to `Hello', not `hello'.
+ (modify-syntax-entry ?' "w p" st)
+ st)
+ "Syntax table used while in `text-mode'.")
+@end group
+
+;; @r{Create the keymap for this mode.}
+@group
+(defvar text-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map "\e\t" 'ispell-complete-word)
+ (define-key map "\es" 'center-line)
+ (define-key map "\eS" 'center-paragraph)
+ map)
+ "Keymap for `text-mode'.
+Many other modes, such as Mail mode, Outline mode
+and Indented Text mode, inherit all the commands
+defined in this map.")
+@end group
+@end smallexample
+
+ Here is how the actual mode command is defined now:
+
+@smallexample
+@group
+(define-derived-mode text-mode nil "Text"
+ "Major mode for editing text written for humans to read.
+In this mode, paragraphs are delimited only by blank or white lines.
+You can thus get the full benefit of adaptive filling
+ (see the variable `adaptive-fill-mode').
+\\@{text-mode-map@}
+Turning on Text mode runs the normal hook `text-mode-hook'."
+@end group
+@group
+ (make-local-variable 'text-mode-variant)
+ (setq text-mode-variant t)
+ ;; @r{These two lines are a feature added recently.}
+ (set (make-local-variable 'require-final-newline)
+ mode-require-final-newline)
+ (set (make-local-variable 'indent-line-function) 'indent-relative))
+@end group
+@end smallexample
+
+@noindent
+(The last line is redundant nowadays, since @code{indent-relative} is
+the default value, and we'll delete it in a future version.)
-@item :group
-If this is specified, the value should be the customization group for
-this mode. (Not all major modes have one.) Only the (still
-experimental and unadvertised) command @code{customize-mode} currently
-uses this. @code{define-derived-mode} does @emph{not} automatically
-define the specified customization group.
-@end table
+ Here is how it was defined formerly, before
+@code{define-derived-mode} existed:
-Here is a hypothetical example:
+@smallexample
+@group
+;; @r{This isn't needed nowadays, since @code{define-derived-mode} does it.}
+(defvar text-mode-abbrev-table nil
+ "Abbrev table used while in text mode.")
+(define-abbrev-table 'text-mode-abbrev-table ())
+@end group
-@example
-(define-derived-mode hypertext-mode
- text-mode "Hypertext"
- "Major mode for hypertext.
-\\@{hypertext-mode-map@}"
- (setq case-fold-search nil))
+@group
+(defun text-mode ()
+ "Major mode for editing text intended for humans to read...
+ Special commands: \\@{text-mode-map@}
+@end group
+@group
+Turning on text-mode runs the hook `text-mode-hook'."
+ (interactive)
+ (kill-all-local-variables)
+ (use-local-map text-mode-map)
+@end group
+@group
+ (setq local-abbrev-table text-mode-abbrev-table)
+ (set-syntax-table text-mode-syntax-table)
+@end group
+@group
+ ;; @r{These four lines are absent from the current version}
+ ;; @r{not because this is done some other way, but rather}
+ ;; @r{because nowadays Text mode uses the normal definition of paragraphs.}
+ (make-local-variable 'paragraph-start)
+ (setq paragraph-start (concat "[ \t]*$\\|" page-delimiter))
+ (make-local-variable 'paragraph-separate)
+ (setq paragraph-separate paragraph-start)
+ (make-local-variable 'indent-line-function)
+ (setq indent-line-function 'indent-relative-maybe)
+@end group
+@group
+ (setq mode-name "Text")
+ (setq major-mode 'text-mode)
+ (run-mode-hooks 'text-mode-hook)) ; @r{Finally, this permits the user to}
+ ; @r{customize the mode with a hook.}
+@end group
+@end smallexample
-(define-key hypertext-mode-map
- [down-mouse-3] 'do-hyper-link)
-@end example
+@cindex @file{lisp-mode.el}
+ The three Lisp modes (Lisp mode, Emacs Lisp mode, and Lisp
+Interaction mode) have more features than Text mode and the code is
+correspondingly more complicated. Here are excerpts from
+@file{lisp-mode.el} that illustrate how these modes are written.
-Do not write an @code{interactive} spec in the definition;
-@code{define-derived-mode} does that automatically.
-@end defmac
+@cindex syntax table example
+@smallexample
+@group
+;; @r{Create mode-specific table variables.}
+(defvar lisp-mode-syntax-table nil "")
+(defvar lisp-mode-abbrev-table nil "")
+@end group
-@node Generic Modes
-@subsection Generic Modes
-@cindex generic mode
+@group
+(defvar emacs-lisp-mode-syntax-table
+ (let ((table (make-syntax-table)))
+ (let ((i 0))
+@end group
-@dfn{Generic modes} are simple major modes with basic support for
-comment syntax and Font Lock mode. They are primarily useful for
-configuration files. To define a generic mode, use the macro
-@code{define-generic-mode}. See the file @file{generic-x.el} for some
-examples of the use of @code{define-generic-mode}.
+@group
+ ;; @r{Set syntax of chars up to @samp{0} to say they are}
+ ;; @r{part of symbol names but not words.}
+ ;; @r{(The digit @samp{0} is @code{48} in the @acronym{ASCII} character set.)}
+ (while (< i ?0)
+ (modify-syntax-entry i "_ " table)
+ (setq i (1+ i)))
+ ;; @r{@dots{} similar code follows for other character ranges.}
+@end group
+@group
+ ;; @r{Then set the syntax codes for characters that are special in Lisp.}
+ (modify-syntax-entry ? " " table)
+ (modify-syntax-entry ?\t " " table)
+ (modify-syntax-entry ?\f " " table)
+ (modify-syntax-entry ?\n "> " table)
+@end group
+@group
+ ;; @r{Give CR the same syntax as newline, for selective-display.}
+ (modify-syntax-entry ?\^m "> " table)
+ (modify-syntax-entry ?\; "< " table)
+ (modify-syntax-entry ?` "' " table)
+ (modify-syntax-entry ?' "' " table)
+ (modify-syntax-entry ?, "' " table)
+@end group
+@group
+ ;; @r{@dots{}likewise for many other characters@dots{}}
+ (modify-syntax-entry ?\( "() " table)
+ (modify-syntax-entry ?\) ")( " table)
+ (modify-syntax-entry ?\[ "(] " table)
+ (modify-syntax-entry ?\] ")[ " table))
+ table))
+@end group
+@group
+;; @r{Create an abbrev table for lisp-mode.}
+(define-abbrev-table 'lisp-mode-abbrev-table ())
+@end group
+@end smallexample
-@defmac define-generic-mode mode comment-list keyword-list font-lock-list auto-mode-list function-list &optional docstring
-This macro creates a new generic mode. The argument @var{mode} (an
-unquoted symbol) is the major mode command. The optional argument
-@var{docstring} is the documentation for the mode command. If you do
-not supply it, @code{define-generic-mode} uses a default documentation
-string instead.
-
-@var{comment-list} is a list in which each element is either a
-character, a string of one or two characters, or a cons cell. A
-character or a string is set up in the mode's syntax table as a
-``comment starter.'' If the entry is a cons cell, the @sc{car} is set
-up as a ``comment starter'' and the @sc{cdr} as a ``comment ender.''
-(Use @code{nil} for the latter if you want comments to end at the end
-of the line.) Note that the syntax table has limitations about what
-comment starters and enders are actually possible. @xref{Syntax
-Tables}.
+ The three modes for Lisp share much of their code. For instance,
+each calls the following function to set various variables:
-@var{keyword-list} is a list of keywords to highlight with
-@code{font-lock-keyword-face}. Each keyword should be a string.
-@var{font-lock-list} is a list of additional expressions to highlight.
-Each element of this list should have the same form as an element of
-@code{font-lock-keywords}. @xref{Search-based Fontification}.
+@smallexample
+@group
+(defun lisp-mode-variables (lisp-syntax)
+ (when lisp-syntax
+ (set-syntax-table lisp-mode-syntax-table))
+ (setq local-abbrev-table lisp-mode-abbrev-table)
+ @dots{}
+@end group
+@end smallexample
-@var{auto-mode-list} is a list of regular expressions to add to the
-variable @code{auto-mode-alist}. These regular expressions are added
-when Emacs runs the macro expansion.
+ In Lisp and most programming languages, we want the paragraph
+commands to treat only blank lines as paragraph separators. And the
+modes should undestand the Lisp conventions for comments. The rest of
+@code{lisp-mode-variables} sets this up:
-@var{function-list} is a list of functions to call to do some
-additional setup. The mode command calls these functions just before
-it runs the mode hook variable @code{@var{mode}-hook}.
-@end defmac
+@smallexample
+@group
+ (make-local-variable 'paragraph-start)
+ (setq paragraph-start (concat page-delimiter "\\|$" ))
+ (make-local-variable 'paragraph-separate)
+ (setq paragraph-separate paragraph-start)
+ @dots{}
+@end group
+@group
+ (make-local-variable 'comment-indent-function)
+ (setq comment-indent-function 'lisp-comment-indent))
+ @dots{}
+@end group
+@end smallexample
-@node Mode Hooks
-@subsection Mode Hooks
+ Each of the different Lisp modes has a slightly different keymap. For
+example, Lisp mode binds @kbd{C-c C-z} to @code{run-lisp}, but the other
+Lisp modes do not. However, all Lisp modes have some commands in
+common. The following code sets up the common commands:
- The two last things a major mode function should do is run its mode
-hook and finally the mode independent normal hook
-@code{after-change-major-mode-hook}. If the major mode is a derived
-mode, that is if it calls another major mode (the parent mode) in its
-body, then the parent's mode hook is run just before the derived
-mode's hook. Neither the parent's mode hook nor
-@code{after-change-major-mode-hook} are run at the end of the actual
-call to the parent mode. This applies recursively if the parent mode
-has itself a parent. That is, the mode hooks of all major modes
-called directly or indirectly by the major mode function are all run
-in sequence at the end, just before
-@code{after-change-major-mode-hook}.
+@smallexample
+@group
+(defvar shared-lisp-mode-map ()
+ "Keymap for commands shared by all sorts of Lisp modes.")
- These conventions are new in Emacs 22, and some major modes
-implemented by users do not follow them yet. So if you put a function
-onto @code{after-change-major-mode-hook}, keep in mind that some modes
-will fail to run it. If a user complains about that, you can respond,
-``That major mode fails to follow Emacs conventions, and that's why it
-fails to work. Please fix the major mode.'' In most cases, that is
-good enough, so go ahead and use @code{after-change-major-mode-hook}.
-However, if a certain feature needs to be completely reliable,
-it should not use @code{after-change-major-mode-hook} as of yet.
+;; @r{Putting this @code{if} after the @code{defvar} is an older style.}
+(if shared-lisp-mode-map
+ ()
+ (setq shared-lisp-mode-map (make-sparse-keymap))
+ (define-key shared-lisp-mode-map "\e\C-q" 'indent-sexp)
+ (define-key shared-lisp-mode-map "\177"
+ 'backward-delete-char-untabify))
+@end group
+@end smallexample
- When you defined a major mode using @code{define-derived-mode}, it
-automatically makes sure these conventions are followed. If you
-define a major mode ``from scratch'', not using
-@code{define-derived-mode}, make sure the major mode command follows
-these and other conventions. @xref{Major Mode Conventions}. You use
-these functions to do it properly.
+@noindent
+And here is the code to set up the keymap for Lisp mode:
-@defun run-mode-hooks &rest hookvars
-Major modes should run their mode hook using this function. It is
-similar to @code{run-hooks} (@pxref{Hooks}), but it also runs
-@code{after-change-major-mode-hook}.
+@smallexample
+@group
+(defvar lisp-mode-map ()
+ "Keymap for ordinary Lisp mode...")
-When the call to this function is dynamically inside a
-@code{delay-mode-hooks} form, this function does not run any hooks.
-Instead, it arranges for the next call to @code{run-mode-hooks} to run
-@var{hookvars}.
-@end defun
+(if lisp-mode-map
+ ()
+ (setq lisp-mode-map (make-sparse-keymap))
+ (set-keymap-parent lisp-mode-map shared-lisp-mode-map)
+ (define-key lisp-mode-map "\e\C-x" 'lisp-eval-defun)
+ (define-key lisp-mode-map "\C-c\C-z" 'run-lisp))
+@end group
+@end smallexample
-@defmac delay-mode-hooks body@dots{}
-This macro executes @var{body} like @code{progn}, but all calls to
-@code{run-mode-hooks} inside @var{body} delay running their hooks.
-They will be run by the first call to @code{run-mode-hooks} after exit
-from @code{delay-mode-hooks}. This is the proper way for a major mode
-command to invoke its parent mode.
-@end defmac
+ Finally, here is the complete major mode function definition for
+Lisp mode.
-@defvar after-change-major-mode-hook
-Every major mode function should run this normal hook at its very end.
-It normally does not need to do so explicitly. Indeed, a major mode
-function should normally run its mode hook with @code{run-mode-hooks}
-as the very last thing it does, and the last thing
-@code{run-mode-hooks} does is run @code{after-change-major-mode-hook}.
-@end defvar
+@smallexample
+@group
+(defun lisp-mode ()
+ "Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
+Commands:
+Delete converts tabs to spaces as it moves back.
+Blank lines separate paragraphs. Semicolons start comments.
+\\@{lisp-mode-map@}
+Note that `run-lisp' may be used either to start an inferior Lisp job
+or to switch back to an existing one.
+@end group
+
+@group
+Entry to this mode calls the value of `lisp-mode-hook'
+if that value is non-nil."
+ (interactive)
+ (kill-all-local-variables)
+@end group
+@group
+ (use-local-map lisp-mode-map) ; @r{Select the mode's keymap.}
+ (setq major-mode 'lisp-mode) ; @r{This is how @code{describe-mode}}
+ ; @r{finds out what to describe.}
+ (setq mode-name "Lisp") ; @r{This goes into the mode line.}
+ (lisp-mode-variables t) ; @r{This defines various variables.}
+ (make-local-variable 'comment-start-skip)
+ (setq comment-start-skip
+ "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *")
+ (make-local-variable 'font-lock-keywords-case-fold-search)
+ (setq font-lock-keywords-case-fold-search t)
+@end group
+@group
+ (setq imenu-case-fold-search t)
+ (set-syntax-table lisp-mode-syntax-table)
+ (run-mode-hooks 'lisp-mode-hook)) ; @r{This permits the user to use a}
+ ; @r{hook to customize the mode.}
+@end group
+@end smallexample
@node Minor Modes
@section Minor Modes
@end smallexample
@noindent
-or like this, using @code{add-to-list} (@pxref{Setting Variables}):
+or like this, using @code{add-to-list} (@pxref{List Variables}):
@smallexample
@group
standard one. The editor command loop handles this function specially.)
The key sequences bound in a minor mode should consist of @kbd{C-c}
-followed by a punctuation character @emph{other than} @kbd{@{},
-@kbd{@}}, @kbd{<}, @kbd{>}, @kbd{:}, and @kbd{;}. (Those few punctuation
-characters are reserved for major modes.)
+followed by one of @kbd{.,/?`'"[]\|~!#$%^&*()-_+=}. (The other
+punctuation characters are reserved for major modes.)
@node Defining Minor Modes
@subsection Defining Minor Modes
implementing a mode in one self-contained definition.
@defmac define-minor-mode mode doc [init-value [lighter [keymap]]] keyword-args@dots{} body@dots{}
-@tindex define-minor-mode
This macro defines a new minor mode whose name is @var{mode} (a
symbol). It defines a command named @var{mode} to toggle the minor
mode, with @var{doc} as its documentation string. It also defines a
Definitions}.
@item :global @var{global}
-If non-@code{nil} specifies that the minor mode should be global. By
-default, minor modes defined with @code{define-minor-mode} are
-buffer-local.
+If non-@code{nil}, this specifies that the minor mode should be global
+rather than buffer-local. It defaults to @code{nil}.
+
+One of the effects of making a minor mode global is that the
+@var{mode} variable becomes a customization variable. Toggling it
+through the Custom interface turns the mode on and off, and its value
+can be saved for future Emacs sessions (@pxref{Saving
+Customizations,,, emacs, The GNU Emacs Manual}. For the saved
+variable to work, you should ensure that the @code{define-minor-mode}
+form is evaluated each time Emacs starts; for packages that are not
+part of Emacs, the easiest way to do this is to specify a
+@code{:require} keyword.
@item :init-value @var{init-value}
This is equivalent to specifying @var{init-value} positionally.
@end smallexample
@noindent
-This defines a minor mode named ``Hungry mode'', a command named
+This defines a minor mode named ``Hungry mode,'' a command named
@code{hungry-mode} to toggle it, a variable named @code{hungry-mode}
which indicates whether the mode is enabled, and a variable named
@code{hungry-mode-map} which holds the keymap that is active when the
:group 'hunger)
@end smallexample
-@defmac define-global-minor-mode global-mode mode turn-on keyword-args@dots{}
-This defines a global minor mode named @var{global-mode} whose meaning
-is to enable the buffer-local minor mode @var{mode} in every buffer.
-To turn on the minor mode in a buffer, it uses the function
+@defmac define-globalized-minor-mode global-mode mode turn-on keyword-args@dots{}
+This defines a global toggle named @var{global-mode} whose meaning is
+to enable or disable the buffer-local minor mode @var{mode} in all
+buffers. To turn on the minor mode in a buffer, it uses the function
@var{turn-on}; to turn off the minor mode, it calls @code{mode} with
@minus{}1 as argument.
+Globally enabling the mode also affects buffers subsequently created
+by visiting files, and buffers that use a major mode other than
+Fundamental mode; but it does not detect the creation of a new buffer
+in Fundamental mode.
+
+This defines the customization option @var{global-mode} (@pxref{Customization}),
+which can be toggled in the Custom interface to turn the minor mode on
+and off. As with @code{define-minor-mode}, you should ensure that the
+@code{define-globalized-minor-mode} form is evaluated each time Emacs
+starts, for example by providing a @code{:require} keyword.
+
Use @code{:group @var{group}} in @var{keyword-args} to specify the
custom group for the mode variable of the global minor mode.
@end defmac
@subsection Mode Line Basics
@code{mode-line-format} is a buffer-local variable that holds a
-@dfn{mode line construct}, a kind of template, which controls the
-display the mode line of the current buffer. All windows for the same
-buffer use the same @code{mode-line-format}, so their mode lines
-appear the same---except for scrolling percentages, and line and
-column numbers, since those depend on point and on how the window is
-scrolled. The value of @code{header-line-format} specifies the
-buffer's header line in the same way, with a mode line construct.
-
- For efficiency, Emacs does not recompute the mode line and header
-line of a window in every redisplay. It does so when circumstances
+@dfn{mode line construct}, a kind of template, which controls what is
+displayed on the mode line of the current buffer. The value of
+@code{header-line-format} specifies the buffer's header line in the
+same way. All windows for the same buffer use the same
+@code{mode-line-format} and @code{header-line-format}.
+
+ For efficiency, Emacs does not continuously recompute the mode
+line and header line of a window. It does so when circumstances
appear to call for it---for instance, if you change the window
configuration, switch buffers, narrow or widen the buffer, scroll, or
change the buffer's modification status. If you modify any of the
update of the mode line so as to display the new information or
display it in the new way.
-@c Emacs 19 feature
@defun force-mode-line-update &optional all
Force redisplay of the current buffer's mode line and header line.
The next redisplay will update the mode line and header line based on
@table @code
@cindex percent symbol in mode line
@item @var{string}
-A string as a mode-line construct appears verbatim in the mode line
-except for @dfn{@code{%}-constructs} in it. These stand for
-substitution of other data; see @ref{%-Constructs}.
-
-If the string has @code{face} properties, they are copied into the
-mode line contents too (@pxref{Properties in Mode}). Any characters
-in the mode line which have no @code{face} properties are displayed,
-by default, in the face @code{mode-line} or @code{mode-line-inactive}
-(@pxref{Standard Faces,,, emacs, The GNU Emacs Manual}).
+A string as a mode-line construct appears verbatim except for
+@dfn{@code{%}-constructs} in it. These stand for substitution of
+other data; see @ref{%-Constructs}.
+
+If parts of the string have @code{face} properties, they control
+display of the text just as they would text in the buffer. Any
+characters which have no @code{face} properties are displayed, by
+default, in the face @code{mode-line} or @code{mode-line-inactive}
+(@pxref{Standard Faces,,, emacs, The GNU Emacs Manual}). The
+@code{help-echo} and @code{local-map} properties in @var{string} have
+special meanings. @xref{Properties in Mode}.
@item @var{symbol}
A symbol as a mode-line construct stands for its value. The value of
non-@code{nil} @code{risky-local-variable} property), all text
properties specified in @var{symbol}'s value are ignored. This
includes the text properties of strings in @var{symbol}'s value, as
-well as all @code{:eval} and @code{:propertize} forms in it.
+well as all @code{:eval} and @code{:propertize} forms in it. (The
+reason for this is security: non-risky variables could be set
+automatically from file variables without prompting the user.)
@item (@var{string} @var{rest}@dots{})
@itemx (@var{list} @var{rest}@dots{})
the user or by Lisp programs (such as @code{display-time} and major
modes) via changes to those variables remain effective.
-@cindex Shell mode @code{mode-line-format}
Here is an example of a @code{mode-line-format} that might be
useful for @code{shell-mode}, since it contains the host name and default
directory.
@item %c
The current column number of point.
+@item %e
+When Emacs is nearly out of memory for Lisp objects, a brief message
+saying so. Otherwise, this is empty.
+
@item %f
The visited file name, obtained with the @code{buffer-file-name}
function. @xref{Buffer File Name}.
meaningful distinction only on certain operating systems (@pxref{MS-DOS
File Types}).
+@item %z
+The mnemonics of keyboard, terminal, and buffer coding systems.
+
+@item %Z
+Like @samp{%z}, but including the end-of-line format.
+
@item %*
@samp{%} if the buffer is read only (see @code{buffer-read-only}); @*
@samp{*} if the buffer is modified (see @code{buffer-modified-p}); @*
property.
@end enumerate
- You use the @code{local-map} property to specify a keymap. Like any
-keymap, it can bind character keys and function keys; but that has no
-effect, since it is impossible to move point into the mode line. This
-keymap can only take real effect for mouse clicks.
+ You can use the @code{local-map} property to specify a keymap. This
+keymap only takes real effect for mouse clicks; binding character keys
+and function keys to it has no effect, since it is impossible to move
+point into the mode line.
When the mode line refers to a variable which does not have a
non-@code{nil} @code{risky-local-variable} property, any text
feature works just like the mode-line feature, except that it's
controlled by different variables.
-@tindex header-line-format
@defvar header-line-format
This variable, local in every buffer, specifies how to display the
header line, for windows displaying the buffer. The format of the value
is the same as for @code{mode-line-format} (@pxref{Mode Line Data}).
@end defvar
-@tindex default-header-line-format
@defvar default-header-line-format
This variable holds the default @code{header-line-format} for buffers
that do not override it. This is the same as @code{(default-value
@node Font Lock Mode
@section Font Lock Mode
-@cindex Font Lock Mode
+@cindex Font Lock mode
@dfn{Font Lock mode} is a feature that automatically attaches
@code{face} properties to certain parts of the buffer based on their
* Syntactic Font Lock:: Fontification based on syntax tables.
* Setting Syntax Properties:: Defining character syntax based on context
using the Font Lock mechanism.
-* Multi line Font Lock Elements:: How to coerce Font Lock into properly
- highlighting multiline elements.
+* Multiline Font Lock:: How to coerce Font Lock into properly
+ highlighting multiline constructs.
@end menu
@node Font Lock Basics
@defvar font-lock-defaults
This variable is set by major modes, as a buffer-local variable, to
specify how to fontify text in that mode. It automatically becomes
-buffer-local when you set it. The value should look like this:
+buffer-local when you set it. If its value is @code{nil}, Font-Lock
+mode does no highlighting, and you can use the @samp{Faces} menu
+(under @samp{Edit} and then @samp{Text Properties} in the menu bar) to
+assign faces explicitly to text in the buffer.
+
+If non-@code{nil}, the value should look like this:
@example
(@var{keywords} [@var{keywords-only} [@var{case-fold}
symbol how to do level 2, and so on. @xref{Levels of Font Lock}.
The second element, @var{keywords-only}, specifies the value of the
-variable @code{font-lock-keywords-only}. If this is non-@code{nil},
-syntactic fontification (of strings and comments) is not performed.
-@xref{Syntactic Font Lock}.
+variable @code{font-lock-keywords-only}. If this is omitted or
+@code{nil}, syntactic fontification (of strings and comments) is also
+performed. If this is non-@code{nil}, such fontification is not
+performed. @xref{Syntactic Font Lock}.
The third element, @var{case-fold}, specifies the value of
@code{font-lock-keywords-case-fold-search}. If it is non-@code{nil},
elements. @xref{Other Font Lock Variables}.
@end defvar
+ If your mode fontifies text explicitly by adding
+@code{font-lock-face} properties, it can specify @code{(nil t)} for
+@code{font-lock-defaults} to turn off all automatic fontification.
+However, this is not required; it is possible to fontify some things
+using @code{font-lock-face} properties and set up automatic
+fontification for other parts of the text.
+
@node Search-based Fontification
@subsection Search-based Fontification
@strong{Warning:} Do not design an element of @code{font-lock-keywords}
to match text which spans lines; this does not work reliably.
-For details, see @xref{Multi line Font Lock Elements}.
+For details, see @xref{Multiline Font Lock}.
You can use @var{case-fold} in @code{font-lock-defaults} to specify
the value of @code{font-lock-keywords-case-fold-search} which says
If your mode does not use any of the other machinery of Font Lock
(i.e. it only uses the @code{font-lock-face} property), it should not
-set the variable @code{font-lock-defaults}. That way, it will not
-cause loading of the @file{font-lock} library.
+set the variable @code{font-lock-defaults}.
@node Faces for Font Lock
@subsection Faces for Font Lock
+@cindex faces for font lock
+@cindex font lock faces
You can make Font Lock mode use any face, but several faces are
defined specifically for Font Lock mode. Each of these symbols is both
@vindex font-lock-preprocessor-face
Used (typically) for preprocessor commands.
+@item font-lock-negation-char-face
+@vindex font-lock-negation-char-face
+Used (typically) for easily-overlooked negation characters.
+
@item font-lock-warning-face
@vindex font-lock-warning-face
Used (typically) for constructs that are peculiar, or that greatly
@node Syntactic Font Lock
@subsection Syntactic Font Lock
+@cindex syntactic font lock
Syntactic fontification uses the syntax table to find comments and
string constants (@pxref{Syntax Tables}). It highlights them using
@code{font-lock-comment-face} and @code{font-lock-string-face}
-(@pxref{Faces for Font Lock}). There are several variables that
-affect syntactic fontification; you should set them by means of
-@code{font-lock-defaults} (@pxref{Font Lock Basics}).
+(@pxref{Faces for Font Lock}), or whatever
+@code{font-lock-syntactic-face-function} chooses. There are several
+variables that affect syntactic fontification; you should set them by
+means of @code{font-lock-defaults} (@pxref{Font Lock Basics}).
@defvar font-lock-keywords-only
Non-@code{nil} means Font Lock should not do syntactic fontification;
@defvar font-lock-syntax-table
This variable holds the syntax table to use for fontification of
comments and strings. Specify it using @var{syntax-alist} in
-@code{font-lock-defaults}.
+@code{font-lock-defaults}. If this is @code{nil}, fontification uses
+the buffer's syntax table.
@end defvar
@defvar font-lock-beginning-of-syntax-function
This can be used to highlighting different kinds of strings or
comments differently. It is also sometimes abused together with
-@code{font-lock-syntactic-keywords} to highlight elements that span
-multiple lines, but this is too obscure to document in this manual.
+@code{font-lock-syntactic-keywords} to highlight constructs that span
+multiple lines, but this is too esoteric to document here.
Specify this variable using @var{other-vars} in
@code{font-lock-defaults}.
@code{font-lock-defaults}.
@end defvar
-@node Multi line Font Lock Elements
-@subsection Multi line Font Lock Elements
-@cindex multi line font lock
-
-Normally, Font Lock elements specified via @code{font-lock-keywords}
-should not match across multiple lines. If they do, Font Lock may
-fail to highlight them properly. This is fundamentally due to the
-fact that Font Lock does not always look at the whole buffer at
-a time, for obvious performance reasons, and instead only looks
-at a small chunk at a time. In order for the highlight to be correct,
-a chunk should not straddle an element matched by
-@code{font-lock-keywords}. The default heuristic used for this is to
-start and end chunks at the beginning resp. end of a line.
-
-In order for Font Lock to properly highlight elements that span
-multiple lines, the package author has to ensure two things: correct
-@emph{discovery} and correct @emph{re}highlighting. The first ensures
-that Font Lock finds all multiline elements. The second ensures that
-Font Lock will correctly re-highlight all the relevant text when
-a multiline element is changed, e.g. causing some of the text that was
-previously part of a multiline element to not be part of it any more.
-The two aspects are closely related and often getting one of the two
-to work will appear to make the other also work. But both aspects
-have to be taken care of for the multiline elements to be
-reliably highlighted.
-
-Correct @emph{re}highlighting of multiline elements can be done in the
-following ways:
+@node Multiline Font Lock
+@subsection Multiline Font Lock Constructs
+@cindex multiline font lock
+
+ Normally, elements of @code{font-lock-keywords} should not match
+across multiple lines; that doesn't work reliably, because Font Lock
+usually scans just part of the buffer, and it can miss a multi-line
+construct that crosses the line boundary where the scan starts. (The
+scan normally starts at the beginning of a line.)
+
+ Making elements that match multiline constructs work properly has
+two aspects: correct @emph{identification} and correct
+@emph{rehighlighting}. The first means that Font Lock finds all
+multiline constructs. The second means that Font Lock will correctly
+rehighlight all the relevant text when a multiline construct is
+changed---for example, if some of the text that was previously part of
+a multiline construct ceases to be part of it. The two aspects are
+closely related, and often getting one of them to work will appear to
+make the other also work. However, for reliable results you must
+attend explicitly to both aspects.
+
+ There are three ways to ensure correct identification of multiline
+constructs:
+
@itemize
@item
-Apply the @code{font-lock-multiline} property to the element.
-This will ensure that the whole element will always be immediately
-rehighlighted if any part of it is changed. This can sometimes be
-done automatically by setting the @code{font-lock-multiline} variable.
-@item
-Rely on @code{jit-lock-contextually}. This will only rehighlight the
-part of the element that follows the actual change, and will do it
-after a short delay. This only works if the highlighting of the
-various parts of your multiline element never depends on text in
-subsequent lines. Since @code{jit-lock-contextually} is activated by
-default, this can be an attractive solution.
+Add a function to @code{font-lock-extend-region-functions} that does
+the @emph{identification} and extends the scan so that the scanned
+text never starts or ends in the middle of a multiline construct.
@item
-Apply the @code{jit-lock-defer-multiline} property to the element.
-This works only if @code{jit-lock-contextually} is used and allows it
-to also work when highlighting does depend on subsequent lines.
+Use the @code{font-lock-fontify-region-function} hook similarly to
+extend the scan so that the scanned text never starts or ends in the
+middle of a multiline construct.
@item
+Somehow identify the multiline construct right when it gets inserted
+into the buffer (or at any point after that but before font-lock
+tries to highlight it), and mark it with a @code{font-lock-multiline}
+which will instruct font-lock not to start or end the scan in the
+middle of the construct.
@end itemize
-Discovery of new multiline elements can be done in the following ways:
+ There are three ways to do rehighlighting of multiline constructs:
+
@itemize
@item
-Manually placing a @code{font-lock-multiline} or
-@code{jit-lock-defer-multiline} property on the element when it is
-added to the buffer.
+Place a @code{font-lock-multiline} property on the construct. This
+will rehighlight the whole construct if any part of it is changed. In
+some cases you can do this automatically by setting the
+@code{font-lock-multiline} variable, which see.
+@item
+Make sure @code{jit-lock-contextually} is set and rely on it doing its
+job. This will only rehighlight the part of the construct that
+follows the actual change, and will do it after a short delay.
+This only works if the highlighting of the various parts of your
+multiline construct never depends on text in subsequent lines.
+Since @code{jit-lock-contextually} is activated by default, this can
+be an attractive solution.
@item
-Using the @code{font-lock-fontify-region-function} hook to extend the
-highlighted chunks so that they never start or end in the middle of
-multiline element.
+Place a @code{jit-lock-defer-multiline} property on the construct.
+This works only if @code{jit-lock-contextually} is used, and with the
+same delay before rehighlighting, but like @code{font-lock-multiline},
+it also handles the case where highlighting depends on
+subsequent lines.
@end itemize
@menu
@node Font Lock Multiline
@subsubsection Font Lock Multiline
-In order to make it possible to properly @emph{re}highlight elements that
-span multiple lines, Font Lock obeys a special text property
-@code{font-lock-multiline} which if non-@code{nil} indicates that this
-piece of text was highlighted as part of a multiline construct.
-So when Font Lock is asked to rehighlight a region, it first verifies
-the two boundaries and extends them as needed so they do not fall in
-the middle of a piece of text marked with the
-@code{font-lock-multiline} property. Immediately after that, it also
-erases all @code{font-lock-multiline} properties from the region it is
-about to highlight, so it is the responsability of the highlighting
-specification (mostly @code{font-lock-keywords}) to make sure that
-this property is re-added where needed so as to inform the next round
-of Font Locking of the presence of a multiline construct.
-
-It is important to understand that the @code{font-lock-multiline}
-property should preferably only be used on Font Lock elements of
-moderate size: every time that text is modified within a multiline
-element (or nearby), the whole multiline element will be completely
-re-highlighted, so if its size is large, the time to font-lock may
-render editing painfully slow.
+ One way to ensure reliable rehighlighting of multiline Font Lock
+constructs is to put on them the text property @code{font-lock-multiline}.
+It should be present and non-@code{nil} for text that is part of a
+multiline construct.
+
+ When Font Lock is about to highlight a range of text, it first
+extends the boundaries of the range as necessary so that they do not
+fall within text marked with the @code{font-lock-multiline} property.
+Then it removes any @code{font-lock-multiline} properties from the
+range, and highlights it. The highlighting specification (mostly
+@code{font-lock-keywords}) must reinstall this property each time,
+whenever it is appropriate.
+
+ @strong{Warning:} don't use the @code{font-lock-multiline} property
+on large ranges of text, because that will make rehighlighting slow.
@defvar font-lock-multiline
If the @code{font-lock-multiline} variable is set to @code{t}, Font
-Lock will try to automatically add the @code{font-lock-multiline}
-property on the keywords that span several lines. This is no silver
-bullet however since it slows down Font Lock somewhat, and may miss
-some cases or make the property larger or smaller than necessary,
-especially for keywords whose @var{MATCHER} is a function, in which
-case the function needs to make sure that the submatch 0 covers the
-whole relevant multiline entity even if only a small subpart will
-be highlighted. It is often just as easy to add the
-@code{font-lock-multiline} property by hand.
+Lock will try to add the @code{font-lock-multiline} property
+automatically on multiline constructs. This is not a universal
+solution, however, since it slows down Font Lock somewhat. It can
+miss some multiline constructs, or make the property larger or smaller
+than necessary.
+
+For elements whose @var{matcher} is a function, the function should
+ensure that submatch 0 covers the whole relevant multiline construct,
+even if only a small subpart will be highlighted. It is often just as
+easy to add the @code{font-lock-multiline} property by hand.
@end defvar
-As mentioned, this property is mostly intended to ensure proper
-@emph{re}fontification. It does not magically discover new
-multiline elements. To discover new multiline elements, all that is
-required is that font-lock operate on large enough chunks at a time.
-This will happen by accident on many cases, which may give the
-impression that multiline elements magically work. If you set the
-@code{font-lock-multiline} variable, this impression will be even
-stronger since the highlighting of those found elements will be
-properly preserved from then on. But for such multiline elements to
-be found reliably, you will need to either manually put the
-@code{font-lock-multiline} property from some appropriate piece of
-code run before Font Lock, or hook into
-@code{font-lock-fontify-region-function} to manually extend the chunks
-of text that Font Lock highlights so they never start or stop in the
-middle of a multiline element.
+ The @code{font-lock-multiline} property is meant to ensure proper
+refontification; it does not automatically identify new multiline
+constructs. Identifying the requires that Font-Lock operate on large
+enough chunks at a time. This will happen by accident on many cases,
+which may give the impression that multiline constructs magically work.
+If you set the @code{font-lock-multiline} variable non-@code{nil},
+this impression will be even stronger, since the highlighting of those
+constructs which are found will be properly updated from then on.
+But that does not work reliably.
+
+ To find multiline constructs reliably, you must either manually
+place the @code{font-lock-multiline} property on the text before
+Font-Lock looks at it, or use
+@code{font-lock-fontify-region-function}.
@node Region to Fontify
@subsubsection Region to Fontify after a Buffer Change
- When a buffer is changed, the region that Font Lock refontifies is by
-default the smallest sequence of whole lines that spans the change.
+ When a buffer is changed, the region that Font Lock refontifies is
+by default the smallest sequence of whole lines that spans the change.
While this works well most of the time, sometimes it doesn't---for
-example, when a buffer change has changed the syntactic meaning of text
-on an earlier line.
+example, when a change alters the syntactic meaning of text on an
+earlier line.
-You can enlarge (or even reduce) the region to fontify by setting @c either of
-the following variables:
+ You can enlarge (or even reduce) the region to fontify by setting
+one the following variables:
-@defvar font-lock-extend-region-function
-This buffer-local variable is either @code{nil} or is a function that
-determines the region to fontify, which Emacs then calls after each
-buffer change.
+@defvar font-lock-extend-after-change-region-function
+This buffer-local variable is either @code{nil} or a function for
+Font-Lock to call to determine the region to scan and fontify.
The function is given three parameters, the standard @var{beg},
-@var{end}, and @var{old-len} from after-change-functions (@pxref{Change
-Hooks}). It should return either a cons of the beginning and end buffer
-positions (in that order) of the region to fontify, or @code{nil} (which
-directs the caller to fontify the default region). This function needs
-to preserve point, the match-data, and the current restriction.
-The region it returns may start or end in the middle of a line.
+@var{end}, and @var{old-len} from after-change-functions
+(@pxref{Change Hooks}). It should return either a cons of the
+beginning and end buffer positions (in that order) of the region to
+fontify, or @code{nil} (which means choose the region in the standard
+way). This function needs to preserve point, the match-data, and the
+current restriction. The region it returns may start or end in the
+middle of a line.
Since this function is called after every buffer change, it should be
reasonably fast.
HCoop / bpt / emacs.git / blobdiff