2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998-1999, 2001-2011 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
5 @setfilename ../../info/modes
6 @node Modes, Documentation, Keymaps, Top
7 @chapter Major and Minor Modes
10 A @dfn{mode} is a set of definitions that customize Emacs and can be
11 turned on and off while you edit. There are two varieties of modes:
12 @dfn{major modes}, which are mutually exclusive and used for editing
13 particular kinds of text, and @dfn{minor modes}, which provide features
14 that users can enable individually.
16 This chapter describes how to write both major and minor modes, how to
17 indicate them in the mode line, and how they run hooks supplied by the
18 user. For related topics such as keymaps and syntax tables, see
19 @ref{Keymaps}, and @ref{Syntax Tables}.
22 * Hooks:: How to use hooks; how to write code that provides hooks.
23 * Major Modes:: Defining major modes.
24 * Minor Modes:: Defining minor modes.
25 * Mode Line Format:: Customizing the text that appears in the mode line.
26 * Imenu:: How a mode can provide a menu
27 of definitions in the buffer.
28 * Font Lock Mode:: How modes can highlight text according to syntax.
29 * Auto-Indentation:: How to teach Emacs to indent for a major mode.
30 * Desktop Save Mode:: How modes can have buffer state saved between
38 A @dfn{hook} is a variable where you can store a function or functions
39 to be called on a particular occasion by an existing program. Emacs
40 provides hooks for the sake of customization. Most often, hooks are set
41 up in the init file (@pxref{Init File}), but Lisp programs can set them also.
42 @xref{Standard Hooks}, for a list of standard hook variables.
45 Most of the hooks in Emacs are @dfn{normal hooks}. These variables
46 contain lists of functions to be called with no arguments. By
47 convention, whenever the hook name ends in @samp{-hook}, that tells
48 you it is normal. We try to make all hooks normal, as much as
49 possible, so that you can use them in a uniform way.
51 Every major mode function is supposed to run a normal hook called
52 the @dfn{mode hook} as the one of the last steps of initialization.
53 This makes it easy for a user to customize the behavior of the mode,
54 by overriding the buffer-local variable assignments already made by
55 the mode. Most minor mode functions also run a mode hook at the end.
56 But hooks are used in other contexts too. For example, the hook
57 @code{suspend-hook} runs just before Emacs suspends itself
58 (@pxref{Suspending Emacs}).
60 The recommended way to add a hook function to a normal hook is by
61 calling @code{add-hook} (see below). The hook functions may be any of
62 the valid kinds of functions that @code{funcall} accepts (@pxref{What
63 Is a Function}). Most normal hook variables are initially void;
64 @code{add-hook} knows how to deal with this. You can add hooks either
65 globally or buffer-locally with @code{add-hook}.
68 If the hook variable's name does not end with @samp{-hook}, that
69 indicates it is probably an @dfn{abnormal hook}. That means the hook
70 functions are called with arguments, or their return values are used
71 in some way. The hook's documentation says how the functions are
72 called. You can use @code{add-hook} to add a function to an abnormal
73 hook, but you must write the function to follow the hook's calling
76 By convention, abnormal hook names end in @samp{-functions} or
77 @samp{-hooks}. If the variable's name ends in @samp{-function}, then
78 its value is just a single function, not a list of functions.
81 * Running Hooks:: How to run a hook.
82 * Setting Hooks:: How to put functions on a hook, or remove them.
86 @subsection Running Hooks
88 At the appropriate times, Emacs uses the @code{run-hooks} function
89 and the other functions below to run particular hooks.
91 @defun run-hooks &rest hookvars
92 This function takes one or more normal hook variable names as
93 arguments, and runs each hook in turn. Each argument should be a
94 symbol that is a normal hook variable. These arguments are processed
95 in the order specified.
97 If a hook variable has a non-@code{nil} value, that value should be a
98 list of functions. @code{run-hooks} calls all the functions, one by
99 one, with no arguments.
101 The hook variable's value can also be a single function---either a
102 lambda expression or a symbol with a function definition---which
103 @code{run-hooks} calls. But this usage is obsolete.
105 If the hook variable is buffer-local, the buffer-local variable will
106 be used instead of the global variable. However, if the buffer-local
107 variable contains the element @code{t}, the global hook variable will
111 @defun run-hook-with-args hook &rest args
112 This function is the way to run an abnormal hook and always call all
113 of the hook functions. It calls each of the hook functions one by
114 one, passing each of them the arguments @var{args}.
117 @defun run-hook-with-args-until-failure hook &rest args
118 This function is the way to run an abnormal hook until one of the hook
119 functions fails. It calls each of the hook functions, passing each of
120 them the arguments @var{args}, until some hook function returns
121 @code{nil}. It then stops and returns @code{nil}. If none of the
122 hook functions return @code{nil}, it returns a non-@code{nil} value.
125 @defun run-hook-with-args-until-success hook &rest args
126 This function is the way to run an abnormal hook until a hook function
127 succeeds. It calls each of the hook functions, passing each of them
128 the arguments @var{args}, until some hook function returns
129 non-@code{nil}. Then it stops, and returns whatever was returned by
130 the last hook function that was called. If all hook functions return
131 @code{nil}, it returns @code{nil} as well.
135 @subsection Setting Hooks
137 Here's an example that uses a mode hook to turn on Auto Fill mode when
138 in Lisp Interaction mode:
141 (add-hook 'lisp-interaction-mode-hook 'turn-on-auto-fill)
144 @defun add-hook hook function &optional append local
145 This function is the handy way to add function @var{function} to hook
146 variable @var{hook}. You can use it for abnormal hooks as well as for
147 normal hooks. @var{function} can be any Lisp function that can accept
148 the proper number of arguments for @var{hook}. For example,
151 (add-hook 'text-mode-hook 'my-text-hook-function)
155 adds @code{my-text-hook-function} to the hook called @code{text-mode-hook}.
157 If @var{function} is already present in @var{hook} (comparing using
158 @code{equal}), then @code{add-hook} does not add it a second time.
160 If @var{function} has a non-@code{nil} property
161 @code{permanent-local-hook}, then @code{kill-all-local-variables} (or
162 changing major modes) won't delete it from the hook variable's local
165 It is best to design your hook functions so that the order in which
166 they are executed does not matter. Any dependence on the order is
167 asking for trouble. However, the order is predictable: normally,
168 @var{function} goes at the front of the hook list, so it will be
169 executed first (barring another @code{add-hook} call). If the
170 optional argument @var{append} is non-@code{nil}, the new hook
171 function goes at the end of the hook list and will be executed last.
173 @code{add-hook} can handle the cases where @var{hook} is void or its
174 value is a single function; it sets or changes the value to a list of
177 If @var{local} is non-@code{nil}, that says to add @var{function} to the
178 buffer-local hook list instead of to the global hook list. This makes
179 the hook buffer-local and adds @code{t} to the buffer-local value. The
180 latter acts as a flag to run the hook functions in the default value as
181 well as in the local value.
184 @defun remove-hook hook function &optional local
185 This function removes @var{function} from the hook variable
186 @var{hook}. It compares @var{function} with elements of @var{hook}
187 using @code{equal}, so it works for both symbols and lambda
190 If @var{local} is non-@code{nil}, that says to remove @var{function}
191 from the buffer-local hook list instead of from the global hook list.
198 Major modes specialize Emacs for editing particular kinds of text.
199 Each buffer has only one major mode at a time. For each major mode
200 there is a function to switch to that mode in the current buffer; its
201 name should end in @samp{-mode}. These functions work by setting
202 buffer-local variable bindings and other data associated with the
203 buffer, such as a local keymap. The effect lasts until you switch
204 to another major mode in the same buffer.
207 * Major Mode Basics::
208 * Major Mode Conventions:: Coding conventions for keymaps, etc.
209 * Auto Major Mode:: How Emacs chooses the major mode automatically.
210 * Mode Help:: Finding out how to use a mode.
211 * Derived Modes:: Defining a new major mode based on another major
213 * Generic Modes:: Defining a simple major mode that supports
214 comment syntax and Font Lock mode.
215 * Mode Hooks:: Hooks run at the end of major mode functions.
216 * Example Major Modes:: Text mode and Lisp modes.
219 @node Major Mode Basics
220 @subsection Major Mode Basics
221 @cindex Fundamental mode
223 The least specialized major mode is called @dfn{Fundamental mode}.
224 This mode has no mode-specific definitions or variable settings, so each
225 Emacs command behaves in its default manner, and each option is in its
226 default state. All other major modes redefine various keys and options.
227 For example, Lisp Interaction mode provides special key bindings for
228 @kbd{C-j} (@code{eval-print-last-sexp}), @key{TAB}
229 (@code{lisp-indent-line}), and other keys.
231 When you need to write several editing commands to help you perform a
232 specialized editing task, creating a new major mode is usually a good
233 idea. In practice, writing a major mode is easy (in contrast to
234 writing a minor mode, which is often difficult).
236 If the new mode is similar to an old one, it is often unwise to
237 modify the old one to serve two purposes, since it may become harder
238 to use and maintain. Instead, copy and rename an existing major mode
239 definition and alter the copy---or use the @code{define-derived-mode}
240 macro to define a @dfn{derived mode} (@pxref{Derived Modes}). For
241 example, Rmail Edit mode is a major mode that is very similar to Text
242 mode except that it provides two additional commands. Its definition
243 is distinct from that of Text mode, but uses that of Text mode.
245 Even if the new mode is not an obvious derivative of any other mode,
246 we recommend to use @code{define-derived-mode}, since it automatically
247 enforces the most important coding conventions for you.
249 For a very simple programming language major mode that handles
250 comments and fontification, you can use @code{define-generic-mode}.
251 @xref{Generic Modes}.
253 Rmail Edit mode offers an example of changing the major mode
254 temporarily for a buffer, so it can be edited in a different way (with
255 ordinary Emacs commands rather than Rmail commands). In such cases, the
256 temporary major mode usually provides a command to switch back to the
257 buffer's usual mode (Rmail mode, in this case). You might be tempted to
258 present the temporary redefinitions inside a recursive edit and restore
259 the usual ones when the user exits; but this is a bad idea because it
260 constrains the user's options when it is done in more than one buffer:
261 recursive edits must be exited most-recently-entered first. Using an
262 alternative major mode avoids this limitation. @xref{Recursive
265 The standard GNU Emacs Lisp library directory tree contains the code
266 for several major modes, in files such as @file{text-mode.el},
267 @file{texinfo.el}, @file{lisp-mode.el}, @file{c-mode.el}, and
268 @file{rmail.el}. They are found in various subdirectories of the
269 @file{lisp} directory. You can study these libraries to see how modes
270 are written. Text mode is perhaps the simplest major mode aside from
271 Fundamental mode. Rmail mode is a complicated and specialized mode.
273 @node Major Mode Conventions
274 @subsection Major Mode Conventions
275 @cindex major mode conventions
276 @cindex conventions for writing major modes
278 The code for existing major modes follows various coding conventions,
279 including conventions for local keymap and syntax table initialization,
280 global names, and hooks. Please follow these conventions when you
281 define a new major mode. (Fundamental mode is an exception to many
282 of these conventions, because its definition is to present the global
285 This list of conventions is only partial, because each major mode
286 should aim for consistency in general with other Emacs major modes.
287 This makes Emacs as a whole more coherent. It is impossible to list
288 here all the possible points where this issue might come up; if the
289 Emacs developers point out an area where your major mode deviates from
290 the usual conventions, please make it compatible.
294 Define a command whose name ends in @samp{-mode}, with no arguments,
295 that switches to the new mode in the current buffer. This command
296 should set up the keymap, syntax table, and buffer-local variables in an
297 existing buffer, without changing the buffer's contents.
300 Write a documentation string for this command that describes the
301 special commands available in this mode. @kbd{C-h m}
302 (@code{describe-mode}) in your mode will display this string.
304 The documentation string may include the special documentation
305 substrings, @samp{\[@var{command}]}, @samp{\@{@var{keymap}@}}, and
306 @samp{\<@var{keymap}>}, which enable the documentation to adapt
307 automatically to the user's own key bindings. @xref{Keys in
311 The major mode command should start by calling
312 @code{kill-all-local-variables}. This runs the normal hook
313 @code{change-major-mode-hook}, then gets rid of the buffer-local
314 variables of the major mode previously in effect. @xref{Creating
318 The major mode command should set the variable @code{major-mode} to the
319 major mode command symbol. This is how @code{describe-mode} discovers
320 which documentation to print.
323 The major mode command should set the variable @code{mode-name} to the
324 ``pretty'' name of the mode, usually a string (but see @ref{Mode Line
325 Data}, for other possible forms). The name of the mode appears
329 @cindex functions in modes
330 Since all global names are in the same name space, all the global
331 variables, constants, and functions that are part of the mode should
332 have names that start with the major mode name (or with an abbreviation
333 of it if the name is long). @xref{Coding Conventions}.
336 In a major mode for editing some kind of structured text, such as a
337 programming language, indentation of text according to structure is
338 probably useful. So the mode should set @code{indent-line-function}
339 to a suitable function, and probably customize other variables
340 for indentation. @xref{Auto-Indentation}.
343 @cindex keymaps in modes
344 The major mode should usually have its own keymap, which is used as the
345 local keymap in all buffers in that mode. The major mode command should
346 call @code{use-local-map} to install this local map. @xref{Active
347 Keymaps}, for more information.
349 This keymap should be stored permanently in a global variable named
350 @code{@var{modename}-mode-map}. Normally the library that defines the
351 mode sets this variable.
353 @xref{Tips for Defining}, for advice about how to write the code to set
354 up the mode's keymap variable.
357 The key sequences bound in a major mode keymap should usually start with
358 @kbd{C-c}, followed by a control character, a digit, or @kbd{@{},
359 @kbd{@}}, @kbd{<}, @kbd{>}, @kbd{:} or @kbd{;}. The other punctuation
360 characters are reserved for minor modes, and ordinary letters are
363 A major mode can also rebind the keys @kbd{M-n}, @kbd{M-p} and
364 @kbd{M-s}. The bindings for @kbd{M-n} and @kbd{M-p} should normally
365 be some kind of ``moving forward and backward,'' but this does not
366 necessarily mean cursor motion.
368 It is legitimate for a major mode to rebind a standard key sequence if
369 it provides a command that does ``the same job'' in a way better
370 suited to the text this mode is used for. For example, a major mode
371 for editing a programming language might redefine @kbd{C-M-a} to
372 ``move to the beginning of a function'' in a way that works better for
375 It is also legitimate for a major mode to rebind a standard key
376 sequence whose standard meaning is rarely useful in that mode. For
377 instance, minibuffer modes rebind @kbd{M-r}, whose standard meaning is
378 rarely of any use in the minibuffer. Major modes such as Dired or
379 Rmail that do not allow self-insertion of text can reasonably redefine
380 letters and other printing characters as special commands.
383 Major modes for editing text should not define @key{RET} to do
384 anything other than insert a newline. However, it is ok for
385 specialized modes for text that users don't directly edit, such as
386 Dired and Info modes, to redefine @key{RET} to do something entirely
390 Major modes should not alter options that are primarily a matter of user
391 preference, such as whether Auto-Fill mode is enabled. Leave this to
392 each user to decide. However, a major mode should customize other
393 variables so that Auto-Fill mode will work usefully @emph{if} the user
397 @cindex syntax tables in modes
398 The mode may have its own syntax table or may share one with other
399 related modes. If it has its own syntax table, it should store this in
400 a variable named @code{@var{modename}-mode-syntax-table}. @xref{Syntax
404 If the mode handles a language that has a syntax for comments, it should
405 set the variables that define the comment syntax. @xref{Options for
406 Comments,, Options Controlling Comments, emacs, The GNU Emacs Manual}.
409 @cindex abbrev tables in modes
410 The mode may have its own abbrev table or may share one with other
411 related modes. If it has its own abbrev table, it should store this
412 in a variable named @code{@var{modename}-mode-abbrev-table}. If the
413 major mode command defines any abbrevs itself, it should pass @code{t}
414 for the @var{system-flag} argument to @code{define-abbrev}.
415 @xref{Defining Abbrevs}.
418 The mode should specify how to do highlighting for Font Lock mode, by
419 setting up a buffer-local value for the variable
420 @code{font-lock-defaults} (@pxref{Font Lock Mode}).
423 Each face that the mode defines should, if possible, inherit from an
424 existing Emacs face. This reduces the chance of conflicting with a
425 user's face customizations. Useful faces include:
428 @item @code{highlight}
429 for stretches of text that should temporarily stand out.
432 for text matching a search command.
434 @item @code{link} and @code{link-visited}
435 for clickable text buttons that send the user to a different buffer or
439 for clickable text buttons that perform other actions.
441 @item @asis{Font Lock faces}
442 for other kinds of syntactic highlighting, if highlighting is not
443 handled by Font Lock mode or some Font Lock faces are not in use.
444 @xref{Faces for Font Lock}, for how to assign Font Lock faces.
448 The mode should specify how Imenu should find the definitions or
449 sections of a buffer, by setting up a buffer-local value for the
450 variable @code{imenu-generic-expression}, for the two variables
451 @code{imenu-prev-index-position-function} and
452 @code{imenu-extract-index-name-function}, or for the variable
453 @code{imenu-create-index-function} (@pxref{Imenu}).
456 The mode can specify a local value for
457 @code{eldoc-documentation-function} to tell ElDoc mode how to handle
461 The mode can specify how to complete various keywords by adding
462 to the special hook @code{completion-at-point-functions}.
465 Use @code{defvar} or @code{defcustom} to set mode-related variables, so
466 that they are not reinitialized if they already have a value. (Such
467 reinitialization could discard customizations made by the user.)
470 @cindex buffer-local variables in modes
471 To make a buffer-local binding for an Emacs customization variable, use
472 @code{make-local-variable} in the major mode command, not
473 @code{make-variable-buffer-local}. The latter function would make the
474 variable local to every buffer in which it is subsequently set, which
475 would affect buffers that do not use this mode. It is undesirable for a
476 mode to have such global effects. @xref{Buffer-Local Variables}.
478 With rare exceptions, the only reasonable way to use
479 @code{make-variable-buffer-local} in a Lisp package is for a variable
480 which is used only within that package. Using it on a variable used by
481 other packages would interfere with them.
485 @cindex major mode hook
486 Each major mode should have a normal @dfn{mode hook} named
487 @code{@var{modename}-mode-hook}. The very last thing the major mode command
488 should do is to call @code{run-mode-hooks}. This runs the mode hook,
489 and then runs the normal hook @code{after-change-major-mode-hook}.
493 The major mode command may start by calling some other major mode
494 command (called the @dfn{parent mode}) and then alter some of its
495 settings. A mode that does this is called a @dfn{derived mode}. The
496 recommended way to define one is to use the @code{define-derived-mode}
497 macro, but this is not required. Such a mode should call the parent
498 mode command inside a @code{delay-mode-hooks} form. (Using
499 @code{define-derived-mode} does this automatically.) @xref{Derived
500 Modes}, and @ref{Mode Hooks}.
503 If something special should be done if the user switches a buffer from
504 this mode to any other major mode, this mode can set up a buffer-local
505 value for @code{change-major-mode-hook} (@pxref{Creating Buffer-Local}).
508 If this mode is appropriate only for specially-prepared text, then the
509 major mode command symbol should have a property named @code{mode-class}
510 with value @code{special}, put on as follows:
512 @kindex mode-class @r{(property)}
513 @cindex @code{special}
515 (put 'funny-mode 'mode-class 'special)
519 This tells Emacs that new buffers created while the current buffer is
520 in Funny mode should not inherit Funny mode, in case the default value
521 of @code{major-mode} is @code{nil}. Modes such as Dired, Rmail,
522 and Buffer List use this feature.
524 The @code{define-derived-mode} macro automatically marks the derived
525 mode as special if the parent mode is special. The special mode
526 @code{special-mode} provides a convenient parent for other special
527 modes to inherit from; it sets @code{buffer-read-only} to @code{t},
528 and does little else.
531 If you want to make the new mode the default for files with certain
532 recognizable names, add an element to @code{auto-mode-alist} to select
533 the mode for those file names (@pxref{Auto Major Mode}). If you
534 define the mode command to autoload, you should add this element in
535 the same file that calls @code{autoload}. If you use an autoload
536 cookie for the mode command, you can also use an autoload cookie for
537 the form that adds the element (@pxref{autoload cookie}). If you do
538 not autoload the mode command, it is sufficient to add the element in
539 the file that contains the mode definition.
542 In the comments that document the file, you should provide a sample
543 @code{autoload} form and an example of how to add to
544 @code{auto-mode-alist}, that users can include in their init files
549 The top-level forms in the file defining the mode should be written so
550 that they may be evaluated more than once without adverse consequences.
551 Even if you never load the file more than once, someone else will.
554 @node Auto Major Mode
555 @subsection How Emacs Chooses a Major Mode
556 @cindex major mode, automatic selection
558 Based on information in the file name or in the file itself, Emacs
559 automatically selects a major mode for the new buffer when a file is
560 visited. It also processes local variables specified in the file text.
562 @deffn Command fundamental-mode
563 Fundamental mode is a major mode that is not specialized for anything
564 in particular. Other major modes are defined in effect by comparison
565 with this one---their definitions say what to change, starting from
566 Fundamental mode. The @code{fundamental-mode} function does @emph{not}
567 run any mode hooks; you're not supposed to customize it. (If you want Emacs
568 to behave differently in Fundamental mode, change the @emph{global}
572 @deffn Command normal-mode &optional find-file
573 This function establishes the proper major mode and buffer-local variable
574 bindings for the current buffer. First it calls @code{set-auto-mode}
575 (see below), then it runs @code{hack-local-variables} to parse, and
576 bind or evaluate as appropriate, the file's local variables
577 (@pxref{File Local Variables}).
579 If the @var{find-file} argument to @code{normal-mode} is non-@code{nil},
580 @code{normal-mode} assumes that the @code{find-file} function is calling
581 it. In this case, it may process local variables in the @samp{-*-}
582 line or at the end of the file. The variable
583 @code{enable-local-variables} controls whether to do so. @xref{File
584 Variables, , Local Variables in Files, emacs, The GNU Emacs Manual},
585 for the syntax of the local variables section of a file.
587 If you run @code{normal-mode} interactively, the argument
588 @var{find-file} is normally @code{nil}. In this case,
589 @code{normal-mode} unconditionally processes any file local variables.
591 The function calls @code{set-auto-mode} to choose a major mode. If this
592 does not specify a mode, the buffer stays in the major mode determined
593 by the default value of @code{major-mode} (see below).
595 @cindex file mode specification error
596 @code{normal-mode} uses @code{condition-case} around the call to the
597 major mode function, so errors are caught and reported as a @samp{File
598 mode specification error}, followed by the original error message.
601 @defun set-auto-mode &optional keep-mode-if-same
602 @cindex visited file mode
603 This function selects the major mode that is appropriate for the
604 current buffer. It bases its decision (in order of precedence) on
605 the @w{@samp{-*-}} line, on any @samp{mode:} local variable near the
606 end of a file, on the @w{@samp{#!}} line (using
607 @code{interpreter-mode-alist}), on the text at the beginning of the
608 buffer (using @code{magic-mode-alist}), and finally on the visited
609 file name (using @code{auto-mode-alist}). @xref{Choosing Modes, , How
610 Major Modes are Chosen, emacs, The GNU Emacs Manual}.
611 If @code{enable-local-variables} is @code{nil}, @code{set-auto-mode}
612 does not check the @w{@samp{-*-}} line, or near the end of the file,
615 If @var{keep-mode-if-same} is non-@code{nil}, this function does not
616 call the mode command if the buffer is already in the proper major
617 mode. For instance, @code{set-visited-file-name} sets this to
618 @code{t} to avoid killing buffer local variables that the user may
623 The buffer-local value of this variable holds the major mode
624 currently active. The default value of this variable holds the
625 default major mode for new buffers. The standard default value is
626 @code{fundamental-mode}.
628 If the default value of @code{major-mode} is @code{nil}, Emacs uses
629 the (previously) current buffer's major mode as the default major mode
630 of a new buffer. However, if that major mode symbol has a @code{mode-class}
631 property with value @code{special}, then it is not used for new buffers;
632 Fundamental mode is used instead. The modes that have this property are
633 those such as Dired and Rmail that are useful only with text that has
634 been specially prepared.
637 @defun set-buffer-major-mode buffer
638 This function sets the major mode of @var{buffer} to the default value of
639 @code{major-mode}; if that is @code{nil}, it uses the
640 current buffer's major mode (if that is suitable). As an exception,
641 if @var{buffer}'s name is @samp{*scratch*}, it sets the mode to
642 @code{initial-major-mode}.
644 The low-level primitives for creating buffers do not use this function,
645 but medium-level commands such as @code{switch-to-buffer} and
646 @code{find-file-noselect} use it whenever they create buffers.
649 @defopt initial-major-mode
650 @cindex @samp{*scratch*}
651 The value of this variable determines the major mode of the initial
652 @samp{*scratch*} buffer. The value should be a symbol that is a major
653 mode command. The default value is @code{lisp-interaction-mode}.
656 @defvar interpreter-mode-alist
657 This variable specifies major modes to use for scripts that specify a
658 command interpreter in a @samp{#!} line. Its value is an alist with
659 elements of the form @code{(@var{interpreter} . @var{mode})}; for
660 example, @code{("perl" . perl-mode)} is one element present by
661 default. The element says to use mode @var{mode} if the file
662 specifies an interpreter which matches @var{interpreter}.
665 @defvar magic-mode-alist
666 This variable's value is an alist with elements of the form
667 @code{(@var{regexp} . @var{function})}, where @var{regexp} is a
668 regular expression and @var{function} is a function or @code{nil}.
669 After visiting a file, @code{set-auto-mode} calls @var{function} if
670 the text at the beginning of the buffer matches @var{regexp} and
671 @var{function} is non-@code{nil}; if @var{function} is @code{nil},
672 @code{auto-mode-alist} gets to decide the mode.
675 @defvar magic-fallback-mode-alist
676 This works like @code{magic-mode-alist}, except that it is handled
677 only if @code{auto-mode-alist} does not specify a mode for this file.
680 @defvar auto-mode-alist
681 This variable contains an association list of file name patterns
682 (regular expressions) and corresponding major mode commands. Usually,
683 the file name patterns test for suffixes, such as @samp{.el} and
684 @samp{.c}, but this need not be the case. An ordinary element of the
685 alist looks like @code{(@var{regexp} . @var{mode-function})}.
691 (("\\`/tmp/fol/" . text-mode)
692 ("\\.texinfo\\'" . texinfo-mode)
693 ("\\.texi\\'" . texinfo-mode)
696 ("\\.el\\'" . emacs-lisp-mode)
703 When you visit a file whose expanded file name (@pxref{File Name
704 Expansion}), with version numbers and backup suffixes removed using
705 @code{file-name-sans-versions} (@pxref{File Name Components}), matches
706 a @var{regexp}, @code{set-auto-mode} calls the corresponding
707 @var{mode-function}. This feature enables Emacs to select the proper
708 major mode for most files.
710 If an element of @code{auto-mode-alist} has the form @code{(@var{regexp}
711 @var{function} t)}, then after calling @var{function}, Emacs searches
712 @code{auto-mode-alist} again for a match against the portion of the file
713 name that did not match before. This feature is useful for
714 uncompression packages: an entry of the form @code{("\\.gz\\'"
715 @var{function} t)} can uncompress the file and then put the uncompressed
716 file in the proper mode according to the name sans @samp{.gz}.
718 Here is an example of how to prepend several pattern pairs to
719 @code{auto-mode-alist}. (You might use this sort of expression in your
724 (setq auto-mode-alist
726 ;; @r{File name (within directory) starts with a dot.}
727 '(("/\\.[^/]*\\'" . fundamental-mode)
728 ;; @r{File name has no dot.}
729 ("/[^\\./]*\\'" . fundamental-mode)
730 ;; @r{File name ends in @samp{.C}.}
731 ("\\.C\\'" . c++-mode))
738 @subsection Getting Help about a Major Mode
740 @cindex help for major mode
741 @cindex documentation for major mode
743 The @code{describe-mode} function is used to provide information
744 about major modes. It is normally called with @kbd{C-h m}. The
745 @code{describe-mode} function uses the value of @code{major-mode},
746 which is why every major mode function needs to set the
747 @code{major-mode} variable.
749 @deffn Command describe-mode
750 This function displays the documentation of the current major mode.
752 The @code{describe-mode} function calls the @code{documentation}
753 function using the value of @code{major-mode} as an argument. Thus, it
754 displays the documentation string of the major mode function.
755 (@xref{Accessing Documentation}.)
759 This buffer-local variable holds the symbol for the current buffer's
760 major mode. This symbol should have a function definition that is the
761 command to switch to that major mode. The @code{describe-mode}
762 function uses the documentation string of the function as the
763 documentation of the major mode.
767 @subsection Defining Derived Modes
770 The recommended way to define a new major mode is to derive it
771 from an existing one using @code{define-derived-mode}. If there is no
772 closely related mode, you can inherit from @code{text-mode},
773 @code{special-mode}, @code{prog-mode}, or in the worst case
774 @code{fundamental-mode}.
776 @defmac define-derived-mode variant parent name docstring keyword-args@dots{} body@dots{}
777 This macro defines @var{variant} as a major mode command, using
778 @var{name} as the string form of the mode name. @var{variant} and
779 @var{parent} should be unquoted symbols.
781 The new command @var{variant} is defined to call the function
782 @var{parent}, then override certain aspects of that parent mode:
786 The new mode has its own sparse keymap, named
787 @code{@var{variant}-map}. @code{define-derived-mode}
788 makes the parent mode's keymap the parent of the new map, unless
789 @code{@var{variant}-map} is already set and already has a parent.
792 The new mode has its own syntax table, kept in the variable
793 @code{@var{variant}-syntax-table}, unless you override this using the
794 @code{:syntax-table} keyword (see below). @code{define-derived-mode}
795 makes the parent mode's syntax-table the parent of
796 @code{@var{variant}-syntax-table}, unless the latter is already set
797 and already has a parent different from the standard syntax table.
800 The new mode has its own abbrev table, kept in the variable
801 @code{@var{variant}-abbrev-table}, unless you override this using the
802 @code{:abbrev-table} keyword (see below).
805 The new mode has its own mode hook, @code{@var{variant}-hook}. It
806 runs this hook, after running the hooks of its ancestor modes, with
807 @code{run-mode-hooks}, as the last thing it does. @xref{Mode Hooks}.
810 In addition, you can specify how to override other aspects of
811 @var{parent} with @var{body}. The command @var{variant}
812 evaluates the forms in @var{body} after setting up all its usual
813 overrides, just before running the mode hooks.
815 If @var{parent} has a non-@code{nil} @code{mode-class} symbol
816 property, then @code{define-derived-mode} sets the @code{mode-class}
817 property of @var{variant} to the same value. This ensures, for
818 example, that if @var{parent} is a special mode, then @var{variant} is
819 also a special mode (@pxref{Major Mode Conventions}).
821 You can also specify @code{nil} for @var{parent}. This gives the new
822 mode no parent. Then @code{define-derived-mode} behaves as described
823 above, but, of course, omits all actions connected with @var{parent}.
825 The argument @var{docstring} specifies the documentation string for
826 the new mode. @code{define-derived-mode} adds some general
827 information about the mode's hook, followed by the mode's keymap, at
828 the end of this docstring. If you omit @var{docstring},
829 @code{define-derived-mode} generates a documentation string.
831 The @var{keyword-args} are pairs of keywords and values. The values
832 are evaluated. The following keywords are currently supported:
836 You can use this to explicitly specify a syntax table for the new
837 mode. If you specify a @code{nil} value, the new mode uses the same
838 syntax table as @var{parent}, or the standard syntax table if
839 @var{parent} is @code{nil}. (Note that this does @emph{not} follow
840 the convention used for non-keyword arguments that a @code{nil} value
841 is equivalent with not specifying the argument.)
844 You can use this to explicitly specify an abbrev table for the new
845 mode. If you specify a @code{nil} value, the new mode uses the same
846 abbrev table as @var{parent}, or @code{fundamental-mode-abbrev-table}
847 if @var{parent} is @code{nil}. (Again, a @code{nil} value is
848 @emph{not} equivalent to not specifying this keyword.)
851 If this is specified, the value should be the customization group for
852 this mode. (Not all major modes have one.) Only the (still
853 experimental and unadvertised) command @code{customize-mode} currently
854 uses this. @code{define-derived-mode} does @emph{not} automatically
855 define the specified customization group.
858 Here is a hypothetical example:
861 (define-derived-mode hypertext-mode
862 text-mode "Hypertext"
863 "Major mode for hypertext.
864 \\@{hypertext-mode-map@}"
865 (setq case-fold-search nil))
867 (define-key hypertext-mode-map
868 [down-mouse-3] 'do-hyper-link)
871 Do not write an @code{interactive} spec in the definition;
872 @code{define-derived-mode} does that automatically.
876 @subsection Generic Modes
879 @dfn{Generic modes} are simple major modes with basic support for
880 comment syntax and Font Lock mode. To define a generic mode, use the
881 macro @code{define-generic-mode}. See the file @file{generic-x.el}
882 for some examples of the use of @code{define-generic-mode}.
884 @defmac define-generic-mode mode comment-list keyword-list font-lock-list auto-mode-list function-list &optional docstring
885 This macro defines a generic mode command named @var{mode} (a symbol,
886 not quoted). The optional argument @var{docstring} is the
887 documentation for the mode command. If you do not supply it,
888 @code{define-generic-mode} generates one by default.
890 The argument @var{comment-list} is a list in which each element is
891 either a character, a string of one or two characters, or a cons cell.
892 A character or a string is set up in the mode's syntax table as a
893 ``comment starter.'' If the entry is a cons cell, the @sc{car} is set
894 up as a ``comment starter'' and the @sc{cdr} as a ``comment ender.''
895 (Use @code{nil} for the latter if you want comments to end at the end
896 of the line.) Note that the syntax table mechanism has limitations
897 about what comment starters and enders are actually possible.
898 @xref{Syntax Tables}.
900 The argument @var{keyword-list} is a list of keywords to highlight
901 with @code{font-lock-keyword-face}. Each keyword should be a string.
902 Meanwhile, @var{font-lock-list} is a list of additional expressions to
903 highlight. Each element of this list should have the same form as an
904 element of @code{font-lock-keywords}. @xref{Search-based
907 The argument @var{auto-mode-list} is a list of regular expressions to
908 add to the variable @code{auto-mode-alist}. They are added by the execution
909 of the @code{define-generic-mode} form, not by expanding the macro call.
911 Finally, @var{function-list} is a list of functions for the mode
912 command to call for additional setup. It calls these functions just
913 before it runs the mode hook variable @code{@var{mode}-hook}.
917 @subsection Mode Hooks
919 Every major mode function should finish by running its mode hook and
920 the mode-independent normal hook @code{after-change-major-mode-hook}.
921 It does this by calling @code{run-mode-hooks}. If the major mode is a
922 derived mode, that is if it calls another major mode (the parent mode)
923 in its body, it should do this inside @code{delay-mode-hooks} so that
924 the parent won't run these hooks itself. Instead, the derived mode's
925 call to @code{run-mode-hooks} runs the parent's mode hook too.
926 @xref{Major Mode Conventions}.
928 Emacs versions before Emacs 22 did not have @code{delay-mode-hooks}.
929 When user-implemented major modes have not been updated to use it,
930 they won't entirely follow these conventions: they may run the
931 parent's mode hook too early, or fail to run
932 @code{after-change-major-mode-hook}. If you encounter such a major
933 mode, please correct it to follow these conventions.
935 When you defined a major mode using @code{define-derived-mode}, it
936 automatically makes sure these conventions are followed. If you
937 define a major mode ``by hand,'' not using @code{define-derived-mode},
938 use the following functions to handle these conventions automatically.
940 @defun run-mode-hooks &rest hookvars
941 Major modes should run their mode hook using this function. It is
942 similar to @code{run-hooks} (@pxref{Hooks}), but it also runs
943 @code{after-change-major-mode-hook}.
945 When this function is called during the execution of a
946 @code{delay-mode-hooks} form, it does not run the hooks immediately.
947 Instead, it arranges for the next call to @code{run-mode-hooks} to run
951 @defmac delay-mode-hooks body@dots{}
952 When one major mode command calls another, it should do so inside of
953 @code{delay-mode-hooks}.
955 This macro executes @var{body}, but tells all @code{run-mode-hooks}
956 calls during the execution of @var{body} to delay running their hooks.
957 The hooks will actually run during the next call to
958 @code{run-mode-hooks} after the end of the @code{delay-mode-hooks}
962 @defvar after-change-major-mode-hook
963 This is a normal hook run by @code{run-mode-hooks}. It is run at the
964 very end of every properly-written major mode function.
967 @node Example Major Modes
968 @subsection Major Mode Examples
970 Text mode is perhaps the simplest mode besides Fundamental mode.
971 Here are excerpts from @file{text-mode.el} that illustrate many of
972 the conventions listed above:
976 ;; @r{Create the syntax table for this mode.}
977 (defvar text-mode-syntax-table
978 (let ((st (make-syntax-table)))
979 (modify-syntax-entry ?\" ". " st)
980 (modify-syntax-entry ?\\ ". " st)
981 ;; Add `p' so M-c on `hello' leads to `Hello', not `hello'.
982 (modify-syntax-entry ?' "w p" st)
984 "Syntax table used while in `text-mode'.")
987 ;; @r{Create the keymap for this mode.}
989 (defvar text-mode-map
990 (let ((map (make-sparse-keymap)))
991 (define-key map "\e\t" 'ispell-complete-word)
992 (define-key map "\es" 'center-line)
993 (define-key map "\eS" 'center-paragraph)
995 "Keymap for `text-mode'.
996 Many other modes, such as Mail mode, Outline mode
997 and Indented Text mode, inherit all the commands
998 defined in this map.")
1002 Here is how the actual mode command is defined now:
1006 (define-derived-mode text-mode nil "Text"
1007 "Major mode for editing text written for humans to read.
1008 In this mode, paragraphs are delimited only by blank or white lines.
1009 You can thus get the full benefit of adaptive filling
1010 (see the variable `adaptive-fill-mode').
1012 Turning on Text mode runs the normal hook `text-mode-hook'."
1015 (set (make-local-variable 'text-mode-variant) t)
1016 ;; @r{These two lines are a feature added recently.}
1017 (set (make-local-variable 'require-final-newline)
1018 mode-require-final-newline)
1019 (set (make-local-variable 'indent-line-function) 'indent-relative))
1024 (The last line is redundant nowadays, since @code{indent-relative} is
1025 the default value, and we'll delete it in a future version.)
1027 Here is how it was defined formerly, before
1028 @code{define-derived-mode} existed:
1032 ;; @r{This isn't needed nowadays, since @code{define-derived-mode} does it.}
1033 (define-abbrev-table 'text-mode-abbrev-table ()
1034 "Abbrev table used while in text mode.")
1039 "Major mode for editing text intended for humans to read...
1040 Special commands: \\@{text-mode-map@}
1043 Turning on text-mode runs the hook `text-mode-hook'."
1045 (kill-all-local-variables)
1046 (use-local-map text-mode-map)
1049 (setq local-abbrev-table text-mode-abbrev-table)
1050 (set-syntax-table text-mode-syntax-table)
1053 ;; @r{These four lines are absent from the current version}
1054 ;; @r{not because this is done some other way, but because}
1055 ;; @r{nowadays Text mode uses the normal definition of paragraphs.}
1056 (set (make-local-variable 'paragraph-start)
1057 (concat "[ \t]*$\\|" page-delimiter))
1058 (set (make-local-variable 'paragraph-separate) paragraph-start)
1059 (set (make-local-variable 'indent-line-function) 'indent-relative-maybe)
1062 (setq mode-name "Text")
1063 (setq major-mode 'text-mode)
1064 (run-mode-hooks 'text-mode-hook)) ; @r{Finally, this permits the user to}
1065 ; @r{customize the mode with a hook.}
1069 @cindex @file{lisp-mode.el}
1070 The three Lisp modes (Lisp mode, Emacs Lisp mode, and Lisp
1071 Interaction mode) have more features than Text mode and the code is
1072 correspondingly more complicated. Here are excerpts from
1073 @file{lisp-mode.el} that illustrate how these modes are written.
1075 @cindex syntax table example
1078 ;; @r{Create mode-specific table variables.}
1079 (defvar lisp-mode-syntax-table nil "")
1080 (defvar lisp-mode-abbrev-table nil "")
1084 (defvar emacs-lisp-mode-syntax-table
1085 (let ((table (make-syntax-table)))
1090 ;; @r{Set syntax of chars up to @samp{0} to say they are}
1091 ;; @r{part of symbol names but not words.}
1092 ;; @r{(The digit @samp{0} is @code{48} in the @acronym{ASCII} character set.)}
1094 (modify-syntax-entry i "_ " table)
1096 ;; @r{@dots{} similar code follows for other character ranges.}
1099 ;; @r{Then set the syntax codes for characters that are special in Lisp.}
1100 (modify-syntax-entry ? " " table)
1101 (modify-syntax-entry ?\t " " table)
1102 (modify-syntax-entry ?\f " " table)
1103 (modify-syntax-entry ?\n "> " table)
1106 ;; @r{Give CR the same syntax as newline, for selective-display.}
1107 (modify-syntax-entry ?\^m "> " table)
1108 (modify-syntax-entry ?\; "< " table)
1109 (modify-syntax-entry ?` "' " table)
1110 (modify-syntax-entry ?' "' " table)
1111 (modify-syntax-entry ?, "' " table)
1114 ;; @r{@dots{}likewise for many other characters@dots{}}
1115 (modify-syntax-entry ?\( "() " table)
1116 (modify-syntax-entry ?\) ")( " table)
1117 (modify-syntax-entry ?\[ "(] " table)
1118 (modify-syntax-entry ?\] ")[ " table))
1122 ;; @r{Create an abbrev table for lisp-mode.}
1123 (define-abbrev-table 'lisp-mode-abbrev-table ())
1127 The three modes for Lisp share much of their code. For instance,
1128 each calls the following function to set various variables:
1132 (defun lisp-mode-variables (lisp-syntax)
1134 (set-syntax-table lisp-mode-syntax-table))
1135 (setq local-abbrev-table lisp-mode-abbrev-table)
1140 In Lisp and most programming languages, we want the paragraph
1141 commands to treat only blank lines as paragraph separators. And the
1142 modes should understand the Lisp conventions for comments. The rest of
1143 @code{lisp-mode-variables} sets this up:
1147 (set (make-local-variable 'paragraph-start)
1148 (concat page-delimiter "\\|$" ))
1149 (set (make-local-variable 'paragraph-separate)
1154 (set (make-local-variable 'comment-indent-function)
1155 'lisp-comment-indent))
1160 Each of the different Lisp modes has a slightly different keymap. For
1161 example, Lisp mode binds @kbd{C-c C-z} to @code{run-lisp}, but the other
1162 Lisp modes do not. However, all Lisp modes have some commands in
1163 common. The following code sets up the common commands:
1167 (defvar shared-lisp-mode-map
1168 (let ((map (make-sparse-keymap)))
1169 (define-key shared-lisp-mode-map "\e\C-q" 'indent-sexp)
1170 (define-key shared-lisp-mode-map "\177"
1171 'backward-delete-char-untabify)
1173 "Keymap for commands shared by all sorts of Lisp modes.")
1178 And here is the code to set up the keymap for Lisp mode:
1182 (defvar lisp-mode-map
1183 (let ((map (make-sparse-keymap)))
1184 (set-keymap-parent map shared-lisp-mode-map)
1185 (define-key map "\e\C-x" 'lisp-eval-defun)
1186 (define-key map "\C-c\C-z" 'run-lisp)
1188 "Keymap for ordinary Lisp mode...")
1192 Finally, here is the complete major mode function definition for
1198 "Major mode for editing Lisp code for Lisps other than GNU Emacs Lisp.
1200 Delete converts tabs to spaces as it moves back.
1201 Blank lines separate paragraphs. Semicolons start comments.
1203 Note that `run-lisp' may be used either to start an inferior Lisp job
1204 or to switch back to an existing one.
1208 Entry to this mode calls the value of `lisp-mode-hook'
1209 if that value is non-nil."
1211 (kill-all-local-variables)
1214 (use-local-map lisp-mode-map) ; @r{Select the mode's keymap.}
1215 (setq major-mode 'lisp-mode) ; @r{This is how @code{describe-mode}}
1216 ; @r{finds out what to describe.}
1217 (setq mode-name "Lisp") ; @r{This goes into the mode line.}
1218 (lisp-mode-variables t) ; @r{This defines various variables.}
1219 (set (make-local-variable 'comment-start-skip)
1220 "\\(\\(^\\|[^\\\\\n]\\)\\(\\\\\\\\\\)*\\)\\(;+\\|#|\\) *")
1221 (set (make-local-variable 'font-lock-keywords-case-fold-search) t)
1224 (setq imenu-case-fold-search t)
1225 (set-syntax-table lisp-mode-syntax-table)
1226 (run-mode-hooks 'lisp-mode-hook)) ; @r{This permits the user to use a}
1227 ; @r{hook to customize the mode.}
1232 @section Minor Modes
1235 A @dfn{minor mode} provides features that users may enable or disable
1236 independently of the choice of major mode. Minor modes can be enabled
1237 individually or in combination. Minor modes would be better named
1238 ``generally available, optional feature modes,'' except that such a name
1241 A minor mode is not usually meant as a variation of a single major mode.
1242 Usually they are general and can apply to many major modes. For
1243 example, Auto Fill mode works with any major mode that permits text
1244 insertion. To be general, a minor mode must be effectively independent
1245 of the things major modes do.
1247 A minor mode is often much more difficult to implement than a major
1248 mode. One reason is that you should be able to activate and deactivate
1249 minor modes in any order. A minor mode should be able to have its
1250 desired effect regardless of the major mode and regardless of the other
1251 minor modes in effect.
1253 Often the biggest problem in implementing a minor mode is finding a
1254 way to insert the necessary hook into the rest of Emacs. Minor mode
1255 keymaps make this easier than it used to be.
1257 @defvar minor-mode-list
1258 The value of this variable is a list of all minor mode commands.
1262 * Minor Mode Conventions:: Tips for writing a minor mode.
1263 * Keymaps and Minor Modes:: How a minor mode can have its own keymap.
1264 * Defining Minor Modes:: A convenient facility for defining minor modes.
1267 @node Minor Mode Conventions
1268 @subsection Conventions for Writing Minor Modes
1269 @cindex minor mode conventions
1270 @cindex conventions for writing minor modes
1272 There are conventions for writing minor modes just as there are for
1273 major modes. Several of the major mode conventions apply to minor
1274 modes as well: those regarding the name of the mode initialization
1275 function, the names of global symbols, the use of a hook at the end of
1276 the initialization function, and the use of keymaps and other tables.
1278 In addition, there are several conventions that are specific to
1279 minor modes. (The easiest way to follow all the conventions is to use
1280 the macro @code{define-minor-mode}; @ref{Defining Minor Modes}.)
1284 @cindex mode variable
1285 Make a variable whose name ends in @samp{-mode} to control the minor
1286 mode. We call this the @dfn{mode variable}. The minor mode command
1287 should set this variable (@code{nil} to disable; anything else to
1290 If possible, implement the mode so that setting the variable
1291 automatically enables or disables the mode. Then the minor mode command
1292 does not need to do anything except set the variable.
1294 This variable is used in conjunction with the @code{minor-mode-alist} to
1295 display the minor mode name in the mode line. It can also enable
1296 or disable a minor mode keymap. Individual commands or hooks can also
1297 check the variable's value.
1299 If you want the minor mode to be enabled separately in each buffer,
1300 make the variable buffer-local.
1303 Define a command whose name is the same as the mode variable.
1304 Its job is to enable and disable the mode by setting the variable.
1306 The command should accept one optional argument. If the argument is
1307 @code{nil}, it should toggle the mode (turn it on if it is off, and
1308 off if it is on). It should turn the mode on if the argument is a
1309 positive integer, the symbol @code{t}, or a list whose @sc{car} is one
1310 of those. It should turn the mode off if the argument is a negative
1311 integer or zero, the symbol @code{-}, or a list whose @sc{car} is a
1312 negative integer or zero. The meaning of other arguments is not
1315 Here is an example taken from the definition of @code{transient-mark-mode}.
1316 It shows the use of @code{transient-mark-mode} as a variable that enables or
1317 disables the mode's behavior, and also shows the proper way to toggle,
1318 enable or disable the minor mode based on the raw prefix argument value.
1322 (setq transient-mark-mode
1323 (if (null arg) (not transient-mark-mode)
1324 (> (prefix-numeric-value arg) 0)))
1329 Add an element to @code{minor-mode-alist} for each minor mode
1330 (@pxref{Definition of minor-mode-alist}), if you want to indicate the
1331 minor mode in the mode line. This element should be a list of the
1335 (@var{mode-variable} @var{string})
1338 Here @var{mode-variable} is the variable that controls enabling of the
1339 minor mode, and @var{string} is a short string, starting with a space,
1340 to represent the mode in the mode line. These strings must be short so
1341 that there is room for several of them at once.
1343 When you add an element to @code{minor-mode-alist}, use @code{assq} to
1344 check for an existing element, to avoid duplication. For example:
1348 (unless (assq 'leif-mode minor-mode-alist)
1349 (setq minor-mode-alist
1350 (cons '(leif-mode " Leif") minor-mode-alist)))
1355 or like this, using @code{add-to-list} (@pxref{List Variables}):
1359 (add-to-list 'minor-mode-alist '(leif-mode " Leif"))
1364 Global minor modes distributed with Emacs should if possible support
1365 enabling and disabling via Custom (@pxref{Customization}). To do this,
1366 the first step is to define the mode variable with @code{defcustom}, and
1367 specify @code{:type 'boolean}.
1369 If just setting the variable is not sufficient to enable the mode, you
1370 should also specify a @code{:set} method which enables the mode by
1371 invoking the mode command. Note in the variable's documentation string that
1372 setting the variable other than via Custom may not take effect.
1374 Also mark the definition with an autoload cookie (@pxref{autoload cookie}),
1375 and specify a @code{:require} so that customizing the variable will load
1376 the library that defines the mode. This will copy suitable definitions
1377 into @file{loaddefs.el} so that users can use @code{customize-option} to
1378 enable the mode. For example:
1384 (defcustom msb-mode nil
1386 Setting this variable directly does not take effect;
1387 use either \\[customize] or the function `msb-mode'."
1388 :set 'custom-set-minor-mode
1389 :initialize 'custom-initialize-default
1397 @node Keymaps and Minor Modes
1398 @subsection Keymaps and Minor Modes
1400 Each minor mode can have its own keymap, which is active when the mode
1401 is enabled. To set up a keymap for a minor mode, add an element to the
1402 alist @code{minor-mode-map-alist}. @xref{Definition of minor-mode-map-alist}.
1404 @cindex @code{self-insert-command}, minor modes
1405 One use of minor mode keymaps is to modify the behavior of certain
1406 self-inserting characters so that they do something else as well as
1407 self-insert. In general, this is the only way to do that, since the
1408 facilities for customizing @code{self-insert-command} are limited to
1409 special cases (designed for abbrevs and Auto Fill mode). (Do not try
1410 substituting your own definition of @code{self-insert-command} for the
1411 standard one. The editor command loop handles this function specially.)
1413 The key sequences bound in a minor mode should consist of @kbd{C-c}
1414 followed by one of @kbd{.,/?`'"[]\|~!#$%^&*()-_+=}. (The other
1415 punctuation characters are reserved for major modes.)
1417 @node Defining Minor Modes
1418 @subsection Defining Minor Modes
1420 The macro @code{define-minor-mode} offers a convenient way of
1421 implementing a mode in one self-contained definition.
1423 @defmac define-minor-mode mode doc [init-value [lighter [keymap]]] keyword-args@dots{} body@dots{}
1424 This macro defines a new minor mode whose name is @var{mode} (a
1425 symbol). It defines a command named @var{mode} to toggle the minor
1426 mode, with @var{doc} as its documentation string. It also defines a
1427 variable named @var{mode}, which is set to @code{t} or @code{nil} by
1428 enabling or disabling the mode. The variable is initialized to
1429 @var{init-value}. Except in unusual circumstances (see below), this
1430 value must be @code{nil}.
1432 The string @var{lighter} says what to display in the mode line
1433 when the mode is enabled; if it is @code{nil}, the mode is not displayed
1436 The optional argument @var{keymap} specifies the keymap for the minor
1437 mode. If non-@code{nil}, it should be a variable name (whose value is
1438 a keymap), a keymap, or an alist of the form
1441 (@var{key-sequence} . @var{definition})
1445 where each @var{key-sequence} and @var{definition} are arguments
1446 suitable for passing to @code{define-key} (@pxref{Changing Key
1447 Bindings}). If @var{keymap} is a keymap or an alist, this also
1448 defines the variable @code{@var{mode}-map}.
1450 The above three arguments @var{init-value}, @var{lighter}, and
1451 @var{keymap} can be (partially) omitted when @var{keyword-args} are
1452 used. The @var{keyword-args} consist of keywords followed by
1453 corresponding values. A few keywords have special meanings:
1456 @item :group @var{group}
1457 Custom group name to use in all generated @code{defcustom} forms.
1458 Defaults to @var{mode} without the possible trailing @samp{-mode}.
1459 @strong{Warning:} don't use this default group name unless you have
1460 written a @code{defgroup} to define that group properly. @xref{Group
1463 @item :global @var{global}
1464 If non-@code{nil}, this specifies that the minor mode should be global
1465 rather than buffer-local. It defaults to @code{nil}.
1467 One of the effects of making a minor mode global is that the
1468 @var{mode} variable becomes a customization variable. Toggling it
1469 through the Custom interface turns the mode on and off, and its value
1470 can be saved for future Emacs sessions (@pxref{Saving
1471 Customizations,,, emacs, The GNU Emacs Manual}. For the saved
1472 variable to work, you should ensure that the @code{define-minor-mode}
1473 form is evaluated each time Emacs starts; for packages that are not
1474 part of Emacs, the easiest way to do this is to specify a
1475 @code{:require} keyword.
1477 @item :init-value @var{init-value}
1478 This is equivalent to specifying @var{init-value} positionally.
1480 @item :lighter @var{lighter}
1481 This is equivalent to specifying @var{lighter} positionally.
1483 @item :keymap @var{keymap}
1484 This is equivalent to specifying @var{keymap} positionally.
1487 Any other keyword arguments are passed directly to the
1488 @code{defcustom} generated for the variable @var{mode}.
1490 The command named @var{mode} first performs the standard actions such
1491 as setting the variable named @var{mode} and then executes the
1492 @var{body} forms, if any. It finishes by running the mode hook
1493 variable @code{@var{mode}-hook}.
1496 The initial value must be @code{nil} except in cases where (1) the
1497 mode is preloaded in Emacs, or (2) it is painless for loading to
1498 enable the mode even though the user did not request it. For
1499 instance, if the mode has no effect unless something else is enabled,
1500 and will always be loaded by that time, enabling it by default is
1501 harmless. But these are unusual circumstances. Normally, the
1502 initial value must be @code{nil}.
1504 @findex easy-mmode-define-minor-mode
1505 The name @code{easy-mmode-define-minor-mode} is an alias
1508 Here is an example of using @code{define-minor-mode}:
1511 (define-minor-mode hungry-mode
1512 "Toggle Hungry mode.
1513 With no argument, this command toggles the mode.
1514 Non-null prefix argument turns on the mode.
1515 Null prefix argument turns off the mode.
1517 When Hungry mode is enabled, the control delete key
1518 gobbles all preceding whitespace except the last.
1519 See the command \\[hungry-electric-delete]."
1520 ;; The initial value.
1522 ;; The indicator for the mode line.
1524 ;; The minor mode bindings.
1525 '(([C-backspace] . hungry-electric-delete))
1530 This defines a minor mode named ``Hungry mode,'' a command named
1531 @code{hungry-mode} to toggle it, a variable named @code{hungry-mode}
1532 which indicates whether the mode is enabled, and a variable named
1533 @code{hungry-mode-map} which holds the keymap that is active when the
1534 mode is enabled. It initializes the keymap with a key binding for
1535 @kbd{C-@key{DEL}}. It puts the variable @code{hungry-mode} into
1536 custom group @code{hunger}. There are no @var{body} forms---many
1537 minor modes don't need any.
1539 Here's an equivalent way to write it:
1542 (define-minor-mode hungry-mode
1543 "Toggle Hungry mode.
1544 With no argument, this command toggles the mode.
1545 Non-null prefix argument turns on the mode.
1546 Null prefix argument turns off the mode.
1548 When Hungry mode is enabled, the control delete key
1549 gobbles all preceding whitespace except the last.
1550 See the command \\[hungry-electric-delete]."
1551 ;; The initial value.
1553 ;; The indicator for the mode line.
1555 ;; The minor mode bindings.
1557 '(([C-backspace] . hungry-electric-delete)
1561 (hungry-electric-delete t))))
1565 @defmac define-globalized-minor-mode global-mode mode turn-on keyword-args@dots{}
1566 This defines a global toggle named @var{global-mode} whose meaning is
1567 to enable or disable the buffer-local minor mode @var{mode} in all
1568 buffers. To turn on the minor mode in a buffer, it uses the function
1569 @var{turn-on}; to turn off the minor mode, it calls @code{mode} with
1570 @minus{}1 as argument.
1572 Globally enabling the mode also affects buffers subsequently created
1573 by visiting files, and buffers that use a major mode other than
1574 Fundamental mode; but it does not detect the creation of a new buffer
1575 in Fundamental mode.
1577 This defines the customization option @var{global-mode} (@pxref{Customization}),
1578 which can be toggled in the Custom interface to turn the minor mode on
1579 and off. As with @code{define-minor-mode}, you should ensure that the
1580 @code{define-globalized-minor-mode} form is evaluated each time Emacs
1581 starts, for example by providing a @code{:require} keyword.
1583 Use @code{:group @var{group}} in @var{keyword-args} to specify the
1584 custom group for the mode variable of the global minor mode.
1587 @node Mode Line Format
1588 @section Mode-Line Format
1591 Each Emacs window (aside from minibuffer windows) typically has a mode
1592 line at the bottom, which displays status information about the buffer
1593 displayed in the window. The mode line contains information about the
1594 buffer, such as its name, associated file, depth of recursive editing,
1595 and major and minor modes. A window can also have a @dfn{header
1596 line}, which is much like the mode line but appears at the top of the
1599 This section describes how to control the contents of the mode line
1600 and header line. We include it in this chapter because much of the
1601 information displayed in the mode line relates to the enabled major and
1605 * Base: Mode Line Basics. Basic ideas of mode line control.
1606 * Data: Mode Line Data. The data structure that controls the mode line.
1607 * Top: Mode Line Top. The top level variable, mode-line-format.
1608 * Mode Line Variables:: Variables used in that data structure.
1609 * %-Constructs:: Putting information into a mode line.
1610 * Properties in Mode:: Using text properties in the mode line.
1611 * Header Lines:: Like a mode line, but at the top.
1612 * Emulating Mode Line:: Formatting text as the mode line would.
1615 @node Mode Line Basics
1616 @subsection Mode Line Basics
1618 @code{mode-line-format} is a buffer-local variable that holds a
1619 @dfn{mode line construct}, a kind of template, which controls what is
1620 displayed on the mode line of the current buffer. The value of
1621 @code{header-line-format} specifies the buffer's header line in the
1622 same way. All windows for the same buffer use the same
1623 @code{mode-line-format} and @code{header-line-format}.
1625 For efficiency, Emacs does not continuously recompute the mode
1626 line and header line of a window. It does so when circumstances
1627 appear to call for it---for instance, if you change the window
1628 configuration, switch buffers, narrow or widen the buffer, scroll, or
1629 change the buffer's modification status. If you modify any of the
1630 variables referenced by @code{mode-line-format} (@pxref{Mode Line
1631 Variables}), or any other variables and data structures that affect
1632 how text is displayed (@pxref{Display}), you may want to force an
1633 update of the mode line so as to display the new information or
1634 display it in the new way.
1636 @defun force-mode-line-update &optional all
1637 Force redisplay of the current buffer's mode line and header line.
1638 The next redisplay will update the mode line and header line based on
1639 the latest values of all relevant variables. With optional
1640 non-@code{nil} @var{all}, force redisplay of all mode lines and header
1643 This function also forces recomputation of the menu bar menus
1644 and the frame title.
1647 The selected window's mode line is usually displayed in a different
1648 color using the face @code{mode-line}. Other windows' mode lines
1649 appear in the face @code{mode-line-inactive} instead. @xref{Faces}.
1651 @node Mode Line Data
1652 @subsection The Data Structure of the Mode Line
1653 @cindex mode-line construct
1655 The mode-line contents are controlled by a data structure called a
1656 @dfn{mode-line construct}, made up of lists, strings, symbols, and
1657 numbers kept in buffer-local variables. Each data type has a specific
1658 meaning for the mode-line appearance, as described below. The same
1659 data structure is used for constructing frame titles (@pxref{Frame
1660 Titles}) and header lines (@pxref{Header Lines}).
1662 A mode-line construct may be as simple as a fixed string of text,
1663 but it usually specifies how to combine fixed strings with variables'
1664 values to construct the text. Many of these variables are themselves
1665 defined to have mode-line constructs as their values.
1667 Here are the meanings of various data types as mode-line constructs:
1670 @cindex percent symbol in mode line
1672 A string as a mode-line construct appears verbatim except for
1673 @dfn{@code{%}-constructs} in it. These stand for substitution of
1674 other data; see @ref{%-Constructs}.
1676 If parts of the string have @code{face} properties, they control
1677 display of the text just as they would text in the buffer. Any
1678 characters which have no @code{face} properties are displayed, by
1679 default, in the face @code{mode-line} or @code{mode-line-inactive}
1680 (@pxref{Standard Faces,,, emacs, The GNU Emacs Manual}). The
1681 @code{help-echo} and @code{local-map} properties in @var{string} have
1682 special meanings. @xref{Properties in Mode}.
1685 A symbol as a mode-line construct stands for its value. The value of
1686 @var{symbol} is used as a mode-line construct, in place of @var{symbol}.
1687 However, the symbols @code{t} and @code{nil} are ignored, as is any
1688 symbol whose value is void.
1690 There is one exception: if the value of @var{symbol} is a string, it is
1691 displayed verbatim: the @code{%}-constructs are not recognized.
1693 Unless @var{symbol} is marked as ``risky'' (i.e., it has a
1694 non-@code{nil} @code{risky-local-variable} property), all text
1695 properties specified in @var{symbol}'s value are ignored. This
1696 includes the text properties of strings in @var{symbol}'s value, as
1697 well as all @code{:eval} and @code{:propertize} forms in it. (The
1698 reason for this is security: non-risky variables could be set
1699 automatically from file variables without prompting the user.)
1701 @item (@var{string} @var{rest}@dots{})
1702 @itemx (@var{list} @var{rest}@dots{})
1703 A list whose first element is a string or list means to process all the
1704 elements recursively and concatenate the results. This is the most
1705 common form of mode-line construct.
1707 @item (:eval @var{form})
1708 A list whose first element is the symbol @code{:eval} says to evaluate
1709 @var{form}, and use the result as a string to display. Make sure this
1710 evaluation cannot load any files, as doing so could cause infinite
1713 @item (:propertize @var{elt} @var{props}@dots{})
1714 A list whose first element is the symbol @code{:propertize} says to
1715 process the mode-line construct @var{elt} recursively, then add the text
1716 properties specified by @var{props} to the result. The argument
1717 @var{props} should consist of zero or more pairs @var{text-property}
1718 @var{value}. (This feature is new as of Emacs 22.1.)
1720 @item (@var{symbol} @var{then} @var{else})
1721 A list whose first element is a symbol that is not a keyword specifies
1722 a conditional. Its meaning depends on the value of @var{symbol}. If
1723 @var{symbol} has a non-@code{nil} value, the second element,
1724 @var{then}, is processed recursively as a mode-line element.
1725 Otherwise, the third element, @var{else}, is processed recursively.
1726 You may omit @var{else}; then the mode-line element displays nothing
1727 if the value of @var{symbol} is @code{nil} or void.
1729 @item (@var{width} @var{rest}@dots{})
1730 A list whose first element is an integer specifies truncation or
1731 padding of the results of @var{rest}. The remaining elements
1732 @var{rest} are processed recursively as mode-line constructs and
1733 concatenated together. When @var{width} is positive, the result is
1734 space filled on the right if its width is less than @var{width}. When
1735 @var{width} is negative, the result is truncated on the right to
1736 @minus{}@var{width} columns if its width exceeds @minus{}@var{width}.
1738 For example, the usual way to show what percentage of a buffer is above
1739 the top of the window is to use a list like this: @code{(-3 "%p")}.
1743 @subsection The Top Level of Mode Line Control
1745 The variable in overall control of the mode line is
1746 @code{mode-line-format}.
1748 @defopt mode-line-format
1749 The value of this variable is a mode-line construct that controls the
1750 contents of the mode-line. It is always buffer-local in all buffers.
1752 If you set this variable to @code{nil} in a buffer, that buffer does
1753 not have a mode line. (A window that is just one line tall never
1754 displays a mode line.)
1757 The default value of @code{mode-line-format} is designed to use the
1758 values of other variables such as @code{mode-line-position} and
1759 @code{mode-line-modes} (which in turn incorporates the values of the
1760 variables @code{mode-name} and @code{minor-mode-alist}). Very few
1761 modes need to alter @code{mode-line-format} itself. For most
1762 purposes, it is sufficient to alter some of the variables that
1763 @code{mode-line-format} either directly or indirectly refers to.
1765 If you do alter @code{mode-line-format} itself, the new value should
1766 use the same variables that appear in the default value (@pxref{Mode
1767 Line Variables}), rather than duplicating their contents or displaying
1768 the information in another fashion. This way, customizations made by
1769 the user or by Lisp programs (such as @code{display-time} and major
1770 modes) via changes to those variables remain effective.
1772 Here is an example of a @code{mode-line-format} that might be
1773 useful for @code{shell-mode}, since it contains the host name and default
1778 (setq mode-line-format
1780 'mode-line-mule-info
1782 'mode-line-frame-identification
1786 ;; @r{Note that this is evaluated while making the list.}
1787 ;; @r{It makes a mode-line construct which is just a string.}
1795 '(:eval (mode-line-mode-name))
1801 '(which-func-mode ("" which-func-format "--"))
1802 '(line-number-mode "L%l--")
1803 '(column-number-mode "C%c--")
1810 (The variables @code{line-number-mode}, @code{column-number-mode}
1811 and @code{which-func-mode} enable particular minor modes; as usual,
1812 these variable names are also the minor mode command names.)
1814 @node Mode Line Variables
1815 @subsection Variables Used in the Mode Line
1817 This section describes variables incorporated by the standard value
1818 of @code{mode-line-format} into the text of the mode line. There is
1819 nothing inherently special about these variables; any other variables
1820 could have the same effects on the mode line if
1821 @code{mode-line-format}'s value were changed to use them. However,
1822 various parts of Emacs set these variables on the understanding that
1823 they will control parts of the mode line; therefore, practically
1824 speaking, it is essential for the mode line to use them.
1826 @defvar mode-line-mule-info
1827 This variable holds the value of the mode-line construct that displays
1828 information about the language environment, buffer coding system, and
1829 current input method. @xref{Non-ASCII Characters}.
1832 @defvar mode-line-modified
1833 This variable holds the value of the mode-line construct that displays
1834 whether the current buffer is modified. Its default value displays
1835 @samp{**} if the buffer is modified, @samp{--} if the buffer is not
1836 modified, @samp{%%} if the buffer is read only, and @samp{%*} if the
1837 buffer is read only and modified.
1839 Changing this variable does not force an update of the mode line.
1842 @defvar mode-line-frame-identification
1843 This variable identifies the current frame. Its default value
1844 displays @code{" "} if you are using a window system which can show
1845 multiple frames, or @code{"-%F "} on an ordinary terminal which shows
1846 only one frame at a time.
1849 @defvar mode-line-buffer-identification
1850 This variable identifies the buffer being displayed in the window.
1851 Its default value displays the buffer name, padded with spaces to at
1855 @defopt mode-line-position
1856 This variable indicates the position in the buffer. Its default value
1857 displays the buffer percentage and, optionally, the buffer size, the
1858 line number and the column number.
1862 The variable @code{vc-mode}, buffer-local in each buffer, records
1863 whether the buffer's visited file is maintained with version control,
1864 and, if so, which kind. Its value is a string that appears in the mode
1865 line, or @code{nil} for no version control.
1868 @defopt mode-line-modes
1869 This variable displays the buffer's major and minor modes. Its
1870 default value also displays the recursive editing level, information
1871 on the process status, and whether narrowing is in effect.
1874 @defopt mode-line-remote
1875 This variable is used to show whether @code{default-directory} for the
1876 current buffer is remote.
1879 @defopt mode-line-client
1880 This variable is used to identify @code{emacsclient} frames.
1883 The following three variables are used in @code{mode-line-modes}:
1886 This buffer-local variable holds the ``pretty'' name of the current
1887 buffer's major mode. Each major mode should set this variable so that
1888 the mode name will appear in the mode line. The value does not have
1889 to be a string, but can use any of the data types valid in a mode-line
1890 construct (@pxref{Mode Line Data}). To compute the string that will
1891 identify the mode name in the mode line, use @code{format-mode-line}
1892 (@pxref{Emulating Mode Line}).
1895 @defvar mode-line-process
1896 This buffer-local variable contains the mode-line information on process
1897 status in modes used for communicating with subprocesses. It is
1898 displayed immediately following the major mode name, with no intervening
1899 space. For example, its value in the @samp{*shell*} buffer is
1900 @code{(":%s")}, which allows the shell to display its status along
1901 with the major mode as: @samp{(Shell:run)}. Normally this variable
1905 @defvar minor-mode-alist
1906 @anchor{Definition of minor-mode-alist}
1907 This variable holds an association list whose elements specify how the
1908 mode line should indicate that a minor mode is active. Each element of
1909 the @code{minor-mode-alist} should be a two-element list:
1912 (@var{minor-mode-variable} @var{mode-line-string})
1915 More generally, @var{mode-line-string} can be any mode-line spec. It
1916 appears in the mode line when the value of @var{minor-mode-variable}
1917 is non-@code{nil}, and not otherwise. These strings should begin with
1918 spaces so that they don't run together. Conventionally, the
1919 @var{minor-mode-variable} for a specific mode is set to a
1920 non-@code{nil} value when that minor mode is activated.
1922 @code{minor-mode-alist} itself is not buffer-local. Each variable
1923 mentioned in the alist should be buffer-local if its minor mode can be
1924 enabled separately in each buffer.
1927 @defvar global-mode-string
1928 This variable holds a mode-line spec that, by default, appears in the
1929 mode line just after the @code{which-func-mode} minor mode if set,
1930 else after @code{mode-line-modes}. The command @code{display-time}
1931 sets @code{global-mode-string} to refer to the variable
1932 @code{display-time-string}, which holds a string containing the time
1933 and load information.
1935 The @samp{%M} construct substitutes the value of
1936 @code{global-mode-string}, but that is obsolete, since the variable is
1937 included in the mode line from @code{mode-line-format}.
1940 Here is a simplified version of the default value of
1941 @code{mode-line-format}. The real default value also
1942 specifies addition of text properties.
1949 mode-line-frame-identification
1950 mode-line-buffer-identification
1958 (which-func-mode ("" which-func-format "--"))
1959 (global-mode-string ("--" global-mode-string))
1965 @subsection @code{%}-Constructs in the Mode Line
1967 Strings used as mode-line constructs can use certain
1968 @code{%}-constructs to substitute various kinds of data. Here is a
1969 list of the defined @code{%}-constructs, and what they mean. In any
1970 construct except @samp{%%}, you can add a decimal integer after the
1971 @samp{%} to specify a minimum field width. If the width is less, the
1972 field is padded with spaces to the right.
1976 The current buffer name, obtained with the @code{buffer-name} function.
1977 @xref{Buffer Names}.
1980 The current column number of point.
1983 When Emacs is nearly out of memory for Lisp objects, a brief message
1984 saying so. Otherwise, this is empty.
1987 The visited file name, obtained with the @code{buffer-file-name}
1988 function. @xref{Buffer File Name}.
1991 The title (only on a window system) or the name of the selected frame.
1992 @xref{Basic Parameters}.
1995 The size of the accessible part of the current buffer; basically
1996 @code{(- (point-max) (point-min))}.
1999 Like @samp{%i}, but the size is printed in a more readable way by using
2000 @samp{k} for 10^3, @samp{M} for 10^6, @samp{G} for 10^9, etc., to
2004 The current line number of point, counting within the accessible portion
2008 @samp{Narrow} when narrowing is in effect; nothing otherwise (see
2009 @code{narrow-to-region} in @ref{Narrowing}).
2012 The percentage of the buffer text above the @strong{top} of window, or
2013 @samp{Top}, @samp{Bottom} or @samp{All}. Note that the default
2014 mode-line specification truncates this to three characters.
2017 The percentage of the buffer text that is above the @strong{bottom} of
2018 the window (which includes the text visible in the window, as well as
2019 the text above the top), plus @samp{Top} if the top of the buffer is
2020 visible on screen; or @samp{Bottom} or @samp{All}.
2023 The status of the subprocess belonging to the current buffer, obtained with
2024 @code{process-status}. @xref{Process Information}.
2027 Whether the visited file is a text file or a binary file. This is a
2028 meaningful distinction only on certain operating systems (@pxref{MS-DOS
2032 The mnemonics of keyboard, terminal, and buffer coding systems.
2035 Like @samp{%z}, but including the end-of-line format.
2038 @samp{%} if the buffer is read only (see @code{buffer-read-only}); @*
2039 @samp{*} if the buffer is modified (see @code{buffer-modified-p}); @*
2040 @samp{-} otherwise. @xref{Buffer Modification}.
2043 @samp{*} if the buffer is modified (see @code{buffer-modified-p}); @*
2044 @samp{%} if the buffer is read only (see @code{buffer-read-only}); @*
2045 @samp{-} otherwise. This differs from @samp{%*} only for a modified
2046 read-only buffer. @xref{Buffer Modification}.
2049 @samp{*} if the buffer is modified, and @samp{-} otherwise.
2052 An indication of the depth of recursive editing levels (not counting
2053 minibuffer levels): one @samp{[} for each editing level.
2054 @xref{Recursive Editing}.
2057 One @samp{]} for each recursive editing level (not counting minibuffer
2061 Dashes sufficient to fill the remainder of the mode line.
2064 The character @samp{%}---this is how to include a literal @samp{%} in a
2065 string in which @code{%}-constructs are allowed.
2068 The following two @code{%}-constructs are still supported, but they are
2069 obsolete, since you can get the same results with the variables
2070 @code{mode-name} and @code{global-mode-string}.
2074 The value of @code{mode-name}.
2077 The value of @code{global-mode-string}.
2080 @node Properties in Mode
2081 @subsection Properties in the Mode Line
2082 @cindex text properties in the mode line
2084 Certain text properties are meaningful in the
2085 mode line. The @code{face} property affects the appearance of text; the
2086 @code{help-echo} property associates help strings with the text, and
2087 @code{local-map} can make the text mouse-sensitive.
2089 There are four ways to specify text properties for text in the mode
2094 Put a string with a text property directly into the mode-line data
2098 Put a text property on a mode-line %-construct such as @samp{%12b}; then
2099 the expansion of the %-construct will have that same text property.
2102 Use a @code{(:propertize @var{elt} @var{props}@dots{})} construct to
2103 give @var{elt} a text property specified by @var{props}.
2106 Use a list containing @code{:eval @var{form}} in the mode-line data
2107 structure, and make @var{form} evaluate to a string that has a text
2111 You can use the @code{local-map} property to specify a keymap. This
2112 keymap only takes real effect for mouse clicks; binding character keys
2113 and function keys to it has no effect, since it is impossible to move
2114 point into the mode line.
2116 When the mode line refers to a variable which does not have a
2117 non-@code{nil} @code{risky-local-variable} property, any text
2118 properties given or specified within that variable's values are
2119 ignored. This is because such properties could otherwise specify
2120 functions to be called, and those functions could come from file
2124 @subsection Window Header Lines
2125 @cindex header line (of a window)
2126 @cindex window header line
2128 A window can have a @dfn{header line} at the
2129 top, just as it can have a mode line at the bottom. The header line
2130 feature works just like the mode-line feature, except that it's
2131 controlled by different variables.
2133 @defvar header-line-format
2134 This variable, local in every buffer, specifies how to display the
2135 header line, for windows displaying the buffer. The format of the value
2136 is the same as for @code{mode-line-format} (@pxref{Mode Line Data}).
2137 It is normally @code{nil}, so that ordinary buffers have no header line.
2140 A window that is just one line tall never displays a header line. A
2141 window that is two lines tall cannot display both a mode line and a
2142 header line at once; if it has a mode line, then it does not display a
2145 @node Emulating Mode Line
2146 @subsection Emulating Mode-Line Formatting
2148 You can use the function @code{format-mode-line} to compute
2149 the text that would appear in a mode line or header line
2150 based on a certain mode-line specification.
2152 @defun format-mode-line format &optional face window buffer
2153 This function formats a line of text according to @var{format} as if it
2154 were generating the mode line for @var{window}, but it also returns the
2155 text as a string. The argument @var{window} defaults to the selected
2156 window. If @var{buffer} is non-@code{nil}, all the information used is
2157 taken from @var{buffer}; by default, it comes from @var{window}'s
2160 The value string normally has text properties that correspond to the
2161 faces, keymaps, etc., that the mode line would have. Any character for
2162 which no @code{face} property is specified by @var{format} gets a
2163 default value determined by @var{face}. If @var{face} is @code{t}, that
2164 stands for either @code{mode-line} if @var{window} is selected,
2165 otherwise @code{mode-line-inactive}. If @var{face} is @code{nil} or
2166 omitted, that stands for the default face. If @var{face} is an integer,
2167 the value returned by this function will have no text properties.
2169 You can also specify other valid faces as the value of @var{face}.
2170 If specified, that face provides the @code{face} property for characters
2171 whose face is not specified by @var{format}.
2173 Note that using @code{mode-line}, @code{mode-line-inactive}, or
2174 @code{header-line} as @var{face} will actually redisplay the mode line
2175 or the header line, respectively, using the current definitions of the
2176 corresponding face, in addition to returning the formatted string.
2177 (Other faces do not cause redisplay.)
2179 For example, @code{(format-mode-line header-line-format)} returns the
2180 text that would appear in the selected window's header line (@code{""}
2181 if it has no header line). @code{(format-mode-line header-line-format
2182 'header-line)} returns the same text, with each character
2183 carrying the face that it will have in the header line itself, and also
2184 redraws the header line.
2191 @dfn{Imenu} is a feature that lets users select a definition or
2192 section in the buffer, from a menu which lists all of them, to go
2193 directly to that location in the buffer. Imenu works by constructing
2194 a buffer index which lists the names and buffer positions of the
2195 definitions, or other named portions of the buffer; then the user can
2196 choose one of them and move point to it. Major modes can add a menu
2197 bar item to use Imenu using @code{imenu-add-to-menubar}.
2199 @defun imenu-add-to-menubar name
2200 This function defines a local menu bar item named @var{name}
2204 The user-level commands for using Imenu are described in the Emacs
2205 Manual (@pxref{Imenu,, Imenu, emacs, the Emacs Manual}). This section
2206 explains how to customize Imenu's method of finding definitions or
2207 buffer portions for a particular major mode.
2209 The usual and simplest way is to set the variable
2210 @code{imenu-generic-expression}:
2212 @defvar imenu-generic-expression
2213 This variable, if non-@code{nil}, is a list that specifies regular
2214 expressions for finding definitions for Imenu. Simple elements of
2215 @code{imenu-generic-expression} look like this:
2218 (@var{menu-title} @var{regexp} @var{index})
2221 Here, if @var{menu-title} is non-@code{nil}, it says that the matches
2222 for this element should go in a submenu of the buffer index;
2223 @var{menu-title} itself specifies the name for the submenu. If
2224 @var{menu-title} is @code{nil}, the matches for this element go directly
2225 in the top level of the buffer index.
2227 The second item in the list, @var{regexp}, is a regular expression
2228 (@pxref{Regular Expressions}); anything in the buffer that it matches
2229 is considered a definition, something to mention in the buffer index.
2230 The third item, @var{index}, is a non-negative integer that indicates
2231 which subexpression in @var{regexp} matches the definition's name.
2233 An element can also look like this:
2236 (@var{menu-title} @var{regexp} @var{index} @var{function} @var{arguments}@dots{})
2239 Each match for this element creates an index item, and when the index
2240 item is selected by the user, it calls @var{function} with arguments
2241 consisting of the item name, the buffer position, and @var{arguments}.
2243 For Emacs Lisp mode, @code{imenu-generic-expression} could look like
2246 @c should probably use imenu-syntax-alist and \\sw rather than [-A-Za-z0-9+]
2249 ((nil "^\\s-*(def\\(un\\|subst\\|macro\\|advice\\)\
2250 \\s-+\\([-A-Za-z0-9+]+\\)" 2)
2253 ("*Vars*" "^\\s-*(def\\(var\\|const\\)\
2254 \\s-+\\([-A-Za-z0-9+]+\\)" 2)
2259 (def\\(type\\|struct\\|class\\|ine-condition\\)\
2260 \\s-+\\([-A-Za-z0-9+]+\\)" 2))
2264 Setting this variable makes it buffer-local in the current buffer.
2267 @defvar imenu-case-fold-search
2268 This variable controls whether matching against the regular
2269 expressions in the value of @code{imenu-generic-expression} is
2270 case-sensitive: @code{t}, the default, means matching should ignore
2273 Setting this variable makes it buffer-local in the current buffer.
2276 @defvar imenu-syntax-alist
2277 This variable is an alist of syntax table modifiers to use while
2278 processing @code{imenu-generic-expression}, to override the syntax table
2279 of the current buffer. Each element should have this form:
2282 (@var{characters} . @var{syntax-description})
2285 The @sc{car}, @var{characters}, can be either a character or a string.
2286 The element says to give that character or characters the syntax
2287 specified by @var{syntax-description}, which is passed to
2288 @code{modify-syntax-entry} (@pxref{Syntax Table Functions}).
2290 This feature is typically used to give word syntax to characters which
2291 normally have symbol syntax, and thus to simplify
2292 @code{imenu-generic-expression} and speed up matching.
2293 For example, Fortran mode uses it this way:
2296 (setq imenu-syntax-alist '(("_$" . "w")))
2299 The @code{imenu-generic-expression} regular expressions can then use
2300 @samp{\\sw+} instead of @samp{\\(\\sw\\|\\s_\\)+}. Note that this
2301 technique may be inconvenient when the mode needs to limit the initial
2302 character of a name to a smaller set of characters than are allowed in
2305 Setting this variable makes it buffer-local in the current buffer.
2308 Another way to customize Imenu for a major mode is to set the
2309 variables @code{imenu-prev-index-position-function} and
2310 @code{imenu-extract-index-name-function}:
2312 @defvar imenu-prev-index-position-function
2313 If this variable is non-@code{nil}, its value should be a function that
2314 finds the next ``definition'' to put in the buffer index, scanning
2315 backward in the buffer from point. It should return @code{nil} if it
2316 doesn't find another ``definition'' before point. Otherwise it should
2317 leave point at the place it finds a ``definition'' and return any
2318 non-@code{nil} value.
2320 Setting this variable makes it buffer-local in the current buffer.
2323 @defvar imenu-extract-index-name-function
2324 If this variable is non-@code{nil}, its value should be a function to
2325 return the name for a definition, assuming point is in that definition
2326 as the @code{imenu-prev-index-position-function} function would leave
2329 Setting this variable makes it buffer-local in the current buffer.
2332 The last way to customize Imenu for a major mode is to set the
2333 variable @code{imenu-create-index-function}:
2335 @defvar imenu-create-index-function
2336 This variable specifies the function to use for creating a buffer
2337 index. The function should take no arguments, and return an index
2338 alist for the current buffer. It is called within
2339 @code{save-excursion}, so where it leaves point makes no difference.
2341 The index alist can have three types of elements. Simple elements
2345 (@var{index-name} . @var{index-position})
2348 Selecting a simple element has the effect of moving to position
2349 @var{index-position} in the buffer. Special elements look like this:
2352 (@var{index-name} @var{index-position} @var{function} @var{arguments}@dots{})
2355 Selecting a special element performs:
2358 (funcall @var{function}
2359 @var{index-name} @var{index-position} @var{arguments}@dots{})
2362 A nested sub-alist element looks like this:
2365 (@var{menu-title} @var{sub-alist})
2368 It creates the submenu @var{menu-title} specified by @var{sub-alist}.
2370 The default value of @code{imenu-create-index-function} is
2371 @code{imenu-default-create-index-function}. This function calls the
2372 value of @code{imenu-prev-index-position-function} and the value of
2373 @code{imenu-extract-index-name-function} to produce the index alist.
2374 However, if either of these two variables is @code{nil}, the default
2375 function uses @code{imenu-generic-expression} instead.
2377 Setting this variable makes it buffer-local in the current buffer.
2380 @node Font Lock Mode
2381 @section Font Lock Mode
2382 @cindex Font Lock mode
2384 @dfn{Font Lock mode} is a feature that automatically attaches
2385 @code{face} properties to certain parts of the buffer based on their
2386 syntactic role. How it parses the buffer depends on the major mode;
2387 most major modes define syntactic criteria for which faces to use in
2388 which contexts. This section explains how to customize Font Lock for a
2389 particular major mode.
2391 Font Lock mode finds text to highlight in two ways: through
2392 syntactic parsing based on the syntax table, and through searching
2393 (usually for regular expressions). Syntactic fontification happens
2394 first; it finds comments and string constants and highlights them.
2395 Search-based fontification happens second.
2398 * Font Lock Basics:: Overview of customizing Font Lock.
2399 * Search-based Fontification:: Fontification based on regexps.
2400 * Customizing Keywords:: Customizing search-based fontification.
2401 * Other Font Lock Variables:: Additional customization facilities.
2402 * Levels of Font Lock:: Each mode can define alternative levels
2403 so that the user can select more or less.
2404 * Precalculated Fontification:: How Lisp programs that produce the buffer
2405 contents can also specify how to fontify it.
2406 * Faces for Font Lock:: Special faces specifically for Font Lock.
2407 * Syntactic Font Lock:: Fontification based on syntax tables.
2408 * Setting Syntax Properties:: Defining character syntax based on context
2409 using the Font Lock mechanism.
2410 * Multiline Font Lock:: How to coerce Font Lock into properly
2411 highlighting multiline constructs.
2414 @node Font Lock Basics
2415 @subsection Font Lock Basics
2417 There are several variables that control how Font Lock mode highlights
2418 text. But major modes should not set any of these variables directly.
2419 Instead, they should set @code{font-lock-defaults} as a buffer-local
2420 variable. The value assigned to this variable is used, if and when Font
2421 Lock mode is enabled, to set all the other variables.
2423 @defvar font-lock-defaults
2424 This variable is set by major modes, as a buffer-local variable, to
2425 specify how to fontify text in that mode. It automatically becomes
2426 buffer-local when you set it. If its value is @code{nil}, Font-Lock
2427 mode does no highlighting, and you can use the @samp{Faces} menu
2428 (under @samp{Edit} and then @samp{Text Properties} in the menu bar) to
2429 assign faces explicitly to text in the buffer.
2431 If non-@code{nil}, the value should look like this:
2434 (@var{keywords} [@var{keywords-only} [@var{case-fold}
2435 [@var{syntax-alist} [@var{syntax-begin} @var{other-vars}@dots{}]]]])
2438 The first element, @var{keywords}, indirectly specifies the value of
2439 @code{font-lock-keywords} which directs search-based fontification.
2440 It can be a symbol, a variable or a function whose value is the list
2441 to use for @code{font-lock-keywords}. It can also be a list of
2442 several such symbols, one for each possible level of fontification.
2443 The first symbol specifies the @samp{mode default} level of
2444 fontification, the next symbol level 1 fontification, the next level 2,
2445 and so on. The @samp{mode default} level is normally the same as level
2446 1. It is used when @code{font-lock-maximum-decoration} has a @code{nil}
2447 value. @xref{Levels of Font Lock}.
2449 The second element, @var{keywords-only}, specifies the value of the
2450 variable @code{font-lock-keywords-only}. If this is omitted or
2451 @code{nil}, syntactic fontification (of strings and comments) is also
2452 performed. If this is non-@code{nil}, such fontification is not
2453 performed. @xref{Syntactic Font Lock}.
2455 The third element, @var{case-fold}, specifies the value of
2456 @code{font-lock-keywords-case-fold-search}. If it is non-@code{nil},
2457 Font Lock mode ignores case when searching as directed by
2458 @code{font-lock-keywords}.
2460 If the fourth element, @var{syntax-alist}, is non-@code{nil}, it
2461 should be a list of cons cells of the form @code{(@var{char-or-string}
2462 . @var{string})}. These are used to set up a syntax table for
2463 syntactic fontification (@pxref{Syntax Table Functions}). The
2464 resulting syntax table is stored in @code{font-lock-syntax-table}.
2466 The fifth element, @var{syntax-begin}, specifies the value of
2467 @code{font-lock-beginning-of-syntax-function}. We recommend setting
2468 this variable to @code{nil} and using @code{syntax-begin-function}
2471 All the remaining elements (if any) are collectively called
2472 @var{other-vars}. Each of these elements should have the form
2473 @code{(@var{variable} . @var{value})}---which means, make
2474 @var{variable} buffer-local and then set it to @var{value}. You can
2475 use these @var{other-vars} to set other variables that affect
2476 fontification, aside from those you can control with the first five
2477 elements. @xref{Other Font Lock Variables}.
2480 If your mode fontifies text explicitly by adding
2481 @code{font-lock-face} properties, it can specify @code{(nil t)} for
2482 @code{font-lock-defaults} to turn off all automatic fontification.
2483 However, this is not required; it is possible to fontify some things
2484 using @code{font-lock-face} properties and set up automatic
2485 fontification for other parts of the text.
2487 @node Search-based Fontification
2488 @subsection Search-based Fontification
2490 The most important variable for customizing Font Lock mode is
2491 @code{font-lock-keywords}. It specifies the search criteria for
2492 search-based fontification. You should specify the value of this
2493 variable with @var{keywords} in @code{font-lock-defaults}.
2495 @defvar font-lock-keywords
2496 This variable's value is a list of the keywords to highlight. Be
2497 careful when composing regular expressions for this list; a poorly
2498 written pattern can dramatically slow things down!
2501 Each element of @code{font-lock-keywords} specifies how to find
2502 certain cases of text, and how to highlight those cases. Font Lock mode
2503 processes the elements of @code{font-lock-keywords} one by one, and for
2504 each element, it finds and handles all matches. Ordinarily, once
2505 part of the text has been fontified already, this cannot be overridden
2506 by a subsequent match in the same text; but you can specify different
2507 behavior using the @var{override} element of a @var{subexp-highlighter}.
2509 Each element of @code{font-lock-keywords} should have one of these
2514 Highlight all matches for @var{regexp} using
2515 @code{font-lock-keyword-face}. For example,
2518 ;; @r{Highlight occurrences of the word @samp{foo}}
2519 ;; @r{using @code{font-lock-keyword-face}.}
2523 The function @code{regexp-opt} (@pxref{Regexp Functions}) is useful
2524 for calculating optimal regular expressions to match a number of
2527 @item @var{function}
2528 Find text by calling @var{function}, and highlight the matches
2529 it finds using @code{font-lock-keyword-face}.
2531 When @var{function} is called, it receives one argument, the limit of
2532 the search; it should begin searching at point, and not search beyond the
2533 limit. It should return non-@code{nil} if it succeeds, and set the
2534 match data to describe the match that was found. Returning @code{nil}
2535 indicates failure of the search.
2537 Fontification will call @var{function} repeatedly with the same limit,
2538 and with point where the previous invocation left it, until
2539 @var{function} fails. On failure, @var{function} need not reset point
2540 in any particular way.
2542 @item (@var{matcher} . @var{subexp})
2543 In this kind of element, @var{matcher} is either a regular
2544 expression or a function, as described above. The @sc{cdr},
2545 @var{subexp}, specifies which subexpression of @var{matcher} should be
2546 highlighted (instead of the entire text that @var{matcher} matched).
2549 ;; @r{Highlight the @samp{bar} in each occurrence of @samp{fubar},}
2550 ;; @r{using @code{font-lock-keyword-face}.}
2554 If you use @code{regexp-opt} to produce the regular expression
2555 @var{matcher}, you can use @code{regexp-opt-depth} (@pxref{Regexp
2556 Functions}) to calculate the value for @var{subexp}.
2558 @item (@var{matcher} . @var{facespec})
2559 In this kind of element, @var{facespec} is an expression whose value
2560 specifies the face to use for highlighting. In the simplest case,
2561 @var{facespec} is a Lisp variable (a symbol) whose value is a face
2565 ;; @r{Highlight occurrences of @samp{fubar},}
2566 ;; @r{using the face which is the value of @code{fubar-face}.}
2567 ("fubar" . fubar-face)
2570 However, @var{facespec} can also evaluate to a list of this form:
2573 (face @var{face} @var{prop1} @var{val1} @var{prop2} @var{val2}@dots{})
2577 to specify the face @var{face} and various additional text properties
2578 to put on the text that matches. If you do this, be sure to add the
2579 other text property names that you set in this way to the value of
2580 @code{font-lock-extra-managed-props} so that the properties will also
2581 be cleared out when they are no longer appropriate. Alternatively,
2582 you can set the variable @code{font-lock-unfontify-region-function} to
2583 a function that clears these properties. @xref{Other Font Lock
2586 @item (@var{matcher} . @var{subexp-highlighter})
2587 In this kind of element, @var{subexp-highlighter} is a list
2588 which specifies how to highlight matches found by @var{matcher}.
2592 (@var{subexp} @var{facespec} [@var{override} [@var{laxmatch}]])
2595 The @sc{car}, @var{subexp}, is an integer specifying which subexpression
2596 of the match to fontify (0 means the entire matching text). The second
2597 subelement, @var{facespec}, is an expression whose value specifies the
2598 face, as described above.
2600 The last two values in @var{subexp-highlighter}, @var{override} and
2601 @var{laxmatch}, are optional flags. If @var{override} is @code{t},
2602 this element can override existing fontification made by previous
2603 elements of @code{font-lock-keywords}. If it is @code{keep}, then
2604 each character is fontified if it has not been fontified already by
2605 some other element. If it is @code{prepend}, the face specified by
2606 @var{facespec} is added to the beginning of the @code{font-lock-face}
2607 property. If it is @code{append}, the face is added to the end of the
2608 @code{font-lock-face} property.
2610 If @var{laxmatch} is non-@code{nil}, it means there should be no error
2611 if there is no subexpression numbered @var{subexp} in @var{matcher}.
2612 Obviously, fontification of the subexpression numbered @var{subexp} will
2613 not occur. However, fontification of other subexpressions (and other
2614 regexps) will continue. If @var{laxmatch} is @code{nil}, and the
2615 specified subexpression is missing, then an error is signaled which
2616 terminates search-based fontification.
2618 Here are some examples of elements of this kind, and what they do:
2621 ;; @r{Highlight occurrences of either @samp{foo} or @samp{bar}, using}
2622 ;; @r{@code{foo-bar-face}, even if they have already been highlighted.}
2623 ;; @r{@code{foo-bar-face} should be a variable whose value is a face.}
2624 ("foo\\|bar" 0 foo-bar-face t)
2626 ;; @r{Highlight the first subexpression within each occurrence}
2627 ;; @r{that the function @code{fubar-match} finds,}
2628 ;; @r{using the face which is the value of @code{fubar-face}.}
2629 (fubar-match 1 fubar-face)
2632 @item (@var{matcher} . @var{anchored-highlighter})
2633 In this kind of element, @var{anchored-highlighter} specifies how to
2634 highlight text that follows a match found by @var{matcher}. So a
2635 match found by @var{matcher} acts as the anchor for further searches
2636 specified by @var{anchored-highlighter}. @var{anchored-highlighter}
2637 is a list of the following form:
2640 (@var{anchored-matcher} @var{pre-form} @var{post-form}
2641 @var{subexp-highlighters}@dots{})
2644 Here, @var{anchored-matcher}, like @var{matcher}, is either a regular
2645 expression or a function. After a match of @var{matcher} is found,
2646 point is at the end of the match. Now, Font Lock evaluates the form
2647 @var{pre-form}. Then it searches for matches of
2648 @var{anchored-matcher} and uses @var{subexp-highlighters} to highlight
2649 these. A @var{subexp-highlighter} is as described above. Finally,
2650 Font Lock evaluates @var{post-form}.
2652 The forms @var{pre-form} and @var{post-form} can be used to initialize
2653 before, and cleanup after, @var{anchored-matcher} is used. Typically,
2654 @var{pre-form} is used to move point to some position relative to the
2655 match of @var{matcher}, before starting with @var{anchored-matcher}.
2656 @var{post-form} might be used to move back, before resuming with
2659 After Font Lock evaluates @var{pre-form}, it does not search for
2660 @var{anchored-matcher} beyond the end of the line. However, if
2661 @var{pre-form} returns a buffer position that is greater than the
2662 position of point after @var{pre-form} is evaluated, then the position
2663 returned by @var{pre-form} is used as the limit of the search instead.
2664 It is generally a bad idea to return a position greater than the end
2665 of the line; in other words, the @var{anchored-matcher} search should
2671 ;; @r{Highlight occurrences of the word @samp{item} following}
2672 ;; @r{an occurrence of the word @samp{anchor} (on the same line)}
2673 ;; @r{in the value of @code{item-face}.}
2674 ("\\<anchor\\>" "\\<item\\>" nil nil (0 item-face))
2677 Here, @var{pre-form} and @var{post-form} are @code{nil}. Therefore
2678 searching for @samp{item} starts at the end of the match of
2679 @samp{anchor}, and searching for subsequent instances of @samp{anchor}
2680 resumes from where searching for @samp{item} concluded.
2682 @item (@var{matcher} @var{highlighters}@dots{})
2683 This sort of element specifies several @var{highlighter} lists for a
2684 single @var{matcher}. A @var{highlighter} list can be of the type
2685 @var{subexp-highlighter} or @var{anchored-highlighter} as described
2691 ;; @r{Highlight occurrences of the word @samp{anchor} in the value}
2692 ;; @r{of @code{anchor-face}, and subsequent occurrences of the word}
2693 ;; @r{@samp{item} (on the same line) in the value of @code{item-face}.}
2694 ("\\<anchor\\>" (0 anchor-face)
2695 ("\\<item\\>" nil nil (0 item-face)))
2698 @item (eval . @var{form})
2699 Here @var{form} is an expression to be evaluated the first time
2700 this value of @code{font-lock-keywords} is used in a buffer.
2701 Its value should have one of the forms described in this table.
2704 @strong{Warning:} Do not design an element of @code{font-lock-keywords}
2705 to match text which spans lines; this does not work reliably.
2706 For details, see @xref{Multiline Font Lock}.
2708 You can use @var{case-fold} in @code{font-lock-defaults} to specify
2709 the value of @code{font-lock-keywords-case-fold-search} which says
2710 whether search-based fontification should be case-insensitive.
2712 @defvar font-lock-keywords-case-fold-search
2713 Non-@code{nil} means that regular expression matching for the sake of
2714 @code{font-lock-keywords} should be case-insensitive.
2717 @node Customizing Keywords
2718 @subsection Customizing Search-Based Fontification
2720 You can use @code{font-lock-add-keywords} to add additional
2721 search-based fontification rules to a major mode, and
2722 @code{font-lock-remove-keywords} to remove rules.
2724 @defun font-lock-add-keywords mode keywords &optional how
2725 This function adds highlighting @var{keywords}, for the current buffer
2726 or for major mode @var{mode}. The argument @var{keywords} should be a
2727 list with the same format as the variable @code{font-lock-keywords}.
2729 If @var{mode} is a symbol which is a major mode command name, such as
2730 @code{c-mode}, the effect is that enabling Font Lock mode in
2731 @var{mode} will add @var{keywords} to @code{font-lock-keywords}.
2732 Calling with a non-@code{nil} value of @var{mode} is correct only in
2733 your @file{~/.emacs} file.
2735 If @var{mode} is @code{nil}, this function adds @var{keywords} to
2736 @code{font-lock-keywords} in the current buffer. This way of calling
2737 @code{font-lock-add-keywords} is usually used in mode hook functions.
2739 By default, @var{keywords} are added at the beginning of
2740 @code{font-lock-keywords}. If the optional argument @var{how} is
2741 @code{set}, they are used to replace the value of
2742 @code{font-lock-keywords}. If @var{how} is any other non-@code{nil}
2743 value, they are added at the end of @code{font-lock-keywords}.
2745 Some modes provide specialized support you can use in additional
2746 highlighting patterns. See the variables
2747 @code{c-font-lock-extra-types}, @code{c++-font-lock-extra-types},
2748 and @code{java-font-lock-extra-types}, for example.
2750 @strong{Warning:} major mode functions must not call
2751 @code{font-lock-add-keywords} under any circumstances, either directly
2752 or indirectly, except through their mode hooks. (Doing so would lead
2753 to incorrect behavior for some minor modes.) They should set up their
2754 rules for search-based fontification by setting
2755 @code{font-lock-keywords}.
2758 @defun font-lock-remove-keywords mode keywords
2759 This function removes @var{keywords} from @code{font-lock-keywords}
2760 for the current buffer or for major mode @var{mode}. As in
2761 @code{font-lock-add-keywords}, @var{mode} should be a major mode
2762 command name or @code{nil}. All the caveats and requirements for
2763 @code{font-lock-add-keywords} apply here too.
2766 For example, this code
2769 (font-lock-add-keywords 'c-mode
2770 '(("\\<\\(FIXME\\):" 1 font-lock-warning-face prepend)
2771 ("\\<\\(and\\|or\\|not\\)\\>" . font-lock-keyword-face)))
2775 adds two fontification patterns for C mode: one to fontify the word
2776 @samp{FIXME}, even in comments, and another to fontify the words
2777 @samp{and}, @samp{or} and @samp{not} as keywords.
2780 That example affects only C mode proper. To add the same patterns to
2781 C mode @emph{and} all modes derived from it, do this instead:
2784 (add-hook 'c-mode-hook
2786 (font-lock-add-keywords nil
2787 '(("\\<\\(FIXME\\):" 1 font-lock-warning-face prepend)
2788 ("\\<\\(and\\|or\\|not\\)\\>" .
2789 font-lock-keyword-face)))))
2792 @node Other Font Lock Variables
2793 @subsection Other Font Lock Variables
2795 This section describes additional variables that a major mode can
2796 set by means of @var{other-vars} in @code{font-lock-defaults}
2797 (@pxref{Font Lock Basics}).
2799 @defvar font-lock-mark-block-function
2800 If this variable is non-@code{nil}, it should be a function that is
2801 called with no arguments, to choose an enclosing range of text for
2802 refontification for the command @kbd{M-o M-o}
2803 (@code{font-lock-fontify-block}).
2805 The function should report its choice by placing the region around it.
2806 A good choice is a range of text large enough to give proper results,
2807 but not too large so that refontification becomes slow. Typical values
2808 are @code{mark-defun} for programming modes or @code{mark-paragraph} for
2812 @defvar font-lock-extra-managed-props
2813 This variable specifies additional properties (other than
2814 @code{font-lock-face}) that are being managed by Font Lock mode. It
2815 is used by @code{font-lock-default-unfontify-region}, which normally
2816 only manages the @code{font-lock-face} property. If you want Font
2817 Lock to manage other properties as well, you must specify them in a
2818 @var{facespec} in @code{font-lock-keywords} as well as add them to
2819 this list. @xref{Search-based Fontification}.
2822 @defvar font-lock-fontify-buffer-function
2823 Function to use for fontifying the buffer. The default value is
2824 @code{font-lock-default-fontify-buffer}.
2827 @defvar font-lock-unfontify-buffer-function
2828 Function to use for unfontifying the buffer. This is used when
2829 turning off Font Lock mode. The default value is
2830 @code{font-lock-default-unfontify-buffer}.
2833 @defvar font-lock-fontify-region-function
2834 Function to use for fontifying a region. It should take two
2835 arguments, the beginning and end of the region, and an optional third
2836 argument @var{verbose}. If @var{verbose} is non-@code{nil}, the
2837 function should print status messages. The default value is
2838 @code{font-lock-default-fontify-region}.
2841 @defvar font-lock-unfontify-region-function
2842 Function to use for unfontifying a region. It should take two
2843 arguments, the beginning and end of the region. The default value is
2844 @code{font-lock-default-unfontify-region}.
2847 @defun jit-lock-register function &optional contextual
2848 This function tells Font Lock mode to run the Lisp function
2849 @var{function} any time it has to fontify or refontify part of the
2850 current buffer. It calls @var{function} before calling the default
2851 fontification functions, and gives it two arguments, @var{start} and
2852 @var{end}, which specify the region to be fontified or refontified.
2854 The optional argument @var{contextual}, if non-@code{nil}, forces Font
2855 Lock mode to always refontify a syntactically relevant part of the
2856 buffer, and not just the modified lines. This argument can usually be
2860 @defun jit-lock-unregister function
2861 If @var{function} was previously registered as a fontification
2862 function using @code{jit-lock-register}, this function unregisters it.
2865 @node Levels of Font Lock
2866 @subsection Levels of Font Lock
2868 Many major modes offer three different levels of fontification. You
2869 can define multiple levels by using a list of symbols for @var{keywords}
2870 in @code{font-lock-defaults}. Each symbol specifies one level of
2871 fontification; it is up to the user to choose one of these levels,
2872 normally by setting @code{font-lock-maximum-decoration} (@pxref{Font
2873 Lock,,, emacs, the GNU Emacs Manual}). The chosen level's symbol
2874 value is used to initialize @code{font-lock-keywords}.
2876 Here are the conventions for how to define the levels of
2881 Level 1: highlight function declarations, file directives (such as include or
2882 import directives), strings and comments. The idea is speed, so only
2883 the most important and top-level components are fontified.
2886 Level 2: in addition to level 1, highlight all language keywords,
2887 including type names that act like keywords, as well as named constant
2888 values. The idea is that all keywords (either syntactic or semantic)
2889 should be fontified appropriately.
2892 Level 3: in addition to level 2, highlight the symbols being defined in
2893 function and variable declarations, and all builtin function names,
2894 wherever they appear.
2897 @node Precalculated Fontification
2898 @subsection Precalculated Fontification
2900 Some major modes such as @code{list-buffers} and @code{occur}
2901 construct the buffer text programmatically. The easiest way for them
2902 to support Font Lock mode is to specify the faces of text when they
2903 insert the text in the buffer.
2905 The way to do this is to specify the faces in the text with the
2906 special text property @code{font-lock-face} (@pxref{Special
2907 Properties}). When Font Lock mode is enabled, this property controls
2908 the display, just like the @code{face} property. When Font Lock mode
2909 is disabled, @code{font-lock-face} has no effect on the display.
2911 It is ok for a mode to use @code{font-lock-face} for some text and
2912 also use the normal Font Lock machinery. But if the mode does not use
2913 the normal Font Lock machinery, it should not set the variable
2914 @code{font-lock-defaults}.
2916 @node Faces for Font Lock
2917 @subsection Faces for Font Lock
2918 @cindex faces for font lock
2919 @cindex font lock faces
2921 Font Lock mode can highlight using any face, but Emacs defines several
2922 faces specifically for syntactic highlighting. These @dfn{Font Lock
2923 faces} are listed below. They can also be used by major modes for
2924 syntactic highlighting outside of Font Lock mode (@pxref{Major Mode
2927 Each of these symbols is both a face name, and a variable whose
2928 default value is the symbol itself. Thus, the default value of
2929 @code{font-lock-comment-face} is @code{font-lock-comment-face}.
2931 The faces are listed with descriptions of their typical usage, and in
2932 order of greater to lesser ``prominence''. If a mode's syntactic
2933 categories do not fit well with the usage descriptions, the faces can be
2934 assigned using the ordering as a guide.
2937 @item font-lock-warning-face
2938 @vindex font-lock-warning-face
2939 for a construct that is peculiar, or that greatly changes the meaning of
2940 other text, like @samp{;;;###autoload} in Emacs Lisp and @samp{#error}
2943 @item font-lock-function-name-face
2944 @vindex font-lock-function-name-face
2945 for the name of a function being defined or declared.
2947 @item font-lock-variable-name-face
2948 @vindex font-lock-variable-name-face
2949 for the name of a variable being defined or declared.
2951 @item font-lock-keyword-face
2952 @vindex font-lock-keyword-face
2953 for a keyword with special syntactic significance, like @samp{for} and
2956 @item font-lock-comment-face
2957 @vindex font-lock-comment-face
2960 @item font-lock-comment-delimiter-face
2961 @vindex font-lock-comment-delimiter-face
2962 for comments delimiters, like @samp{/*} and @samp{*/} in C. On most
2963 terminals, this inherits from @code{font-lock-comment-face}.
2965 @item font-lock-type-face
2966 @vindex font-lock-type-face
2967 for the names of user-defined data types.
2969 @item font-lock-constant-face
2970 @vindex font-lock-constant-face
2971 for the names of constants, like @samp{NULL} in C.
2973 @item font-lock-builtin-face
2974 @vindex font-lock-builtin-face
2975 for the names of built-in functions.
2977 @item font-lock-preprocessor-face
2978 @vindex font-lock-preprocessor-face
2979 for preprocessor commands. This inherits, by default, from
2980 @code{font-lock-builtin-face}.
2982 @item font-lock-string-face
2983 @vindex font-lock-string-face
2984 for string constants.
2986 @item font-lock-doc-face
2987 @vindex font-lock-doc-face
2988 for documentation strings in the code. This inherits, by default, from
2989 @code{font-lock-string-face}.
2991 @item font-lock-negation-char-face
2992 @vindex font-lock-negation-char-face
2993 for easily-overlooked negation characters.
2996 @node Syntactic Font Lock
2997 @subsection Syntactic Font Lock
2998 @cindex syntactic font lock
3000 Syntactic fontification uses the syntax table to find comments and
3001 string constants (@pxref{Syntax Tables}). It highlights them using
3002 @code{font-lock-comment-face} and @code{font-lock-string-face}
3003 (@pxref{Faces for Font Lock}), or whatever
3004 @code{font-lock-syntactic-face-function} chooses. There are several
3005 variables that affect syntactic fontification; you should set them by
3006 means of @code{font-lock-defaults} (@pxref{Font Lock Basics}).
3008 @defvar font-lock-keywords-only
3009 Non-@code{nil} means Font Lock should not do syntactic fontification;
3010 it should only fontify based on @code{font-lock-keywords}. The normal
3011 way for a mode to set this variable to @code{t} is with
3012 @var{keywords-only} in @code{font-lock-defaults}.
3015 @defvar font-lock-syntax-table
3016 This variable holds the syntax table to use for fontification of
3017 comments and strings. Specify it using @var{syntax-alist} in
3018 @code{font-lock-defaults}. If this is @code{nil}, fontification uses
3019 the buffer's syntax table.
3022 @defvar font-lock-beginning-of-syntax-function
3023 If this variable is non-@code{nil}, it should be a function to move
3024 point back to a position that is syntactically at ``top level'' and
3025 outside of strings or comments. Font Lock uses this when necessary
3026 to get the right results for syntactic fontification.
3028 This function is called with no arguments. It should leave point at
3029 the beginning of any enclosing syntactic block. Typical values are
3030 @code{beginning-of-line} (used when the start of the line is known to
3031 be outside a syntactic block), or @code{beginning-of-defun} for
3032 programming modes, or @code{backward-paragraph} for textual modes.
3034 If the value is @code{nil}, Font Lock uses
3035 @code{syntax-begin-function} to move back outside of any comment,
3036 string, or sexp. This variable is semi-obsolete; we recommend setting
3037 @code{syntax-begin-function} instead.
3039 Specify this variable using @var{syntax-begin} in
3040 @code{font-lock-defaults}.
3043 @defvar font-lock-syntactic-face-function
3044 A function to determine which face to use for a given syntactic
3045 element (a string or a comment). The function is called with one
3046 argument, the parse state at point returned by
3047 @code{parse-partial-sexp}, and should return a face. The default
3048 value returns @code{font-lock-comment-face} for comments and
3049 @code{font-lock-string-face} for strings.
3051 This can be used to highlighting different kinds of strings or
3052 comments differently. It is also sometimes abused together with
3053 @code{font-lock-syntactic-keywords} to highlight constructs that span
3054 multiple lines, but this is too esoteric to document here.
3056 Specify this variable using @var{other-vars} in
3057 @code{font-lock-defaults}.
3060 @node Setting Syntax Properties
3061 @subsection Setting Syntax Properties
3063 Font Lock mode can be used to update @code{syntax-table} properties
3064 automatically (@pxref{Syntax Properties}). This is useful in
3065 languages for which a single syntax table by itself is not sufficient.
3067 @defvar font-lock-syntactic-keywords
3068 This variable enables and controls updating @code{syntax-table}
3069 properties by Font Lock. Its value should be a list of elements of
3073 (@var{matcher} @var{subexp} @var{syntax} @var{override} @var{laxmatch})
3076 The parts of this element have the same meanings as in the corresponding
3077 sort of element of @code{font-lock-keywords},
3080 (@var{matcher} @var{subexp} @var{facespec} @var{override} @var{laxmatch})
3083 However, instead of specifying the value @var{facespec} to use for the
3084 @code{face} property, it specifies the value @var{syntax} to use for
3085 the @code{syntax-table} property. Here, @var{syntax} can be a string
3086 (as taken by @code{modify-syntax-entry}), a syntax table, a cons cell
3087 (as returned by @code{string-to-syntax}), or an expression whose value
3088 is one of those two types. @var{override} cannot be @code{prepend} or
3091 For example, an element of the form:
3094 ("\\$\\(#\\)" 1 ".")
3097 highlights syntactically a hash character when following a dollar
3098 character, with a SYNTAX of @code{"."} (meaning punctuation syntax).
3099 Assuming that the buffer syntax table specifies hash characters to
3100 have comment start syntax, the element will only highlight hash
3101 characters that do not follow dollar characters as comments
3104 An element of the form:
3112 highlights syntactically both single quotes which surround a single
3113 character, with a SYNTAX of @code{"\""} (meaning string quote syntax).
3114 Assuming that the buffer syntax table does not specify single quotes
3115 to have quote syntax, the element will only highlight single quotes of
3116 the form @samp{'@var{c}'} as strings syntactically. Other forms, such
3117 as @samp{foo'bar} or @samp{'fubar'}, will not be highlighted as
3120 Major modes normally set this variable with @var{other-vars} in
3121 @code{font-lock-defaults}.
3124 @node Multiline Font Lock
3125 @subsection Multiline Font Lock Constructs
3126 @cindex multiline font lock
3128 Normally, elements of @code{font-lock-keywords} should not match
3129 across multiple lines; that doesn't work reliably, because Font Lock
3130 usually scans just part of the buffer, and it can miss a multi-line
3131 construct that crosses the line boundary where the scan starts. (The
3132 scan normally starts at the beginning of a line.)
3134 Making elements that match multiline constructs work properly has
3135 two aspects: correct @emph{identification} and correct
3136 @emph{rehighlighting}. The first means that Font Lock finds all
3137 multiline constructs. The second means that Font Lock will correctly
3138 rehighlight all the relevant text when a multiline construct is
3139 changed---for example, if some of the text that was previously part of
3140 a multiline construct ceases to be part of it. The two aspects are
3141 closely related, and often getting one of them to work will appear to
3142 make the other also work. However, for reliable results you must
3143 attend explicitly to both aspects.
3145 There are three ways to ensure correct identification of multiline
3150 Add a function to @code{font-lock-extend-region-functions} that does
3151 the @emph{identification} and extends the scan so that the scanned
3152 text never starts or ends in the middle of a multiline construct.
3154 Use the @code{font-lock-fontify-region-function} hook similarly to
3155 extend the scan so that the scanned text never starts or ends in the
3156 middle of a multiline construct.
3158 Somehow identify the multiline construct right when it gets inserted
3159 into the buffer (or at any point after that but before font-lock
3160 tries to highlight it), and mark it with a @code{font-lock-multiline}
3161 which will instruct font-lock not to start or end the scan in the
3162 middle of the construct.
3165 There are three ways to do rehighlighting of multiline constructs:
3169 Place a @code{font-lock-multiline} property on the construct. This
3170 will rehighlight the whole construct if any part of it is changed. In
3171 some cases you can do this automatically by setting the
3172 @code{font-lock-multiline} variable, which see.
3174 Make sure @code{jit-lock-contextually} is set and rely on it doing its
3175 job. This will only rehighlight the part of the construct that
3176 follows the actual change, and will do it after a short delay.
3177 This only works if the highlighting of the various parts of your
3178 multiline construct never depends on text in subsequent lines.
3179 Since @code{jit-lock-contextually} is activated by default, this can
3180 be an attractive solution.
3182 Place a @code{jit-lock-defer-multiline} property on the construct.
3183 This works only if @code{jit-lock-contextually} is used, and with the
3184 same delay before rehighlighting, but like @code{font-lock-multiline},
3185 it also handles the case where highlighting depends on
3190 * Font Lock Multiline:: Marking multiline chunks with a text property.
3191 * Region to Refontify:: Controlling which region gets refontified
3192 after a buffer change.
3195 @node Font Lock Multiline
3196 @subsubsection Font Lock Multiline
3198 One way to ensure reliable rehighlighting of multiline Font Lock
3199 constructs is to put on them the text property @code{font-lock-multiline}.
3200 It should be present and non-@code{nil} for text that is part of a
3201 multiline construct.
3203 When Font Lock is about to highlight a range of text, it first
3204 extends the boundaries of the range as necessary so that they do not
3205 fall within text marked with the @code{font-lock-multiline} property.
3206 Then it removes any @code{font-lock-multiline} properties from the
3207 range, and highlights it. The highlighting specification (mostly
3208 @code{font-lock-keywords}) must reinstall this property each time,
3209 whenever it is appropriate.
3211 @strong{Warning:} don't use the @code{font-lock-multiline} property
3212 on large ranges of text, because that will make rehighlighting slow.
3214 @defvar font-lock-multiline
3215 If the @code{font-lock-multiline} variable is set to @code{t}, Font
3216 Lock will try to add the @code{font-lock-multiline} property
3217 automatically on multiline constructs. This is not a universal
3218 solution, however, since it slows down Font Lock somewhat. It can
3219 miss some multiline constructs, or make the property larger or smaller
3222 For elements whose @var{matcher} is a function, the function should
3223 ensure that submatch 0 covers the whole relevant multiline construct,
3224 even if only a small subpart will be highlighted. It is often just as
3225 easy to add the @code{font-lock-multiline} property by hand.
3228 The @code{font-lock-multiline} property is meant to ensure proper
3229 refontification; it does not automatically identify new multiline
3230 constructs. Identifying the requires that Font-Lock operate on large
3231 enough chunks at a time. This will happen by accident on many cases,
3232 which may give the impression that multiline constructs magically work.
3233 If you set the @code{font-lock-multiline} variable non-@code{nil},
3234 this impression will be even stronger, since the highlighting of those
3235 constructs which are found will be properly updated from then on.
3236 But that does not work reliably.
3238 To find multiline constructs reliably, you must either manually
3239 place the @code{font-lock-multiline} property on the text before
3240 Font-Lock looks at it, or use
3241 @code{font-lock-fontify-region-function}.
3243 @node Region to Refontify
3244 @subsubsection Region to Fontify after a Buffer Change
3246 When a buffer is changed, the region that Font Lock refontifies is
3247 by default the smallest sequence of whole lines that spans the change.
3248 While this works well most of the time, sometimes it doesn't---for
3249 example, when a change alters the syntactic meaning of text on an
3252 You can enlarge (or even reduce) the region to refontify by setting
3253 the following variable:
3255 @defvar font-lock-extend-after-change-region-function
3256 This buffer-local variable is either @code{nil} or a function for
3257 Font-Lock to call to determine the region to scan and fontify.
3259 The function is given three parameters, the standard @var{beg},
3260 @var{end}, and @var{old-len} from @code{after-change-functions}
3261 (@pxref{Change Hooks}). It should return either a cons of the
3262 beginning and end buffer positions (in that order) of the region to
3263 fontify, or @code{nil} (which means choose the region in the standard
3264 way). This function needs to preserve point, the match-data, and the
3265 current restriction. The region it returns may start or end in the
3268 Since this function is called after every buffer change, it should be
3272 @node Auto-Indentation
3273 @section Auto-indentation of code
3275 For programming languages, an important feature of a major mode is to
3276 provide automatic indentation. This is controlled in Emacs by
3277 @code{indent-line-function} (@pxref{Mode-Specific Indent}).
3278 Writing a good indentation function can be difficult and to a large
3279 extent it is still a black art.
3281 Many major mode authors will start by writing a simple indentation
3282 function that works for simple cases, for example by comparing with the
3283 indentation of the previous text line. For most programming languages
3284 that are not really line-based, this tends to scale very poorly:
3285 improving such a function to let it handle more diverse situations tends
3286 to become more and more difficult, resulting in the end with a large,
3287 complex, unmaintainable indentation function which nobody dares to touch.
3289 A good indentation function will usually need to actually parse the
3290 text, according to the syntax of the language. Luckily, it is not
3291 necessary to parse the text in as much detail as would be needed
3292 for a compiler, but on the other hand, the parser embedded in the
3293 indentation code will want to be somewhat friendly to syntactically
3296 Good maintainable indentation functions usually fall into 2 categories:
3297 either parsing forward from some ``safe'' starting point until the
3298 position of interest, or parsing backward from the position of interest.
3299 Neither of the two is a clearly better choice than the other: parsing
3300 backward is often more difficult than parsing forward because
3301 programming languages are designed to be parsed forward, but for the
3302 purpose of indentation it has the advantage of not needing to
3303 guess a ``safe'' starting point, and it generally enjoys the property
3304 that only a minimum of text will be analyzed to decide the indentation
3305 of a line, so indentation will tend to be unaffected by syntax errors in
3306 some earlier unrelated piece of code. Parsing forward on the other hand
3307 is usually easier and has the advantage of making it possible to
3308 reindent efficiently a whole region at a time, with a single parse.
3310 Rather than write your own indentation function from scratch, it is
3311 often preferable to try and reuse some existing ones or to rely
3312 on a generic indentation engine. There are sadly few such
3313 engines. The CC-mode indentation code (used with C, C++, Java, Awk
3314 and a few other such modes) has been made more generic over the years,
3315 so if your language seems somewhat similar to one of those languages,
3316 you might try to use that engine. @c FIXME: documentation?
3317 Another one is SMIE which takes an approach in the spirit
3318 of Lisp sexps and adapts it to non-Lisp languages.
3321 * SMIE:: A simple minded indentation engine
3325 @subsection Simple Minded Indentation Engine
3327 SMIE is a package that provides a generic navigation and indentation
3328 engine. Based on a very simple parser using an ``operator precedence
3329 grammar'', it lets major modes extend the sexp-based navigation of Lisp
3330 to non-Lisp languages as well as provide a simple to use but reliable
3333 Operator precedence grammar is a very primitive technology for parsing
3334 compared to some of the more common techniques used in compilers.
3335 It has the following characteristics: its parsing power is very limited,
3336 and it is largely unable to detect syntax errors, but it has the
3337 advantage of being algorithmically efficient and able to parse forward
3338 just as well as backward. In practice that means that SMIE can use it
3339 for indentation based on backward parsing, that it can provide both
3340 @code{forward-sexp} and @code{backward-sexp} functionality, and that it
3341 will naturally work on syntactically incorrect code without any extra
3342 effort. The downside is that it also means that most programming
3343 languages cannot be parsed correctly using SMIE, at least not without
3344 resorting to some special tricks (@pxref{SMIE Tricks}).
3347 * SMIE setup:: SMIE setup and features
3348 * Operator Precedence Grammars:: A very simple parsing technique
3349 * SMIE Grammar:: Defining the grammar of a language
3350 * SMIE Lexer:: Defining tokens
3351 * SMIE Tricks:: Working around the parser's limitations
3352 * SMIE Indentation:: Specifying indentation rules
3353 * SMIE Indentation Helpers:: Helper functions for indentation rules
3354 * SMIE Indentation Example:: Sample indentation rules
3358 @subsubsection SMIE Setup and Features
3360 SMIE is meant to be a one-stop shop for structural navigation and
3361 various other features which rely on the syntactic structure of code, in
3362 particular automatic indentation. The main entry point is
3363 @code{smie-setup} which is a function typically called while setting
3366 @defun smie-setup grammar rules-function &rest keywords
3367 Setup SMIE navigation and indentation.
3368 @var{grammar} is a grammar table generated by @code{smie-prec2->grammar}.
3369 @var{rules-function} is a set of indentation rules for use on
3370 @code{smie-rules-function}.
3371 @var{keywords} are additional arguments, which can include the following
3375 @code{:forward-token} @var{fun}: Specify the forward lexer to use.
3377 @code{:backward-token} @var{fun}: Specify the backward lexer to use.
3381 Calling this function is sufficient to make commands such as
3382 @code{forward-sexp}, @code{backward-sexp}, and @code{transpose-sexps} be
3383 able to properly handle structural elements other than just the paired
3384 parentheses already handled by syntax tables. For example, if the
3385 provided grammar is precise enough, @code{transpose-sexps} can correctly
3386 transpose the two arguments of a @code{+} operator, taking into account
3387 the precedence rules of the language.
3389 Calling `smie-setup' is also sufficient to make TAB indentation work in
3390 the expected way, extends @code{blink-matching-paren} to apply to
3391 elements like @code{begin...end}, and provides some commands that you
3392 can bind in the major mode keymap.
3394 @deffn Command smie-close-block
3395 This command closes the most recently opened (and not yet closed) block.
3398 @deffn Command smie-down-list &optional arg
3399 This command is like @code{down-list} but it also pays attention to
3400 nesting of tokens other than parentheses, such as @code{begin...end}.
3403 @node Operator Precedence Grammars
3404 @subsubsection Operator Precedence Grammars
3406 SMIE's precedence grammars simply give to each token a pair of
3407 precedences: the left-precedence and the right-precedence. We say
3408 @code{T1 < T2} if the right-precedence of token @code{T1} is less than
3409 the left-precedence of token @code{T2}. A good way to read this
3410 @code{<} is as a kind of parenthesis: if we find @code{... T1 something
3411 T2 ...} then that should be parsed as @code{... T1 (something T2 ...}
3412 rather than as @code{... T1 something) T2 ...}. The latter
3413 interpretation would be the case if we had @code{T1 > T2}. If we have
3414 @code{T1 = T2}, it means that token T2 follows token T1 in the same
3415 syntactic construction, so typically we have @code{"begin" = "end"}.
3416 Such pairs of precedences are sufficient to express left-associativity
3417 or right-associativity of infix operators, nesting of tokens like
3418 parentheses and many other cases.
3420 @c Let's leave this undocumented to leave it more open for change!
3421 @c @defvar smie-grammar
3422 @c The value of this variable is an alist specifying the left and right
3423 @c precedence of each token. It is meant to be initialized by using one of
3424 @c the functions below.
3427 @defun smie-prec2->grammar table
3428 This function takes a @emph{prec2} grammar @var{table} and returns an
3429 alist suitable for use in @code{smie-setup}. The @emph{prec2}
3430 @var{table} is itself meant to be built by one of the functions below.
3433 @defun smie-merge-prec2s &rest tables
3434 This function takes several @emph{prec2} @var{tables} and merges them
3435 into a new @emph{prec2} table.
3438 @defun smie-precs->prec2 precs
3439 This function builds a @emph{prec2} table from a table of precedences
3440 @var{precs}. @var{precs} should be a list, sorted by precedence (for
3441 example @code{"+"} will come before @code{"*"}), of elements of the form
3442 @code{(@var{assoc} @var{op} ...)}, where each @var{op} is a token that
3443 acts as an operator; @var{assoc} is their associativity, which can be
3444 either @code{left}, @code{right}, @code{assoc}, or @code{nonassoc}.
3445 All operators in a given element share the same precedence level
3449 @defun smie-bnf->prec2 bnf &rest resolvers
3450 This function lets you specify the grammar using a BNF notation.
3451 It accepts a @var{bnf} description of the grammar along with a set of
3452 conflict resolution rules @var{resolvers}, and
3453 returns a @emph{prec2} table.
3455 @var{bnf} is a list of nonterminal definitions of the form
3456 @code{(@var{nonterm} @var{rhs1} @var{rhs2} ...)} where each @var{rhs}
3457 is a (non-empty) list of terminals (aka tokens) or non-terminals.
3459 Not all grammars are accepted:
3462 An @var{rhs} cannot be an empty list (an empty list is never needed,
3463 since SMIE allows all non-terminals to match the empty string anyway).
3465 An @var{rhs} cannot have 2 consecutive non-terminals: each pair of
3466 non-terminals needs to be separated by a terminal (aka token).
3467 This is a fundamental limitation of operator precedence grammars.
3470 Additionally, conflicts can occur:
3473 The returned @emph{prec2} table holds constraints between pairs of tokens, and
3474 for any given pair only one constraint can be present: T1 < T2,
3475 T1 = T2, or T1 > T2.
3477 A token can be an @code{opener} (something similar to an open-paren),
3478 a @code{closer} (like a close-paren), or @code{neither} of the two
3479 (e.g. an infix operator, or an inner token like @code{"else"}).
3482 Precedence conflicts can be resolved via @var{resolvers}, which
3483 is a list of @emph{precs} tables (see @code{smie-precs->prec2}): for
3484 each precedence conflict, if those @code{precs} tables
3485 specify a particular constraint, then the conflict is resolved by using
3486 this constraint instead, else a conflict is reported and one of the
3487 conflicting constraints is picked arbitrarily and the others are
3492 @subsubsection Defining the Grammar of a Language
3494 The usual way to define the SMIE grammar of a language is by
3495 defining a new global variable that holds the precedence table by
3496 giving a set of BNF rules.
3497 For example, the grammar definition for a small Pascal-like language
3502 (defvar sample-smie-grammar
3503 (smie-prec2->grammar
3508 (inst ("begin" insts "end")
3509 ("if" exp "then" inst "else" inst)
3512 (insts (insts ";" insts) (inst))
3516 (exps (exps "," exps) (exp)))
3521 '((assoc "+") (assoc "*")))))
3526 A few things to note:
3530 The above grammar does not explicitly mention the syntax of function
3531 calls: SMIE will automatically allow any sequence of sexps, such as
3532 identifiers, balanced parentheses, or @code{begin ... end} blocks
3533 to appear anywhere anyway.
3535 The grammar category @code{id} has no right hand side: this does not
3536 mean that it can match only the empty string, since as mentioned any
3537 sequence of sexps can appear anywhere anyway.
3539 Because non terminals cannot appear consecutively in the BNF grammar, it
3540 is difficult to correctly handle tokens that act as terminators, so the
3541 above grammar treats @code{";"} as a statement @emph{separator} instead,
3542 which SMIE can handle very well.
3544 Separators used in sequences (such as @code{","} and @code{";"} above)
3545 are best defined with BNF rules such as @code{(foo (foo "separator" foo) ...)}
3546 which generate precedence conflicts which are then resolved by giving
3547 them an explicit @code{(assoc "separator")}.
3549 The @code{("(" exps ")")} rule was not needed to pair up parens, since
3550 SMIE will pair up any characters that are marked as having paren syntax
3551 in the syntax table. What this rule does instead (together with the
3552 definition of @code{exps}) is to make it clear that @code{","} should
3553 not appear outside of parentheses.
3555 Rather than have a single @emph{precs} table to resolve conflicts, it is
3556 preferable to have several tables, so as to let the BNF part of the
3557 grammar specify relative precedences where possible.
3559 Unless there is a very good reason to prefer @code{left} or
3560 @code{right}, it is usually preferable to mark operators as associative,
3561 using @code{assoc}. For that reason @code{"+"} and @code{"*"} are
3562 defined above as @code{assoc}, although the language defines them
3563 formally as left associative.
3567 @subsubsection Defining Tokens
3569 SMIE comes with a predefined lexical analyzer which uses syntax tables
3570 in the following way: any sequence of characters that have word or
3571 symbol syntax is considered a token, and so is any sequence of
3572 characters that have punctuation syntax. This default lexer is
3573 often a good starting point but is rarely actually correct for any given
3574 language. For example, it will consider @code{"2,+3"} to be composed
3575 of 3 tokens: @code{"2"}, @code{",+"}, and @code{"3"}.
3577 To describe the lexing rules of your language to SMIE, you need
3578 2 functions, one to fetch the next token, and another to fetch the
3579 previous token. Those functions will usually first skip whitespace and
3580 comments and then look at the next chunk of text to see if it
3581 is a special token. If so it should skip the token and
3582 return a description of this token. Usually this is simply the string
3583 extracted from the buffer, but it can be anything you want.
3587 (defvar sample-keywords-regexp
3588 (regexp-opt '("+" "*" "," ";" ">" ">=" "<" "<=" ":=" "=")))
3591 (defun sample-smie-forward-token ()
3592 (forward-comment (point-max))
3594 ((looking-at sample-keywords-regexp)
3595 (goto-char (match-end 0))
3596 (match-string-no-properties 0))
3597 (t (buffer-substring-no-properties
3599 (progn (skip-syntax-forward "w_")
3603 (defun sample-smie-backward-token ()
3604 (forward-comment (- (point)))
3606 ((looking-back sample-keywords-regexp (- (point) 2) t)
3607 (goto-char (match-beginning 0))
3608 (match-string-no-properties 0))
3609 (t (buffer-substring-no-properties
3611 (progn (skip-syntax-backward "w_")
3616 Notice how those lexers return the empty string when in front of
3617 parentheses. This is because SMIE automatically takes care of the
3618 parentheses defined in the syntax table. More specifically if the lexer
3619 returns nil or an empty string, SMIE tries to handle the corresponding
3620 text as a sexp according to syntax tables.
3623 @subsubsection Living With a Weak Parser
3625 The parsing technique used by SMIE does not allow tokens to behave
3626 differently in different contexts. For most programming languages, this
3627 manifests itself by precedence conflicts when converting the
3630 Sometimes, those conflicts can be worked around by expressing the
3631 grammar slightly differently. For example, for Modula-2 it might seem
3632 natural to have a BNF grammar that looks like this:
3636 (inst ("IF" exp "THEN" insts "ELSE" insts "END")
3637 ("CASE" exp "OF" cases "END")
3639 (cases (cases "|" cases)
3640 (caselabel ":" insts)
3645 But this will create conflicts for @code{"ELSE"}: on the one hand, the
3646 IF rule implies (among many other things) that @code{"ELSE" = "END"};
3647 but on the other hand, since @code{"ELSE"} appears within @code{cases},
3648 which appears left of @code{"END"}, we also have @code{"ELSE" > "END"}.
3649 We can solve the conflict either by using:
3652 (inst ("IF" exp "THEN" insts "ELSE" insts "END")
3653 ("CASE" exp "OF" cases "END")
3654 ("CASE" exp "OF" cases "ELSE" insts "END")
3656 (cases (cases "|" cases) (caselabel ":" insts))
3662 (inst ("IF" exp "THEN" else "END")
3663 ("CASE" exp "OF" cases "END")
3665 (else (insts "ELSE" insts))
3666 (cases (cases "|" cases) (caselabel ":" insts) (else))
3670 Reworking the grammar to try and solve conflicts has its downsides, tho,
3671 because SMIE assumes that the grammar reflects the logical structure of
3672 the code, so it is preferable to keep the BNF closer to the intended
3673 abstract syntax tree.
3675 Other times, after careful consideration you may conclude that those
3676 conflicts are not serious and simply resolve them via the
3677 @var{resolvers} argument of @code{smie-bnf->prec2}. Usually this is
3678 because the grammar is simply ambiguous: the conflict does not affect
3679 the set of programs described by the grammar, but only the way those
3680 programs are parsed. This is typically the case for separators and
3681 associative infix operators, where you want to add a resolver like
3682 @code{'((assoc "|"))}. Another case where this can happen is for the
3683 classic @emph{dangling else} problem, where you will use @code{'((assoc
3684 "else" "then"))}. It can also happen for cases where the conflict is
3685 real and cannot really be resolved, but it is unlikely to pose a problem
3688 Finally, in many cases some conflicts will remain despite all efforts to
3689 restructure the grammar. Do not despair: while the parser cannot be
3690 made more clever, you can make the lexer as smart as you want. So, the
3691 solution is then to look at the tokens involved in the conflict and to
3692 split one of those tokens into 2 (or more) different tokens. E.g. if
3693 the grammar needs to distinguish between two incompatible uses of the
3694 token @code{"begin"}, make the lexer return different tokens (say
3695 @code{"begin-fun"} and @code{"begin-plain"}) depending on which kind of
3696 @code{"begin"} it finds. This pushes the work of distinguishing the
3697 different cases to the lexer, which will thus have to look at the
3698 surrounding text to find ad-hoc clues.
3700 @node SMIE Indentation
3701 @subsubsection Specifying Indentation Rules
3703 Based on the provided grammar, SMIE will be able to provide automatic
3704 indentation without any extra effort. But in practice, this default
3705 indentation style will probably not be good enough. You will want to
3706 tweak it in many different cases.
3708 SMIE indentation is based on the idea that indentation rules should be
3709 as local as possible. To this end, it relies on the idea of
3710 @emph{virtual} indentation, which is the indentation that a particular
3711 program point would have if it were at the beginning of a line.
3712 Of course, if that program point is indeed at the beginning of a line,
3713 its virtual indentation is its current indentation. But if not, then
3714 SMIE uses the indentation algorithm to compute the virtual indentation
3715 of that point. Now in practice, the virtual indentation of a program
3716 point does not have to be identical to the indentation it would have if
3717 we inserted a newline before it. To see how this works, the SMIE rule
3718 for indentation after a @code{@{} in C does not care whether the
3719 @code{@{} is standing on a line of its own or is at the end of the
3720 preceding line. Instead, these different cases are handled in the
3721 indentation rule that decides how to indent before a @code{@{}.
3723 Another important concept is the notion of @emph{parent}: The
3724 @emph{parent} of a token, is the head token of the nearest enclosing
3725 syntactic construct. For example, the parent of an @code{else} is the
3726 @code{if} to which it belongs, and the parent of an @code{if}, in turn,
3727 is the lead token of the surrounding construct. The command
3728 @code{backward-sexp} jumps from a token to its parent, but there are
3729 some caveats: for @emph{openers} (tokens which start a construct, like
3730 @code{if}), you need to start with point before the token, while for
3731 others you need to start with point after the token.
3732 @code{backward-sexp} stops with point before the parent token if that is
3733 the @emph{opener} of the token of interest, and otherwise it stops with
3734 point after the parent token.
3736 SMIE indentation rules are specified using a function that takes two
3737 arguments @var{method} and @var{arg} where the meaning of @var{arg} and the
3738 expected return value depend on @var{method}.
3740 @var{method} can be:
3743 @code{:after}, in which case @var{arg} is a token and the function
3744 should return the @var{offset} to use for indentation after @var{arg}.
3746 @code{:before}, in which case @var{arg} is a token and the function
3747 should return the @var{offset} to use to indent @var{arg} itself.
3749 @code{:elem}, in which case the function should return either the offset
3750 to use to indent function arguments (if @var{arg} is the symbol
3751 @code{arg}) or the basic indentation step (if @var{arg} is the symbol
3754 @code{:list-intro}, in which case @var{arg} is a token and the function
3755 should return non-@code{nil} if the token is followed by a list of
3756 expressions (not separated by any token) rather than an expression.
3759 When @var{arg} is a token, the function is called with point just before
3760 that token. A return value of nil always means to fallback on the
3761 default behavior, so the function should return nil for arguments it
3764 @var{offset} can be:
3767 @code{nil}: use the default indentation rule.
3769 @code{(column . @var{column})}: indent to column @var{column}.
3771 @var{number}: offset by @var{number}, relative to a base token which is
3772 the current token for @code{:after} and its parent for @code{:before}.
3775 @node SMIE Indentation Helpers
3776 @subsubsection Helper Functions for Indentation Rules
3778 SMIE provides various functions designed specifically for use in the
3779 indentation rules function (several of those functions break if used in
3780 another context). These functions all start with the prefix
3783 @defun smie-rule-bolp
3784 Return non-@code{nil} if the current token is the first on the line.
3787 @defun smie-rule-hanging-p
3788 Return non-@code{nil} if the current token is @emph{hanging}.
3789 A token is @emph{hanging} if it is the last token on the line
3790 and if it is preceded by other tokens: a lone token on a line is not
3794 @defun smie-rule-next-p &rest tokens
3795 Return non-@code{nil} if the next token is among @var{tokens}.
3798 @defun smie-rule-prev-p &rest tokens
3799 Return non-@code{nil} if the previous token is among @var{tokens}.
3802 @defun smie-rule-parent-p &rest parents
3803 Return non-@code{nil} if the current token's parent is among @var{parents}.
3806 @defun smie-rule-sibling-p
3807 Return non-nil if the current token's parent is actually a sibling.
3808 This is the case for example when the parent of a @code{","} is just the
3809 previous @code{","}.
3812 @defun smie-rule-parent &optional offset
3813 Return the proper offset to align the current token with the parent.
3814 If non-@code{nil}, @var{offset} should be an integer giving an
3815 additional offset to apply.
3818 @defun smie-rule-separator method
3819 Indent current token as a @emph{separator}.
3821 By @emph{separator}, we mean here a token whose sole purpose is to
3822 separate various elements within some enclosing syntactic construct, and
3823 which does not have any semantic significance in itself (i.e. it would
3824 typically not exist as a node in an abstract syntax tree).
3826 Such a token is expected to have an associative syntax and be closely
3827 tied to its syntactic parent. Typical examples are @code{","} in lists
3828 of arguments (enclosed inside parentheses), or @code{";"} in sequences
3829 of instructions (enclosed in a @code{@{...@}} or @code{begin...end}
3832 @var{method} should be the method name that was passed to
3833 `smie-rules-function'.
3836 @node SMIE Indentation Example
3837 @subsubsection Sample Indentation Rules
3839 Here is an example of an indentation function:
3842 (defun sample-smie-rules (kind token)
3843 (pcase (cons kind token)
3844 (`(:elem . basic) sample-indent-basic)
3845 (`(,_ . ",") (smie-rule-separator kind))
3846 (`(:after . ":=") sample-indent-basic)
3847 (`(:before . ,(or `"begin" `"(" `"@{")))
3848 (if (smie-rule-hanging-p) (smie-rule-parent)))
3850 (and (not (smie-rule-bolp)) (smie-rule-prev-p "else")
3851 (smie-rule-parent)))))
3855 A few things to note:
3859 The first case indicates the basic indentation increment to use.
3860 If @code{sample-indent-basic} is nil, then SMIE uses the global
3861 setting @code{smie-indent-basic}. The major mode could have set
3862 @code{smie-indent-basic} buffer-locally instead, but that
3866 The rule for the token @code{","} make SMIE try to be more clever when
3867 the comma separator is placed at the beginning of lines. It tries to
3868 outdent the separator so as to align the code after the comma; for
3872 x = longfunctionname (
3879 The rule for indentation after @code{":="} exists because otherwise
3880 SMIE would treat @code{":="} as an infix operator and would align the
3881 right argument with the left one.
3884 The rule for indentation before @code{"begin"} is an example of the use
3885 of virtual indentation: This rule is used only when @code{"begin"} is
3886 hanging, which can happen only when @code{"begin"} is not at the
3887 beginning of a line. So this is not used when indenting
3888 @code{"begin"} itself but only when indenting something relative to this
3889 @code{"begin"}. Concretely, this rule changes the indentation from:
3904 The rule for indentation before @code{"if"} is similar to the one for
3905 @code{"begin"}, but where the purpose is to treat @code{"else if"}
3906 as a single unit, so as to align a sequence of tests rather than indent
3907 each test further to the right. This function does this only in the
3908 case where the @code{"if"} is not placed on a separate line, hence the
3909 @code{smie-rule-bolp} test.
3911 If we know that the @code{"else"} is always aligned with its @code{"if"}
3912 and is always at the beginning of a line, we can use a more efficient
3916 (and (not (smie-rule-bolp))
3917 (smie-rule-prev-p "else")
3919 (sample-smie-backward-token)
3920 (cons 'column (current-column)))))
3923 The advantage of this formulation is that it reuses the indentation of
3924 the previous @code{"else"}, rather than going all the way back to the
3925 first @code{"if"} of the sequence.
3928 @node Desktop Save Mode
3929 @section Desktop Save Mode
3930 @cindex desktop save mode
3932 @dfn{Desktop Save Mode} is a feature to save the state of Emacs from
3933 one session to another. The user-level commands for using Desktop
3934 Save Mode are described in the GNU Emacs Manual (@pxref{Saving Emacs
3935 Sessions,,, emacs, the GNU Emacs Manual}). Modes whose buffers visit
3936 a file, don't have to do anything to use this feature.
3938 For buffers not visiting a file to have their state saved, the major
3939 mode must bind the buffer local variable @code{desktop-save-buffer} to
3940 a non-@code{nil} value.
3942 @defvar desktop-save-buffer
3943 If this buffer-local variable is non-@code{nil}, the buffer will have
3944 its state saved in the desktop file at desktop save. If the value is
3945 a function, it is called at desktop save with argument
3946 @var{desktop-dirname}, and its value is saved in the desktop file along
3947 with the state of the buffer for which it was called. When file names
3948 are returned as part of the auxiliary information, they should be
3949 formatted using the call
3952 (desktop-file-name @var{file-name} @var{desktop-dirname})
3957 For buffers not visiting a file to be restored, the major mode must
3958 define a function to do the job, and that function must be listed in
3959 the alist @code{desktop-buffer-mode-handlers}.
3961 @defvar desktop-buffer-mode-handlers
3965 (@var{major-mode} . @var{restore-buffer-function})
3968 The function @var{restore-buffer-function} will be called with
3972 (@var{buffer-file-name} @var{buffer-name} @var{desktop-buffer-misc})
3975 and it should return the restored buffer.
3976 Here @var{desktop-buffer-misc} is the value returned by the function
3977 optionally bound to @code{desktop-save-buffer}.