@c This is part of the Emacs manual.
@c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001,
-@c 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+@c 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Customization, Quitting, Amusements, Top
@chapter Customization
@cindex customization
This chapter talks about various topics relevant to adapting the
-behavior of Emacs in minor ways.
+behavior of Emacs in ways we have anticipated.
@iftex
See @cite{The Emacs Lisp Reference Manual}
@end iftex
@xref{Top, Emacs Lisp, Emacs Lisp, elisp, The Emacs Lisp
Reference Manual},
@end ifnottex
-for how to make more far-reaching changes. @xref{X Resources},
-for information on using X resources to customize Emacs.
+for how to make more far-reaching and open-ended changes. @xref{X
+Resources}, for information on using X resources to customize Emacs.
Customization that you do within Emacs normally affects only the
particular Emacs session that you do it in---it does not persist
between sessions unless you save the customization in a file such as
-@file{.emacs} or @file{.Xdefaults} that will affect future sessions.
-@xref{Init File}. In the customization buffer, when you save
+your init file (@file{.emacs}) that will affect future sessions.
+(@xref{Init File}.) When you tell the customization buffer to save
customizations for future sessions, this actually works by editing
@file{.emacs} for you.
@menu
* Minor Modes:: Each minor mode is one feature you can turn on
independently of any others.
-* Easy Customization:: Convenient way to browse and change user options.
+* Easy Customization:: Convenient way to browse and change settings.
* Variables:: Many Emacs commands examine Emacs variables
to decide what to do; by setting variables,
you can control their functioning.
example, Auto Fill mode is a minor mode in which @key{SPC} breaks lines
between words as you type. All the minor modes are independent of each
other and of the selected major mode. Most minor modes say in the mode
-line when they are on; for example, @samp{Fill} in the mode line means
-that Auto Fill mode is on.
-
- Append @code{-mode} to the name of a minor mode to get the name of a
-command that turns the mode on or off. Thus, the command to
-enable or disable Auto Fill mode is called @code{auto-fill-mode}. These
-commands are usually invoked with @kbd{M-x}, but you can bind keys to them
-if you wish. With no argument, the function turns the mode on if it was
-off and off if it was on. This is known as @dfn{toggling}. A positive
-argument always turns the mode on, and an explicit zero argument or a
-negative argument always turns it off.
+line when they are enabled; for example, @samp{Fill} in the mode line means
+that Auto Fill mode is enabled.
+
+ You should append @code{-mode} to the name of a minor mode to
+produce the name of the command that turns the mode on or off. Thus,
+the command to enable or disable Auto Fill mode is called
+@code{auto-fill-mode}. These commands are usually invoked with
+@kbd{M-x}, but you can bind keys to them if you wish.
+
+ With no argument, the minor mode function turns the mode on if it
+was off, and off if it was on. This is known as @dfn{toggling}. A
+positive argument always turns the mode on, and an explicit zero
+argument or a negative argument always turns it off.
Some minor modes are global: while enabled, they affect everything
you do in the Emacs session, in all buffers. Other minor modes are
not want the same minor modes you prefer.
The most useful buffer-local minor modes include Abbrev mode, Auto
-Fill mode, Auto Save mode, Font-Lock mode, Glasses mode, ISO Accents
-mode, Outline minor mode, Overwrite mode, and Binary Overwrite mode.
+Fill mode, Auto Save mode, Font-Lock mode, Glasses mode, Outline minor
+mode, Overwrite mode, and Binary Overwrite mode.
Abbrev mode allows you to define abbreviations that automatically expand
as you type them. For example, @samp{amd} might expand to @samp{abbrev
explicitly. Emacs inserts newlines as necessary to prevent lines from
becoming too long. @xref{Filling}.
- Auto Save mode causes the contents of a buffer to be saved
-periodically to reduce the amount of work you can lose in case of a
-system crash. @xref{Auto Save}.
+ Auto Save mode saves the buffer contents periodically to reduce the
+amount of work you can lose in case of a crash. @xref{Auto Save}.
Enriched mode enables editing and saving of formatted text.
@xref{Formatted Text}.
Flyspell mode automatically highlights misspelled words.
@xref{Spelling}.
- Font-Lock mode automatically highlights certain textual units found in
-programs, such as comments, strings, and function names being defined.
-This requires a window system that can display multiple fonts.
-@xref{Faces}.
+ Font-Lock mode automatically highlights certain textual units found
+in programs, such as comments, strings, and function names being
+defined. This requires a display that can show multiple fonts or
+colors. @xref{Faces}.
+@ignore
ISO Accents mode makes the characters @samp{`}, @samp{'}, @samp{"},
@samp{^}, @samp{/} and @samp{~} combine with the following letter, to
produce an accented letter in the ISO Latin-1 character set. The
newer and more general feature of input methods more or less
-supersedes ISO Accents mode. @xref{Single-Byte Character Support}.
+supersedes ISO Accents mode. @xref{Unibyte Mode}.
+@end ignore
Outline minor mode provides the same facilities as the major mode
called Outline mode; but since it is a minor mode instead, you can
@node Easy Customization
@section Easy Customization Interface
-@cindex user option
- Emacs has many @dfn{user options} which have values that you can set
-in order to customize various commands. Many user options are
-documented in this manual. Most user options are actually Lisp
-variables (@pxref{Variables}), so their names appear in the Variable
-Index (@pxref{Variable Index}). The rest are faces and their
-attributes (@pxref{Faces}).
+@cindex settings
+ Emacs has many @dfn{settings} which have values that you can specify
+in order to customize various commands. Many are documented in this
+manual. Most settings are @dfn{user options}---that is to say, Lisp
+variables (@pxref{Variables})---so their names appear in the Variable
+Index (@pxref{Variable Index}). The other settings are faces and
+their attributes (@pxref{Faces}).
@findex customize
@cindex customization buffer
- You can browse interactively through the user options and change
-some of them using @kbd{M-x customize}. This command creates a
-@dfn{customization buffer}, which offers commands to navigate through
-a logically organized structure of the Emacs user options; you can
-also use it to edit and set their values, and to save settings
-permanently in your @file{~/.emacs} file (@pxref{Init File}).
+ You can browse interactively through settings and change them using
+@kbd{M-x customize}. This command creates a @dfn{customization
+buffer}, which offers commands to navigate through a logically
+organized structure of the Emacs settings; you can also use it to edit
+and set their values, and to save settings permanently in your
+@file{~/.emacs} file (@pxref{Init File}).
The appearance of the example buffers in this section is typically
-different under a window system, since faces are then used to indicate
-the active fields and other features.
+different under a graphical display, since faces are then used to indicate
+buttons, links and editable fields.
@menu
-* Groups: Customization Groups. How options are classified in a structure.
-* Changing a Variable:: How to edit a value and set an option.
-* Saving Customizations:: Details of saving customizations.
+* Groups: Customization Groups. How settings are classified in a structure.
+* Browsing: Browsing Custom. Browsing and searching for settings.
+* Changing a Variable:: How to edit an option's value and set the option.
+* Saving Customizations:: Specifying the file for saving customizations.
* Face Customization:: How to edit the attributes of a face.
* Specific Customization:: Making a customization buffer for specific
variables, faces, or groups.
@subsection Customization Groups
@cindex customization groups
- For customization purposes, user options are organized into
-@dfn{groups} to help you find them. Groups are collected into bigger
-groups, all the way up to a master group called @code{Emacs}.
+ For customization purposes, settings are organized into @dfn{groups}
+to help you find them. Groups are collected into bigger groups, all
+the way up to a master group called @code{Emacs}.
@kbd{M-x customize} creates a customization buffer that shows the
top-level @code{Emacs} group and the second-level groups immediately
@smallexample
/- Emacs group: ---------------------------------------------------\
- [State]: visible group members are all at standard settings.
+ [State]: visible group members are all at standard values.
Customization of the One True Editor.
See also [Manual].
line.
@cindex editable fields (customization buffer)
-@cindex active fields (customization buffer)
+@cindex buttons (customization buffer)
+@cindex links (customization buffer)
Most of the text in the customization buffer is read-only, but it
-typically includes some @dfn{editable fields} that you can edit. There
-are also @dfn{active fields}; this means a field that does something
-when you @dfn{invoke} it. To invoke an active field, either click on it
-with @kbd{Mouse-1}, or move point to it and type @key{RET}.
-
- For example, the phrase @samp{[Go to Group]} that appears in a
-second-level group is an active field. Invoking the @samp{[Go to
-Group]} field for a group creates a new customization buffer, which
-shows that group and its contents. This field is a kind of hypertext
-link to another group.
-
- The @code{Emacs} group includes a few user options itself, but
-mainly it contains other groups, which contain more groups, which
-contain the user options. By browsing the hierarchy of groups, you
-will eventually find the feature you are interested in customizing.
-Then you can use the customization buffer to set the options
-pertaining to that feature. You can also go straight to a particular
-group by name, using the command @kbd{M-x customize-group}.
-
+typically includes some @dfn{editable fields} that you can edit.
+There are also @dfn{buttons} and @dfn{links}, which do something when
+you @dfn{invoke} them. To invoke a button or a link, either click on
+it with @kbd{Mouse-1}, or move point to it and type @key{RET}.
+
+ For example, the phrase @samp{[State]} that appears in
+a second-level group is a button. It operates on the same
+customization buffer. The phrase @samp{[Go to Group]} is a kind
+of hypertext link to another group. Invoking it creates a new
+customization buffer, which shows that group and its contents.
+
+ The @code{Emacs} group includes a few settings, but mainly it
+contains other groups, which contain more groups, which contain the
+settings. By browsing the hierarchy of groups, you will eventually
+find the feature you are interested in customizing. Then you can use
+the customization buffer to set that feature's settings. You can also
+go straight to a particular group by name, using the command @kbd{M-x
+customize-group}.
+
+@node Browsing Custom
+@subsection Browsing and Searching for Options and Faces
@findex customize-browse
- You can view the structure of customization groups on a larger scale
-with @kbd{M-x customize-browse}. This command creates a special kind of
-customization buffer which shows only the names of the groups (and
-variables and faces), and their structure.
- In this buffer, you can show the contents of a group by invoking
-@samp{[+]}. When the group contents are visible, this button changes to
-@samp{[-]}; invoking that hides the group contents.
+ @kbd{M-x customize-browse} is another way to browse the available
+settings. This command creates a special customization buffer which
+shows only the names of groups and settings, and puts them in a
+structure.
- Each group, variable, or face name in this buffer has an active field
-which says @samp{[Group]}, @samp{[Option]} or @samp{[Face]}. Invoking
-that active field creates an ordinary customization buffer showing just
-that group and its contents, just that variable, or just that face.
-This is the way to set values in it.
+ In this buffer, you can show the contents of a group by invoking the
+@samp{[+]} button. When the group contents are visible, this button
+changes to @samp{[-]}; invoking that hides the group contents again.
+
+ Each group or setting in this buffer has a link which says
+@samp{[Group]}, @samp{[Option]} or @samp{[Face]}. Invoking this link
+creates an ordinary customization buffer showing just that group and
+its contents, just that user option, or just that face. This is the
+way to change settings that you find with @kbd{M-x customize-browse}.
+
+ If you can guess part of the name of the settings you are interested
+in, @kbd{M-x customize-apropos} is another way to search for settings.
+However, unlike @code{customize} and @code{customize-browse},
+@code{customize-apropos} can only find groups and settings that are
+loaded in the current Emacs session. @xref{Specific Customization,,
+Customizing Specific Items}.
@node Changing a Variable
@subsection Changing a Variable
- Here is an example of what a variable looks like in the
-customization buffer:
+ Here is an example of what a variable (a user option) looks like in
+the customization buffer:
@smallexample
Kill Ring Max: [Hide Value] 60
buffer initially hides values that take up several lines. Invoke
@samp{[Show Value]} to show the value.
- The line after the option name indicates the @dfn{customization state}
-of the variable: in the example above, it says you have not changed the
-option yet. The word @samp{[State]} at the beginning of this line is
-active; you can get a menu of various operations by invoking it with
-@kbd{Mouse-1} or @key{RET}. These operations are essential for
-customizing the variable.
+ The line after the variable name indicates the @dfn{customization
+state} of the variable: in the example above, it says you have not
+changed the option yet. The @samp{[State]} button at the beginning of
+this line gives you a menu of various operations for customizing the
+variable.
The line after the @samp{[State]} line displays the beginning of the
variable's documentation string. If there are more lines of
-documentation, this line ends with @samp{[More]}; invoke this to show
-the full documentation string.
-
- To enter a new value for @samp{Kill Ring Max}, move point to the value
-and edit it textually. For example, you can type @kbd{M-d}, then insert
-another number.
+documentation, this line ends with a @samp{[More]} button; invoke that
+to show the full documentation string.
- When you begin to alter the text, you will see the @samp{[State]} line
-change to say that you have edited the value:
+ To enter a new value for @samp{Kill Ring Max}, move point to the
+value and edit it textually. For example, you can type @kbd{M-d},
+then insert another number. As you begin to alter the text, you will
+see the @samp{[State]} line change to say that you have edited the
+value:
@smallexample
[State]: EDITED, shown value does not take effect until you set or @r{@dots{}}
save it.
@end smallexample
-@cindex setting option value
- Editing the value does not actually set the variable. To do
-that, you must @dfn{set} it. To do this, invoke the word
-@samp{[State]} and choose @samp{Set for Current Session}.
+@cindex user options, how to set
+@cindex variables, how to set
+@cindex settings, how to set
+ Editing the value does not actually set the variable. To do that,
+you must @dfn{set} the variable. To do this, invoke the
+@samp{[State]} button and choose @samp{Set for Current Session}.
The state of the variable changes visibly when you set it:
@end smallexample
You don't have to worry about specifying a value that is not valid;
-setting the variable checks for validity and will not really install an
-unacceptable value.
+the @samp{Set for Current Session} operation checks for validity and
+will not install an unacceptable value.
@kindex M-TAB @r{(customization buffer)}
@findex widget-complete
- While editing a value or field that is a file name, directory name,
+ While editing a field that is a file name, directory name,
command name, or anything else for which completion is defined, you
can type @kbd{M-@key{TAB}} (@code{widget-complete}) to do completion.
(@kbd{@key{ESC} @key{TAB}} and @kbd{C-M-i} do the same thing.)
Some variables have a small fixed set of possible legitimate values.
-These variables don't let you edit the value textually. Instead, an
-active field @samp{[Value Menu]} appears before the value; invoke this
-field to edit the value. For a boolean ``on or off'' value, the active
-field says @samp{[Toggle]}, and it changes to the other value.
-@samp{[Value Menu]} and @samp{[Toggle]} edit the buffer; the changes
-take effect when you use the @samp{Set for Current Session} operation.
+These variables don't let you edit the value textually. Instead, a
+@samp{[Value Menu]} button appears before the value; invoke this
+button to change the value. For a boolean ``on or off'' value, the
+button says @samp{[Toggle]}, and it changes to the other value.
+@samp{[Value Menu]} and @samp{[Toggle]} simply edit the buffer; the
+changes take real effect when you use the @samp{Set for Current
+Session} operation.
Some variables have values with complex structure. For example, the
value of @code{file-coding-system-alist} is an association list. Here
@noindent
Each association in the list appears on four lines, with several
-editable or ``active'' fields. You can edit the regexps and coding
+editable fields and/or buttons. You can edit the regexps and coding
systems using ordinary editing commands. You can also invoke
-@samp{[Value Menu]} to switch to a kind of value---for instance, to
-specify a function instead of a pair of coding systems.
+@samp{[Value Menu]} to switch to a different kind of value---for
+instance, to specify a function instead of a pair of coding systems.
To delete an association from the list, invoke the @samp{[DEL]} button
for that item. To add an association, invoke @samp{[INS]} at the
position where you want to add it. There is an @samp{[INS]} button
-between each pair of association, another at the beginning and another
-at the end, so you can add the new association at any position in the
+between each pair of associations, another at the beginning and another
+at the end, so you can add a new association at any position in the
list.
@kindex TAB @r{(customization buffer)}
@kindex S-TAB @r{(customization buffer)}
@findex widget-forward
@findex widget-backward
- Two special commands, @key{TAB} and @kbd{S-@key{TAB}}, are useful for
-moving through the customization buffer. @key{TAB}
-(@code{widget-forward}) moves forward to the next active or editable
-field; @kbd{S-@key{TAB}} (@code{widget-backward}) moves backward to the
-previous active or editable field.
+ Two special commands, @key{TAB} and @kbd{S-@key{TAB}}, are useful
+for moving through the customization buffer. @key{TAB}
+(@code{widget-forward}) moves forward to the next button or editable
+field; @kbd{S-@key{TAB}} (@code{widget-backward}) moves backward to
+the previous button or editable field.
Typing @key{RET} on an editable field also moves forward, just like
@key{TAB}. We set it up this way because people often type @key{RET}
when they are finished editing a field. To insert a newline within an
editable field, use @kbd{C-o} or @kbd{C-q C-j}.
-@cindex saving variable value
-@cindex customized variables, saving
+@cindex saving a setting
+@cindex settings, how to save
Setting the variable changes its value in the current Emacs session;
@dfn{saving} the value changes it for future sessions as well. To
save the variable, invoke @samp{[State]} and select the @samp{Save for
There are actually four reset operations:
@table @samp
-@item Reset to Current
+@item Undo Edits
If you have made some modifications and not yet set the variable,
this restores the text in the customization buffer to match
the actual value.
@item Erase Customization
This sets the variable to its standard value, and updates the text
-accordingly. This also eliminates any saved value for the option,
+accordingly. This also eliminates any saved value for the variable,
so that you will get the standard value in future Emacs sessions.
-@item Use Backup Value
+@item Set to Backup Value
This sets the variable to a previous value that was set in the
customization buffer in this session. If you customize a variable
and then reset it, which discards the customized value,
you can get the customized value back again with this operation.
@end table
-@cindex comments on customized options
+@cindex comments on customized settings
Sometimes it is useful to record a comment about a specific
customization. Use the @samp{Add Comment} item from the
@samp{[State]} menu to create a field for entering the comment. The
The state of a group indicates whether anything in that group has been
edited, set or saved.
- Near the top of the customization buffer there are two lines
-containing several active fields:
+ Near the top of the customization buffer there are two lines of buttons:
@smallexample
[Set for Current Session] [Save for Future Sessions]
- [Reset to Current] [Reset to Saved] [Erase Customization] [Finish]
+ [Undo Edits] [Reset to Saved] [Erase Customization] [Finish]
@end smallexample
@vindex custom-buffer-done-function
Invoking @samp{[Finish]} either buries or kills this customization
buffer according to the setting of the option
@code{custom-buffer-done-kill}; the default is to bury the buffer.
-Each of the other fields performs an operation---set, save or
-reset---on each of the options in the buffer that could meaningfully
-be set, saved or reset. They do not operate on options whose values
-are hidden, nor on subgroups.
+Each of the other buttons performs an operation---set, save or
+reset---on each of the settings in the buffer that could meaningfully
+be set, saved or reset. They do not operate on settings whose values
+are hidden, nor on subgroups which are hidden or not visible in the buffer.
@node Saving Customizations
@subsection Saving Customizations
+ Saving customizations from the customization buffer works by writing
+code that future sessions will read, code to set up those
+customizations again.
+
@vindex custom-file
- The customization buffer normally saves customizations in
+ Normally this saves customizations in your init file,
@file{~/.emacs}. If you wish, you can save customizations in another
file instead. To make this work, your @file{~/.emacs} should set
@code{custom-file} to the name of that file. Then you should load the
(load custom-file)
@end example
- You can also use @code{custom-file} to specify different
-customization files for different Emacs versions, like this:
+ You can use @code{custom-file} to specify different customization
+files for different Emacs versions, like this:
@example
(cond ((< emacs-major-version 21)
[ ] Inherit: *
@end smallexample
- Each face attribute has its own line. The @samp{[@var{x}]} field
+ Each face attribute has its own line. The @samp{[@var{x}]} button
before the attribute name indicates whether the attribute is
-@dfn{enabled}; @samp{X} means that it is. You can enable or disable the
-attribute by invoking that field. When the attribute is enabled, you
-can change the attribute value in the usual ways.
+@dfn{enabled}; @samp{[X]} means that it's enabled, and @samp{[ ]}
+means that it's disabled. You can enable or disable the attribute by
+clicking that button. When the attribute is enabled, you can change
+the attribute value in the usual ways.
For the colors, you can specify a color name (use @kbd{M-x
list-colors-display} for a list of them) or a hexadecimal color
A face can specify different appearances for different types of
display. For example, a face can make text red on a color display, but
use a bold font on a monochrome display. To specify multiple
-appearances for a face, select @samp{Show all display specs} in the menu you
-get from invoking @samp{[State]}.
+appearances for a face, select @samp{For All Kinds of Displays} in the
+menu you get from invoking @samp{[State]}.
@findex modify-face
Another more basic way to set the attributes of a specific face is
@node Specific Customization
@subsection Customizing Specific Items
- Instead of finding the options you want to change by moving down
-through the structure of groups, you can specify the particular variable,
-face, or group that you want to customize.
+ Instead of finding the setting you want to change by navigating the
+structure of groups, here are other ways to specify the settings that
+you want to customize.
@table @kbd
@item M-x customize-variable @key{RET} @var{variable} @key{RET}
@item M-x customize-group @key{RET} @var{group} @key{RET}
Set up a customization buffer with just one group, @var{group}.
@item M-x customize-apropos @key{RET} @var{regexp} @key{RET}
-Set up a customization buffer with all the variables, faces and groups
-that match @var{regexp}.
+Set up a customization buffer with all the settings and groups that
+match @var{regexp}.
@item M-x customize-changed-options @key{RET} @var{version} @key{RET}
-Set up a customization buffer with all the variables, faces and groups
+Set up a customization buffer with all the settings and groups
whose meaning has changed since Emacs version @var{version}.
@item M-x customize-saved
-Set up a customization buffer containing all variables and faces that you
+Set up a customization buffer containing all settings that you
have saved with customization buffers.
@item M-x customize-customized
-Set up a customization buffer containing all variables and faces that you
-have customized but not saved.
+Set up a customization buffer containing all settings that you have
+customized but not saved.
@end table
@findex customize-variable
customize-variable} and specify the variable name. This sets up the
customization buffer with just one variable---the one that you asked
for. Editing, setting and saving the value work as described above,
-but only for the specified variable.
+but only for the specified variable. Minibuffer completion is handy
+if you only know part of the name. However, this command can only see
+options that have been loaded in the current Emacs session.
@findex customize-face
Likewise, you can modify a specific face, chosen by name, using
@findex customize-group
You can also set up the customization buffer with a specific group,
using @kbd{M-x customize-group}. The immediate contents of the chosen
-group, including user options, faces, and other groups, all appear
-as well. However, these subgroups' own contents are not included.
+group, including settings (variables and faces), and other groups, all
+appear as well (even if not already loaded). However, the subgroups'
+own contents are not included.
@findex customize-apropos
To control more precisely what to customize, you can use @kbd{M-x
-customize-apropos}. You specify a regular expression as argument; then
-all options, faces and groups whose names match this regular expression
-are set up in the customization buffer. If you specify an empty regular
-expression, this includes @emph{all} groups, options and faces (but
-that takes a long time).
-
-@findex customize-changed-options
- When you upgrade to a new Emacs version, you might want to customize
-new options and options whose meanings or default values have changed.
-To do this, use @kbd{M-x customize-changed-options} and specify a
-previous Emacs version number using the minibuffer. It creates a
-customization buffer which shows all the options (and groups) whose
-definitions have been changed since the specified version.
+customize-apropos}. You specify a regular expression as argument;
+then all @emph{loaded} settings and groups whose names match this
+regular expression are set up in the customization buffer. If you
+specify an empty regular expression, this includes @emph{all} loaded
+groups and settings---which takes a long time to set up.
+
+@findex customize-changed
+ When you upgrade to a new Emacs version, you might want to consider
+customizing new settings, and settings whose meanings or default
+values have changed. To do this, use @kbd{M-x customize-changed} and
+specify a previous Emacs version number using the minibuffer. It
+creates a customization buffer which shows all the settings and groups
+whose definitions have been changed since the specified version,
+loading them if necessary.
@findex customize-saved
@findex customize-customized
- If you change option values and then decide the change was a
-mistake, you can use two special commands to revisit your previous
-changes. Use @kbd{M-x customize-saved} to look at the options that
-you have saved. Use @kbd{M-x customize-customized} to look at the
-options that you have set but not saved.
+ If you change settings and then decide the change was a mistake, you
+can use two special commands to revisit your previous changes. Use
+@kbd{M-x customize-saved} to look at the settings that you have saved.
+Use @kbd{M-x customize-customized} to look at the settings that you
+have set but not saved.
@node Custom Themes
@subsection Customization Themes
@cindex custom themes
-@dfn{Custom themes} are collections of customized options that can be
-enabled or disabled as a unit. You can use Custom themes to switch
-quickly and easily between various collections of settings, and to
-transfer such collections from one computer to another.
+ @dfn{Custom themes} are collections of settings that can be enabled
+or disabled as a unit. You can use Custom themes to switch quickly
+and easily between various collections of settings, and to transfer
+such collections from one computer to another.
@findex customize-create-theme
-To define a Custom theme, use the command
-@kbd{M-x customize-create-theme}, which brings up a buffer named
-@samp{*New Custom Theme*}. At the top of the buffer is an editable
-field where you can specify the name of the theme. To add a
-customization option to the theme, click on the @samp{INS} button to
-open up a field where you can insert the name of the option. The
-current value of that option is applied to the theme. After adding as
-many options as you like, click on @samp{Done} to save the Custom
-theme.
+ To define a Custom theme, use @kbd{M-x customize-create-theme},
+which brings up a buffer named @samp{*New Custom Theme*}. At the top
+of the buffer is an editable field where you can specify the name of
+the theme. Click on the button labelled @samp{Insert Variable} to add
+a variable to the theme, and click on @samp{Insert Face} to add a
+face. You can edit these values in the @samp{*New Custom Theme*}
+buffer like in an ordinary Customize buffer. To remove an option from
+the theme, click on its @samp{State} button and select @samp{Delete}.
@vindex custom-theme-directory
-Saving a Custom theme named @var{foo} writes its definition into the
-file @file{@var{foo}-theme.el}, in the directory @file{~/.emacs.d/}
-(you can specify the directory by setting
-@code{custom-theme-directory}).
+ After adding the desired options, click on @samp{Save Theme} to save
+the Custom theme. This writes the theme definition to a file
+@file{@var{foo}-theme.el} (where @var{foo} is the theme name you
+supplied), in the directory @file{~/.emacs.d/}. You can specify the
+directory by setting @code{custom-theme-directory}.
+
+ You can view and edit the settings of a previously-defined theme by
+clicking on @samp{Visit Theme} and specifying the theme name. You can
+also import the variables and faces that you have set using Customize
+by visiting the ``special'' theme named @samp{user}. This theme, which
+records all the options that you set in the ordinary customization
+buffer, is always enabled, and always takes precedence over all other
+enabled Custom themes. Additionally, the @samp{user} theme is
+recorded with code in your @file{.emacs} file, rather than a
+@file{user-theme.el} file.
+
+@vindex custom-enabled-themes
+ Once you have defined a Custom theme, you can use it by customizing
+the variable @code{custom-enabled-themes}. This is a list of Custom
+themes that are @dfn{enabled}, or put into effect. If you set
+@code{custom-enabled-themes} using the Customize interface, the theme
+definitions are automatically loaded from the theme files, if they
+aren't already. If you save the value of @code{custom-enabled-themes}
+for future Emacs sessions, those Custom themes will be enabled
+whenever Emacs is started up.
+
+ If two enabled themes specify different values for an option, the
+theme occurring earlier in @code{custom-enabled-themes} takes effect.
@findex load-theme
@findex enable-theme
@findex disable-theme
-You can load the themes you've previously defined with the command
-@code{load-theme}. It prompts for a theme name in the minibuffer,
-then loads that theme if it isn't already loaded. It also
-@dfn{enables} the theme, which means putting its settings into effect.
-An enabled theme can be @dfn{disabled} with the command
-@kbd{M-x disable-theme}; this returns the options specified in the
-theme to their original values. To re-enable the theme, use the
-command @kbd{M-x enable-theme}.
-
-To enable a Custom theme named @var{foo} whenever Emacs is started up,
-add the line @code{(load-theme '@var{foo})} to your @file{.emacs} file
-(@pxref{Init File}).
-
-Enabling a custom theme does not disable the themes already enabled;
-instead, they are all enabled together. If two enabled Custom themes
-specify different values for an option, the last theme to be enabled
-takes effect.
-
-The options that you set in the ordinary customization buffer
-(@pxref{Easy Customization}) are also considered part of a Custom
-theme, called @samp{user}. The @samp{user} theme is always enabled,
-and always takes precedence over all other enabled Custom themes.
-Additionally, the @samp{user} theme is recorded in your @file{.emacs}
-file, rather than a @file{user-theme.el} file.
+ You can temporarily enable a Custom theme with @kbd{M-x
+enable-theme}. This prompts for a theme name in the minibuffer, loads
+the theme from the theme file if necessary, and enables the theme.
+You can @dfn{disable} any enabled theme with the command @kbd{M-x
+disable-theme}; this returns the options specified in the theme to
+their original values. To re-enable the theme, type @kbd{M-x
+enable-theme} again. If a theme file is changed during your Emacs
+session, you can reload it by typing @kbd{M-x load-theme}. (This also
+enables the theme.)
@node Variables
@section Variables
have a documentation string which describes what kind of value it should
have and how the value will be used.
- Lisp allows any variable to have any kind of value, but most variables
-that Emacs uses need a value of a certain type. Often the value should
-always be a string, or should always be a number. Sometimes we say that a
-certain feature is turned on if a variable is ``non-@code{nil},'' meaning
-that if the variable's value is @code{nil}, the feature is off, but the
-feature is on for @emph{any} other value. The conventional value to use to
-turn on the feature---since you have to pick one particular value when you
-set the variable---is @code{t}.
+ Emacs Lisp allows any variable (with a few exceptions) to have any
+kind of value, but most variables that Emacs uses expect a value of a
+certain type. Often the value should always be a string, or should
+always be a number. Sometimes we say that a certain feature is turned
+on if a variable is ``non-@code{nil},'' meaning that if the variable's
+value is @code{nil}, the feature is off, but the feature is on for
+@emph{any} other value. The conventional value to use to turn on the
+feature---since you have to pick one particular value when you set the
+variable---is @code{t}.
Emacs uses many Lisp variables for internal record keeping, but the
-most interesting variables for a non-programmer user are those that
-are also @dfn{user options}, the variables that are meant for users to
-change. Each user option that you can set with the customization
-buffer is (if it is not a face) in fact a Lisp variable. Emacs does
-not (usually) change the values of these variables; instead, you set
-the values, and thereby alter and control the behavior of certain
-Emacs commands. Use of the customization buffer is explained above
-(@pxref{Easy Customization}); here we describe other aspects of Emacs
-variables.
+most interesting variables for a non-programmer user are those meant
+for users to change---these are called @dfn{user options}.
+
+ Each user option that you can set with the customization buffer is
+in fact a Lisp variable. Emacs does not (usually) change the values
+of these variables on its own; instead, you set the values in order to
+control the behavior of certain Emacs commands. Use of the
+customization buffer is explained above (@pxref{Easy Customization});
+here we describe other aspects of Emacs variables.
@menu
* Examining:: Examining or setting one variable's value.
displays something like this:
@smallexample
+fill-column is a variable defined in `C source code'.
fill-column's value is 70
+Local in buffer custom.texi; global value is 70
+Automatically becomes buffer-local when set in any fashion.
Documentation:
*Column beyond which automatic line-wrapping should happen.
-Automatically becomes buffer-local when set in any fashion.
+Interactively, you can set the buffer local value using C-x f.
+
+You can customize this variable.
@end smallexample
@noindent
-The star at the beginning of the documentation indicates that this
-variable is a user option. @kbd{C-h v} is not restricted to user
-options; it allows any variable name.
+The line that says you can customize the variable indicates that this
+variable is a user option. (The star also indicates this, but it is
+an obsolete indicator that may eventually disappear.) @kbd{C-h v} is
+not restricted to user options; it allows any variable name.
@findex set-variable
- The most convenient way to set a specific user option variable is
-with @kbd{M-x set-variable}. This reads the variable name with the
+The most convenient way to set a specific user option variable is with
+@kbd{M-x set-variable}. This reads the variable name with the
minibuffer (with completion), and then reads a Lisp expression for the
new value using the minibuffer a second time (you can insert the old
value into the minibuffer for editing via @kbd{M-n}). For example,
are not called at all. The documentation of each abnormal hook variable
explains in detail what is peculiar about it.
+@findex add-hook
You can set a hook variable with @code{setq} like any other Lisp
variable, but the recommended way to add a hook function to a hook
-(either normal or abnormal) is by calling @code{add-hook}. You can
-specify any valid Lisp function as the hook function, provided it can
-handle the proper number of arguments (zero arguments, in the case of
-a normal hook). Of course, not every Lisp function is @emph{useful}
-in any particular hook.
+(either normal or abnormal) is by calling @code{add-hook}.
+@xref{Hooks,,, elisp, The Emacs Lisp Reference Manual}.
For example, here's how to set up a hook to turn on Auto Fill mode
when entering Text mode and other modes based on Text mode:
``asking for trouble.'' However, the order is predictable: the most
recently added hook functions are executed first.
+@findex remove-hook
If you play with adding various different versions of a hook
function by calling @code{add-hook} over and over, remember that all
the versions you added will remain in the hook variable together. You
-can clear out individual functions with @code{remove-hook}, or do
-@code{(setq @var{hook-variable} nil)} to remove everything.
+can clear out individual functions by calling @code{remove-hook}, or
+do @code{(setq @var{hook-variable} nil)} to remove everything.
@node Locals
@subsection Local Variables
effect in all buffers that have not made the variable local.
@findex make-local-variable
- @kbd{M-x make-local-variable} reads the name of a variable and makes it
-local to the current buffer. Further changes in this buffer will not
-affect others, and further changes in the global value will not affect this
-buffer.
+ @kbd{M-x make-local-variable} reads the name of a variable and makes
+it local to the current buffer. Changing its value subsequently in
+this buffer will not affect others, and changes in its global value
+will not affect this buffer.
@findex make-variable-buffer-local
@cindex per-buffer variables
- @kbd{M-x make-variable-buffer-local} reads the name of a variable and
-changes the future behavior of the variable so that it will become local
-automatically when it is set. More precisely, once a variable has been
-marked in this way, the usual ways of setting the variable automatically
-do @code{make-local-variable} first. We call such variables
-@dfn{per-buffer} variables.
+ @kbd{M-x make-variable-buffer-local} marks a variable so it will
+become local automatically whenever it is set. More precisely, once a
+variable has been marked in this way, the usual ways of setting the
+variable automatically do @code{make-local-variable} first. We call
+such variables @dfn{per-buffer} variables. Many variables in Emacs
+are normally per-buffer; the variable's document string tells you when
+this is so. A per-buffer variable's global value is normally never
+effective in any buffer, but it still has a meaning: it is the initial
+value of the variable for each new buffer.
Major modes (@pxref{Major Modes}) always make variables local to the
buffer before setting the variables. This is why changing major modes
-in one buffer has no effect on other buffers. Minor modes also work by
-setting variables---normally, each minor mode has one controlling
-variable which is non-@code{nil} when the mode is enabled (@pxref{Minor
-Modes}). For most minor modes, the controlling variable is per buffer.
-
- Emacs contains a number of variables that are always per-buffer.
-These include @code{abbrev-mode}, @code{auto-fill-function},
-@code{case-fold-search}, @code{comment-column}, @code{ctl-arrow},
-@code{fill-column}, @code{fill-prefix}, @code{indent-tabs-mode},
-@code{left-margin}, @code{mode-line-format}, @code{overwrite-mode},
-@code{selective-display-ellipses}, @code{selective-display},
-@code{tab-width}, and @code{truncate-lines}. Some other variables are
-always local in every buffer, but they are used for internal
-purposes.@refill
+in one buffer has no effect on other buffers. Minor modes also work
+by setting variables---normally, each minor mode has one controlling
+variable which is non-@code{nil} when the mode is enabled
+(@pxref{Minor Modes}). For many minor modes, the controlling variable
+is per buffer, and thus always buffer-local. Otherwise, you can make
+it local in a specific buffer like any other variable.
A few variables cannot be local to a buffer because they are always
local to each display instead (@pxref{Multiple Displays}). If you try to
make one of these variables buffer-local, you'll get an error message.
@findex kill-local-variable
- @kbd{M-x kill-local-variable} reads the name of a variable and makes
-it cease to be local to the current buffer. The global value of the
-variable henceforth is in effect in this buffer. Setting the major mode
-kills all the local variables of the buffer except for a few variables
+ @kbd{M-x kill-local-variable} makes a specified variable cease to be
+local to the current buffer. The global value of the variable
+henceforth is in effect in this buffer. Setting the major mode kills
+all the local variables of the buffer except for a few variables
specially marked as @dfn{permanent locals}.
@findex setq-default
specifications; it automatically makes these variables local to the
buffer, and sets them to the values specified in the file.
- There are two ways to specify local variable values: in the first
+@menu
+* Specifying File Variables:: Specifying file local variables.
+* Safe File Variables:: Making sure file local variables are safe.
+@end menu
+
+@node Specifying File Variables
+@subsubsection Specifying File Variables
+
+ There are two ways to specify file local variable values: in the first
line, or with a local variables list. Here's how to specify them in the
first line:
@cindex shell scripts, and local file variables
In shell scripts, the first line is used to identify the script
-interpreter, so you cannot put any local variables there. To accommodate
-for this, when Emacs visits a shell script, it looks for local variable
-specifications in the @emph{second} line.
+interpreter, so you cannot put any local variables there. To
+accommodate this, Emacs looks for local variable specifications in the
+@emph{second} line when the first line specifies an interpreter.
A @dfn{local variables list} goes near the end of the file, in the
last page. (It is often best to put it on a page by itself.) The local
in the @samp{-*-} line first, and @emph{everything} in the local
variables list afterward.
-Here is an example of a local variables list:
+ Here is an example of a local variables list:
@example
;;; Local Variables: ***
;;; End: ***
@end example
- As you see, each line starts with the prefix @samp{;;; } and each line
-ends with the suffix @samp{ ***}. Emacs recognizes these as the prefix
-and suffix based on the first line of the list, by finding them
+ Each line starts with the prefix @samp{;;; } and each line ends with
+the suffix @samp{ ***}. Emacs recognizes these as the prefix and
+suffix based on the first line of the list, by finding them
surrounding the magic string @samp{Local Variables:}; then it
automatically discards them from the other lines of the list.
as the major modes; in fact, you can use it more than once, first to
set the major mode and then to set minor modes which are specific to
particular buffers. But most minor modes should not be specified in
-the file at all, regardless of how, because they represent user
-preferences.
+the file at all, because they represent user preferences.
For example, you may be tempted to try to turn on Auto Fill mode with
a local variable list. That is a mistake. The choice of Auto Fill mode
major mode of a buffer according to the file name and contents,
including the local variables list if any. @xref{Choosing Modes}.
-@findex enable-local-variables
- The variable @code{enable-local-variables} controls whether to process
-local variables in files, and thus gives you a chance to override them.
-Its default value is @code{t}, which means do process local variables in
-files. If you set the value to @code{nil}, Emacs simply ignores local
-variables in files. Any other value says to query you about each file
-that has local variables, showing you the local variable specifications
-so you can judge.
-
-@findex enable-local-eval
- The @code{eval} ``variable,'' and certain actual variables, create a
-special risk; when you visit someone else's file, local variable
-specifications for these could affect your Emacs in arbitrary ways.
-Therefore, the variable @code{enable-local-eval} controls whether Emacs
-processes @code{eval} variables, as well variables with names that end
-in @samp{-hook}, @samp{-hooks}, @samp{-function} or @samp{-functions},
-and certain other variables. The three possibilities for the variable's
-value are @code{t}, @code{nil}, and anything else, just as for
-@code{enable-local-variables}. The default is @code{maybe}, which is
-neither @code{t} nor @code{nil}, so normally Emacs does ask for
-confirmation about file settings for these variables.
-
-@findex safe-local-eval-forms
- The @code{safe-local-eval-forms} is a customizable list of eval
-forms which are safe to eval, so Emacs should not ask for
-confirmation to evaluate these forms, even if
-@code{enable-local-variables} says to ask for confirmation in general.
+@node Safe File Variables
+@subsubsection Safety of File Variables
+
+ File-local variables can be dangerous; when you visit someone else's
+file, there's no telling what its local variables list could do to
+your Emacs. Improper values of the @code{eval} ``variable,'' and
+other variables such as @code{load-path}, could execute Lisp code you
+didn't intend to run.
+
+ Therefore, whenever Emacs encounters file local variable values that
+are not known to be safe, it displays the file's entire local
+variables list, and asks you for confirmation before setting them.
+You can type @kbd{y} or @key{SPC} to put the local variables list into
+effect, or @kbd{n} to ignore it. When Emacs is run in batch mode
+(@pxref{Initial Options}), it can't really ask you, so it assumes the
+answer @samp{n}.
+
+ Emacs normally recognizes certain variables/value pairs as safe.
+For instance, it is safe to give @code{comment-column} or
+@code{fill-column} any integer value. If a file specifies only
+known-safe variable/value pairs, Emacs does not ask for confirmation
+before setting them. Otherwise, you can tell Emacs to record all the
+variable/value pairs in this file as safe, by typing @kbd{!} at the
+confirmation prompt. When Emacs encounters these variable/value pairs
+subsequently, in the same file or others, it will assume they are
+safe.
+
+@vindex safe-local-variable-values
+@cindex risky variable
+ Some variables, such as @code{load-path}, are considered
+particularly @dfn{risky}: there is seldom any reason to specify them
+as local variables, and changing them can be dangerous. Even if you
+enter @kbd{!} at the confirmation prompt, Emacs will not record any
+values as safe for these variables. If you really want to record safe
+values for these variables, do it directly by customizing
+@samp{safe-local-variable-values} (@pxref{Easy Customization}).
+
+@vindex enable-local-variables
+ The variable @code{enable-local-variables} allows you to change the
+way Emacs processes local variables. Its default value is @code{t},
+which specifies the behavior described above. If it is @code{nil},
+Emacs simply ignores all file local variables. @code{:safe} means use
+only the safe values and ignore the rest. Any other value says to
+query you about each file that has local variables, without trying to
+determine whether the values are known to be safe.
+
+@vindex enable-local-eval
+ The variable @code{enable-local-eval} controls whether Emacs
+processes @code{eval} variables. The three possibilities for the
+variable's value are @code{t}, @code{nil}, and anything else, just as
+for @code{enable-local-variables}. The default is @code{maybe}, which
+is neither @code{t} nor @code{nil}, so normally Emacs does ask for
+confirmation about processes @code{eval} variables.
+
+@vindex safe-local-eval-forms
+ But there is an exception. The @code{safe-local-eval-forms} is a
+customizable list of eval forms which are safe. Emacs does not ask
+for confirmation when it finds these forms for the @code{eval}
+variable.
@node Key Bindings
@section Customizing Key Bindings
Recall that a command is a Lisp function whose definition provides for
interactive use. Like every Lisp function, a command has a function
-name which usually consists of lower-case letters and hyphens.
+name, which usually consists of lower-case letters and hyphens.
@menu
* Keymaps:: Generalities. The global keymap.
symbol whose function definition is the following keymap; the effect is
the same, but it provides a command name for the prefix key that can be
used as a description of what the prefix key is for. Thus, the binding
-of @kbd{C-x} is the symbol @code{Ctl-X-Prefix}, whose function
+of @kbd{C-x} is the symbol @code{Control-X-prefix}, whose function
definition is the keymap for @kbd{C-x} commands. The definitions of
@kbd{C-c}, @kbd{C-x}, @kbd{C-h} and @key{ESC} as prefix keys appear in
the global map, so these prefix keys are always available.
in effect, the definitions in its keymap override both the major
mode's local keymap and the global keymap.
-@vindex c-mode-map
-@vindex lisp-mode-map
- The local keymaps for Lisp mode and several other major modes always
-exist even when not in use. These are kept in variables named
-@code{lisp-mode-map} and so on. For major modes less often used, the
-local keymap is normally constructed only when the mode is used for the
-first time in a session. This is to save space. If you wish to change
-one of these keymaps, you must use the major mode's @dfn{mode
-hook}---see below.
-
- All minor mode keymaps are created in advance. There is no way to
-defer their creation until the first time the minor mode is enabled.
-
A local keymap can locally redefine a key as a prefix key by defining
it as a prefix keymap. If the key is also defined globally as a prefix,
then its local and global definitions (both keymaps) effectively
whole key sequence. First it checks the minor mode keymaps for minor
modes that are enabled, then it checks the major mode's keymap, and then
it checks the global keymap. This is not precisely how key lookup
-works, but it's good enough for understanding ordinary circumstances.
+works, but it's good enough for understanding the results in ordinary
+circumstances.
@cindex rebinding major mode keys
-@findex define-key
- To change the local bindings of a major mode, you must change the
-mode's local keymap. Normally you must wait until the first time the
-mode is used, because most major modes don't create their keymaps until
-then. If you want to specify something in your @file{~/.emacs} file to
-change a major mode's bindings, you must use the mode's mode hook to
-delay the change until the mode is first used.
+ Most major modes construct their keymaps when the mode is used for
+the first time in a session. If you wish to change one of these
+keymaps, you must use the major mode's @dfn{mode hook}
+(@pxref{Hooks}).
+@findex define-key
For example, the command @code{texinfo-mode} to select Texinfo mode
runs the hook @code{texinfo-mode-hook}. Here's how you can use the hook
to add local bindings (not very useful, we admit) for @kbd{C-c n} and
'forward-paragraph)))
@end example
- @xref{Hooks}.
-
@node Minibuffer Maps
@subsection Minibuffer Keymaps
You can rebind a key that contains more than one event in the same
way. Emacs keeps reading the key to rebind until it is a complete key
(that is, not a prefix key). Thus, if you type @kbd{C-f} for
-@var{key}, that's the end; the minibuffer is entered immediately to
-read @var{cmd}. But if you type @kbd{C-x}, another character is read;
-if that is @kbd{4}, another character is read, and so on. For
-example,
+@var{key}, that's the end; it enters the minibuffer immediately to
+read @var{cmd}. But if you type @kbd{C-x}, since that's a prefix, it
+reads another character; if that is @kbd{4}, another prefix character,
+it reads one more character, and so on. For example,
@example
M-x global-set-key @key{RET} C-x 4 $ spell-other-window @key{RET}
If you have redefined (or undefined) a key and you subsequently wish
to retract the change, undefining the key will not do the job---you need
to redefine the key with its standard definition. To find the name of
-the standard definition of a key, go to a Fundamental mode buffer and
-use @kbd{C-h c}. The documentation of keys in this manual also lists
-their command names.
+the standard definition of a key, go to a Fundamental mode buffer in a
+fresh Emacs and use @kbd{C-h c}. The documentation of keys in this
+manual also lists their command names.
If you want to prevent yourself from invoking a command by mistake, it
is better to disable the command than to undefine the key. A disabled
@noindent
As you see, you represent a multi-character key sequence with a vector
-by listing all of the characters in order within the square brackets that
-delimit the vector.
+by listing all of the characters, in order, within the square brackets
+that delimit the vector.
Language and coding systems can cause problems with key bindings
for non-@acronym{ASCII} characters. @xref{Non-ASCII Rebinding}.
@cindex rebinding non-@acronym{ASCII} keys
@cindex non-@acronym{ASCII} keys, binding
-If your keyboard has keys that send non-@acronym{ASCII}
+ If your keyboard has keys that send non-@acronym{ASCII}
characters, such as accented letters, rebinding these keys
-must be done by using a vector like this@footnote{Note that
-you should avoid the string syntax for binding
+must be done by using a vector like this@footnote{You must
+avoid the string syntax for binding
non-@acronym{ASCII} characters, since they will be
interpreted as meta keys. @xref{Strings of Events,,,elisp,
The Emacs Lisp Reference Manual}.}:
@noindent
Type @kbd{C-q} followed by the key you want to bind, to insert @var{char}.
-Since this puts a non-@acronym{ASCII} character in the @file{.emacs},
+ Since this puts a non-@acronym{ASCII} character in the @file{.emacs},
you should specify a coding system for that file that supports the
-character in question. @xref{Init Syntax}.
+character in question. @xref{Init Non-ASCII}.
-@strong{Warning:} if you change the keyboard encoding, or change
+ @strong{Warning:} if you change the keyboard encoding, or change
between multibyte and unibyte mode, or anything that would alter which
code @kbd{C-q} would insert for that character, you'll need to edit
the Lisp expression accordingly, to use the character code generated
@subsection Disabling Commands
@cindex disabled command
- Disabling a command marks the command as requiring confirmation before it
-can be executed. The purpose of disabling a command is to prevent
-beginning users from executing it by accident and being confused.
+ Disabling a command menas it requires confirmation before it can be
+executed. The purpose of disabling a command is to prevent users from
+executing it by accident and being confused.
An attempt to invoke a disabled command interactively in Emacs
-displays a window containing the command's name, its documentation, and
-some instructions on what to do immediately; then Emacs asks for input
-saying whether to execute the command as requested, enable it and
-execute it, or cancel. If you decide to enable the command, you are
-asked whether to do this permanently or just for the current session.
-(Enabling permanently works by automatically editing your @file{.emacs}
-file.) You can also type @kbd{!} to enable @emph{all} commands,
-for the current session only.
+displays a window containing the command's name, its documentation,
+and some instructions on what to do immediately; then Emacs asks for
+input saying whether to execute the command as requested, enable it
+and execute it, or cancel. If you decide to enable the command, you
+must then answer another question---whether to do this permanently, or
+just for the current session. (Enabling permanently works by
+automatically editing your @file{.emacs} file.) You can also type
+@kbd{!} to enable @emph{all} commands, for the current session only.
The direct mechanism for disabling a command is to put a
non-@code{nil} @code{disabled} property on the Lisp symbol for the
@findex disable-command
@findex enable-command
You can make a command disabled either by editing the @file{.emacs}
-file directly or with the command @kbd{M-x disable-command}, which edits
+file directly, or with the command @kbd{M-x disable-command}, which edits
the @file{.emacs} file for you. Likewise, @kbd{M-x enable-command}
edits @file{.emacs} to enable a command permanently. @xref{Init File}.
If Emacs was invoked with the @option{-q} or @option{--no-init-file}
options (@pxref{Initial Options}), it will not edit your
-@file{~/.emacs} init file. This is because editing the init file from
-such a session might overwrite the lines you might have on your init
-file which enable and disable commands.
+@file{~/.emacs} init file. Doing so could lose information
+because Emacs has not read your init file.
Whether a command is disabled is independent of what key is used to
invoke it; disabling also applies if the command is invoked using
some additional information also.
Each major mode has its own syntax table (though related major modes
-sometimes share one syntax table) which it installs in each buffer
+sometimes share one syntax table), which it installs in each buffer
that uses the mode. The syntax table installed in the current buffer
is the one that all commands use, so we call it ``the'' syntax table.
@findex describe-syntax
To display a description of the contents of the current syntax
table, type @kbd{C-h s} (@code{describe-syntax}). The description of
-each character includes both the string you would have to give to
+each character includes the string you would have to give to
@code{modify-syntax-entry} to set up that character's current syntax,
starting with the character which designates its syntax class, plus
some English text to explain its meaning.
@cindex startup (init file)
When Emacs is started, it normally loads a Lisp program from the
-file @file{.emacs} or @file{.emacs.el} in your home directory. We
-call this file your @dfn{init file} because it specifies how to
+file @file{.emacs} or @file{.emacs.el} in your home directory
+(see @ref{General Variables, HOME}, if you don't know where that is).
+We call this file your @dfn{init file} because it specifies how to
initialize Emacs for you. You can use the command line switch
@samp{-q} to prevent loading your init file, and @samp{-u} (or
@samp{--user}) to specify a different user's init file (@pxref{Initial
@cindex international characters in @file{.emacs}
@cindex non-@acronym{ASCII} characters in @file{.emacs}
-If you want to include non-@acronym{ASCII} characters in strings in your init
+@anchor{Init Non-ASCII}If you want to include non-@acronym{ASCII}
+characters in strings in your init
file, you should consider putting a @w{@samp{-*-coding:
@var{coding-system}-*-}} tag on the first line which states the coding
system used to save your @file{.emacs}, as explained in @ref{Recognize
Specify your own email address, if Emacs can't figure it out correctly.
@example
-(setq user-mail-address "coon@@yoyodyne.com")
+(setq user-mail-address "rumsfeld@@torture.gov")
@end example
Various Emacs packages that need your own email address use the value of
@node Find Init
@subsection How Emacs Finds Your Init File
- Normally Emacs uses the environment variable @env{HOME} to find
-@file{.emacs}; that's what @samp{~} means in a file name. If
-@file{.emacs} is not found inside @file{~/} (nor @file{.emacs.el}),
-Emacs looks for @file{~/.emacs.d/init.el} (which, like
-@file{~/.emacs.el}, can be byte-compiled).
+ Normally Emacs uses the environment variable @env{HOME}
+(@pxref{General Variables, HOME}) to find @file{.emacs}; that's what
+@samp{~} means in a file name. If @file{.emacs} is not found inside
+@file{~/} (nor @file{.emacs.el}), Emacs looks for
+@file{~/.emacs.d/init.el} (which, like @file{~/.emacs.el}, can be
+byte-compiled).
However, if you run Emacs from a shell started by @code{su}, Emacs
tries to find your own @file{.emacs}, not that of the user you are
editor customizations even if you are running as the super user.
More precisely, Emacs first determines which user's init file to use.
-It gets the user name from the environment variables @env{LOGNAME} and
+It gets your user name from the environment variables @env{LOGNAME} and
@env{USER}; if neither of those exists, it uses effective user-ID.
If that user name matches the real user-ID, then Emacs uses @env{HOME};
otherwise, it looks up the home directory corresponding to that user