@c This is part of the Emacs manual.
-@c Copyright (C) 1985, 86, 87, 93, 94, 95, 97, 2000
+@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001,2002
@c Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Customization, Quitting, Amusements, Top
This chapter talks about various topics relevant to adapting the
behavior of Emacs in minor ways. See @cite{The Emacs Lisp Reference
-Manual} for how to make more far-reaching changes.
-
- All kinds of customization affect only the particular Emacs session
-that you do them in. They are completely lost when you kill the Emacs
-session, and have no effect on other Emacs sessions you may run at the
-same time or later. The only way an Emacs session can affect anything
-outside of it is by writing a file; in particular, the only way to make
-a customization ``permanent'' is to put something in your @file{.emacs}
-file or other appropriate file to do the customization in each session.
-@xref{Init File}.
+Manual} for how to make more far-reaching 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
+customizations for future sessions, this actually works by editing
+@file{.emacs} for you.
+
+ Another means of customization is the keyboard macro, which is a
+sequence of keystrokes to be replayed with a single command.
+@xref{Keyboard Macros}, for full instruction how to record, manage, and
+replay sequences of keys.
@menu
* Minor Modes:: Each minor mode is one feature you can turn on
* Variables:: Many Emacs commands examine Emacs variables
to decide what to do; by setting variables,
you can control their functioning.
-* Keyboard Macros:: A keyboard macro records a sequence of
- keystrokes to be replayed with a single
- command.
* Key Bindings:: The keymaps say what command each key runs.
By changing them, you can "redefine keys".
* Keyboard Translations::
If your keyboard passes an undesired code
for a key, you can tell Emacs to
- substitute another code.
+ substitute another code.
* Syntax:: The syntax table controls how words and
expressions are parsed.
* Init File:: How to write common customizations in the
- @file{.emacs} file.
+ @file{.emacs} file.
@end menu
@node Minor Modes
argument always turns the mode on, and an explicit zero argument or a
negative argument always turns it off.
- Enabling or disabling some minor modes applies only to the current
-buffer; each buffer is independent of the other buffers. Therefore, you
-can enable the mode in particular buffers and disable it in others. The
-per-buffer minor modes include Abbrev mode, Auto Fill mode, Auto Save
-mode, Font-Lock mode, ISO Accents mode, Outline minor
-mode, Overwrite mode, and Binary Overwrite mode.
+ Some minor modes are global: while enabled, they affect everything
+you do in the Emacs session, in all buffers. Other minor modes are
+buffer-local; they apply only to the current buffer, so you can enable
+the mode in certain buffers and not others.
+
+ For most minor modes, the command name is also the name of a
+variable which directly controls the mode. The mode is enabled
+whenever this variable's value is non-@code{nil}, and the minor-mode
+command works by setting the variable. For example, the command
+@code{outline-minor-mode} works by setting the value of
+@code{outline-minor-mode} as a variable; it is this variable that
+directly turns Outline minor mode on and off. To check whether a
+given minor mode works this way, use @kbd{C-h v} to ask for
+documentation on the variable name.
+
+ These minor-mode variables provide a good way for Lisp programs to turn
+minor modes on and off; they are also useful in a file's local variables
+list. But please think twice before setting minor modes with a local
+variables list, because most minor modes are matter of user
+preference---other users editing the same file might not want the same
+minor modes you prefer.
+
+ The 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.
Abbrev mode allows you to define abbreviations that automatically expand
as you type them. For example, @samp{amd} might expand to @samp{abbrev
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.
-@xref{Single-Byte Character Support}.
+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}.
Outline minor mode provides the same facilities as the major mode
called Outline mode; but since it is a minor mode instead, you can
@cindex Overwrite mode
@cindex mode, Overwrite
-@findex overwrite-mode
-@findex binary-overwrite-mode
Overwrite mode causes ordinary printing characters to replace existing
text instead of shoving it to the right. For example, if point is in
front of the @samp{B} in @samp{FOOBAR}, then in Overwrite mode typing a
character whatever it may be, even if it is a digit---this gives you a
way to insert a character instead of replacing an existing character.
+@findex overwrite-mode
+@kindex INSERT
+ The command @code{overwrite-mode} is an exception to the rule that
+commands which toggle minor modes are normally not bound to keys: it is
+bound to the @key{INSERT} function key. This is because many other
+programs bind @key{INSERT} to similar functions.
+
+@findex binary-overwrite-mode
Binary Overwrite mode is a variant of Overwrite mode for editing
binary files; it treats newlines and tabs like other characters, so that
they overwrite other characters and can be overwritten by them.
+In Binary Overwrite mode, digits after @kbd{C-q} specify an
+octal character code, as usual.
The following minor modes normally apply to all buffers at once.
Since each is enabled or disabled by the value of a variable, you
The advantage of Transient Mark mode is that Emacs can display the
region highlighted (currently only when using X). @xref{Mark}.
- For most minor modes, the command name is also the name of a variable
-which directly controls the mode. The mode is enabled whenever this
-variable's value is non-@code{nil}, and the minor-mode command works by
-setting the variable. For example, the command
-@code{outline-minor-mode} works by setting the value of
-@code{outline-minor-mode} as a variable; it is this variable that
-directly turns Outline minor mode on and off. To check whether a given
-minor mode works this way, use @kbd{C-h v} to ask for documentation on
-the variable name.
-
- These minor-mode variables provide a good way for Lisp programs to turn
-minor modes on and off; they are also useful in a file's local variables
-list. But please think twice before setting minor modes with a local
-variables list, because most minor modes are matter of user
-preference---other users editing the same file might not want the same
-minor modes you prefer.
-
@node Variables
@section Variables
@cindex variable
displays something like this:
@smallexample
-fill-column's value is 75
+fill-column's value is 70
Documentation:
*Column beyond which automatic line-wrapping should happen.
@findex customize
@cindex customization buffer
A convenient way to find the user option variables that you want to
-change, and then change them, is with @kbd{M-x customize}. This command
-creates a @dfn{customization buffer} with which you can browse through
-the Emacs user options in a logically organized structure, then edit and
-set their values. You can also use the customization buffer to save
-settings permanently. (Not all Emacs user options are included in this
-structure as of yet, but we are adding the rest.)
+change, and then change them, is with @kbd{M-x customize}. This
+command creates a @dfn{customization buffer} with which you can browse
+through the Emacs user options in a logically organized structure,
+then edit and set their values. You can also use the customization
+buffer to save settings permanently in your @file{~/.emacs} file
+(@pxref{Init File}).
The appearance of the example buffers in the following is typically
different under a window system where faces can be used to indicate the
* Groups: Customization Groups.
How options are classified in a structure.
* Changing an Option:: How to edit a value and set an option.
+* Saving Customizations:: Details of saving customizations.
* Face Customization:: How to edit the attributes of a face.
* Specific Customization:: Making a customization buffer for specific
options, faces, or groups.
Customization of the One True Editor.
See also [Manual].
-Editing group: [Go to Group]
+Confirm Kill Emacs: [Hide] [Value Menu] Don't confirm
+ [State]: this option is unchanged from its standard setting.
+How to ask for confirmation when leaving Emacs. [More]
+
+Editing group: [Go to Group]
Basic text editing facilities.
-External group: [Go to Group]
+External group: [Go to Group]
Interfacing to external utilities.
@var{more second-level groups}
shows that group and its contents. This field is a kind of hypertext
link to another group.
- The @code{Emacs} group does not include any user options itself, but
-other groups do. By examining various groups, you will eventually find
-the options and faces that belong to the feature you are interested in
-customizing. Then you can use the customization buffer to set them.
+ 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 and faces
+pertaining to that feature. You can also go straight to a particular
+group by name, using the command @kbd{M-x customize-group}.
@findex customize-browse
You can view the structure of customization groups on a larger scale
customization buffer:
@smallexample
-Kill Ring Max: [Hide] 30
+Kill Ring Max: [Hide] 60
[State]: this option is unchanged from its standard setting.
Maximum length of kill ring before oldest elements are thrown away.
@end smallexample
- The text following @samp{[Hide]}, @samp{30} in this case, indicates
+ The text following @samp{[Hide]}, @samp{60} in this case, indicates
the current value of the option. If you see @samp{[Show]} instead of
@samp{[Hide]}, it means that the value is hidden; the customization
buffer initially hides values that take up several lines. Invoke
Encoding: emacs-mule
[INS] [DEL] File regexp: \(\`\|/\)loaddefs.el\'
Choice: [Value Menu] Encoding/decoding pair:
- Decoding: no-conversion
- Encoding: no-conversion
+ Decoding: raw-text
+ Encoding: raw-text-unix
[INS] [DEL] File regexp: \.tar\'
Choice: [Value Menu] Encoding/decoding pair:
Decoding: no-conversion
editable field, use @kbd{C-o} or @kbd{C-q C-j}.
@cindex saving option value
+@cindex customized options, saving
Setting the option changes its value in the current Emacs session;
-@dfn{saving} the value changes it for future sessions as well. This
-works by writing code into your @file{~/.emacs} file so as to set the
-option variable again each time you start Emacs. To save the option,
-invoke @samp{[State]} and select the @samp{Save for Future Sessions}
-operation.
+@dfn{saving} the value changes it for future sessions as well. To
+save the option, invoke @samp{[State]} and select the @samp{Save for
+Future Sessions} operation. This works by writing code so as to set
+the option variable again each time you start Emacs (@pxref{Saving
+Customizations}).
You can also restore the option to its standard value by invoking
-@samp{[State]} and selecting the @samp{Erase Customization}
-operation. There are actually three reset operations:
+@samp{[State]} and selecting the @samp{Erase Customization} operation.
+There are actually three reset operations:
@table @samp
@item Reset
This sets the option to its standard value, and updates the text
accordingly. This also eliminates any saved value for the option,
so that you will get the standard value in future Emacs sessions.
+
+@item Use Backup Value
+This sets the option to a previous value that was set in the
+customization buffer in this session. If you customize a variable
+and then reset the variable, which discards the customized value,
+you can get the customized value back again with this operation.
@end table
@cindex comments on customized options
reset---on each of the items in the buffer that could meaningfully be
set, saved or reset.
+@node Saving Customizations
+@subsubsection Saving Customizations
+
+@vindex custom-file
+ The customization buffer normally saves customizations in
+@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. Emacs loads the file
+right after your @file{.emacs} if you did not load it already. For
+example:
+
+@example
+(setq custom-file "~/.emacs-custom")
+@end example
+
+ The variable @code{custom-file} is useful if you want to have
+different customizations for different Emacs versions:
+
+@example
+(if (< emacs-major-version 21)
+ ;; @r{Emacs 20 customization.}
+ (setq custom-file "~/.custom-20.el")
+ ;; @r{Emacs 21 customization.}
+ (setq custom-file "~/.custom-21.el"))
+@end example
+
+ If Emacs was invoked with the @option{-q} or @option{--no-init-file}
+options (@pxref{Initial Options}), it will not let you save your
+customizations in your @file{~/.emacs} init file. This is because
+saving customizations from such a session would wipe out all the other
+customizations you might have on your init file.
+
@node Face Customization
@subsubsection Customizing Faces
@cindex customizing faces
example of how a face looks:
@smallexample
-Custom Changed Face: (sample) [Hide]
+Custom Changed Face:(sample) [Hide]
[State]: this face is unchanged from its standard setting.
-Parent groups: [Custom Magic Faces]
-Attributes: [ ] Font family: [Value Menu] *
- [ ] Width: [Value Menu] *
- [ ] Height: [Value Menu] *
- [ ] Weight: [Value Menu] *
- [ ] Slant: [Value Menu] *
- [ ] Underline: [Value Menu] *
- [ ] Overline: [Value Menu] *
- [ ] Strike-through: [Value Menu] *
- [ ] Box around text: [Value Menu] Off
- [ ] Inverse-video: [Value Menu] *
- [X] Foreground: [Value Menu] Color: white (sample)
- [X] Background: [Value Menu] Color: blue (sample)
- [ ] Stipple: [Value Menu] *
+Face used when the customize item has been changed.
+Parent groups: => Custom Magic Faces
+Attributes: [ ] Font Family: *
+ [ ] Width: *
+ [ ] Height: *
+ [ ] Weight: *
+ [ ] Slant: *
+ [ ] Underline: *
+ [ ] Overline: *
+ [ ] Strike-through: *
+ [ ] Box around text: *
+ [ ] Inverse-video: *
+ [X] Foreground: white (sample)
+ [X] Background: blue (sample)
+ [ ] Stipple: *
+ [ ] Inherit: *
@end smallexample
Each face attribute has its own line. The @samp{[@var{x}]} field
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 Display Types} in the menu you
+appearances for a face, select @samp{Show all display specs} in the menu you
get from invoking @samp{[State]}.
@findex modify-face
@item M-x customize-changed-options @key{RET} @var{version} @key{RET}
Set up a customization buffer with all the options, faces and groups
whose meaning has changed since Emacs version @var{version}.
-@item M-x customize-saved
+@item M-x customize-saved
Set up a customization buffer containing all options and faces that you
have saved with customization buffers.
@item M-x customize-customized
@findex customize-face
Likewise, you can modify a specific face, chosen by name, using
-@kbd{M-x customize-face}.
+@kbd{M-x customize-face}. By default it operates on the face used
+on the character after point.
@findex customize-group
You can also set up the customization buffer with a specific group,
@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{customize-saved} to look at the options and faces that you have
+@kbd{M-x customize-saved} to look at the options and faces that you have
saved. Use @kbd{M-x customize-customized} to look at the options and
faces that you have set but not saved.
makes these hooks abnormal is that there is something peculiar about the
way its functions are called---perhaps they are given arguments, or
perhaps the values they return are used in some way. For example,
-@code{find-file-not-found-hooks} (@pxref{Visiting}) is abnormal because
+@code{find-file-not-found-functions} (@pxref{Visiting}) is abnormal because
as soon as one hook function returns a non-@code{nil} value, the rest
are not called at all. The documentation of each abnormal hook variable
explains in detail what is peculiar about it.
@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 accomodate
+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.
and a value for the variable @code{eval} is simply evaluated as an
expression and the value is ignored. @code{mode} and @code{eval} are
not real variables; setting variables named @code{mode} and @code{eval}
-in any other context has no special meaning. If @code{mode} is used to
-set a major mode, it should be the first ``variable'' in the list.
+in any other context has no special meaning. @emph{If @code{mode} is
+used to set a major mode, it should be the first ``variable'' in the
+list.} Otherwise, the entries that precede it in the list of the local
+variables are likely to be ignored, since most modes kill all local
+variables as part of their initialization.
You can use the @code{mode} ``variable'' to set minor modes as well as
major modes; in fact, you can use it more than once, first to set the
neither @code{t} nor @code{nil}, so normally Emacs does ask for
confirmation about file settings for these variables.
-@node Keyboard Macros
-@section Keyboard Macros
-
-@cindex defining keyboard macros
-@cindex keyboard macro
- A @dfn{keyboard macro} is a command defined by the user to stand for
-another sequence of keys. For example, if you discover that you are
-about to type @kbd{C-n C-d} forty times, you can speed your work by
-defining a keyboard macro to do @kbd{C-n C-d} and calling it with a
-repeat count of forty.
-
-@c widecommands
-@table @kbd
-@item C-x (
-Start defining a keyboard macro (@code{start-kbd-macro}).
-@item C-x )
-End the definition of a keyboard macro (@code{end-kbd-macro}).
-@item C-x e
-Execute the most recent keyboard macro (@code{call-last-kbd-macro}).
-@item C-u C-x (
-Re-execute last keyboard macro, then add more keys to its definition.
-@item C-x q
-When this point is reached during macro execution, ask for confirmation
-(@code{kbd-macro-query}).
-@item M-x name-last-kbd-macro
-Give a command name (for the duration of the session) to the most
-recently defined keyboard macro.
-@item M-x insert-kbd-macro
-Insert in the buffer a keyboard macro's definition, as Lisp code.
-@item C-x C-k
-Edit a previously defined keyboard macro (@code{edit-kbd-macro}).
-@item M-x apply-macro-to-region-lines
-Run the last keyboard macro on each complete line in the region.
-@end table
-
- Keyboard macros differ from ordinary Emacs commands in that they are
-written in the Emacs command language rather than in Lisp. This makes it
-easier for the novice to write them, and makes them more convenient as
-temporary hacks. However, the Emacs command language is not powerful
-enough as a programming language to be useful for writing anything
-intelligent or general. For such things, Lisp must be used.
-
- You define a keyboard macro while executing the commands which are the
-definition. Put differently, as you define a keyboard macro, the
-definition is being executed for the first time. This way, you can see
-what the effects of your commands are, so that you don't have to figure
-them out in your head. When you are finished, the keyboard macro is
-defined and also has been, in effect, executed once. You can then do the
-whole thing over again by invoking the macro.
-
-@menu
-* Basic Kbd Macro:: Defining and running keyboard macros.
-* Save Kbd Macro:: Giving keyboard macros names; saving them in files.
-* Kbd Macro Query:: Making keyboard macros do different things each time.
-@end menu
-
-@node Basic Kbd Macro
-@subsection Basic Use
-
-@kindex C-x (
-@kindex C-x )
-@kindex C-x e
-@findex start-kbd-macro
-@findex end-kbd-macro
-@findex call-last-kbd-macro
- To start defining a keyboard macro, type the @kbd{C-x (} command
-(@code{start-kbd-macro}). From then on, your keys continue to be
-executed, but also become part of the definition of the macro. @samp{Def}
-appears in the mode line to remind you of what is going on. When you are
-finished, the @kbd{C-x )} command (@code{end-kbd-macro}) terminates the
-definition (without becoming part of it!). For example,
-
-@example
-C-x ( M-f foo C-x )
-@end example
-
-@noindent
-defines a macro to move forward a word and then insert @samp{foo}.
-
- The macro thus defined can be invoked again with the @kbd{C-x e}
-command (@code{call-last-kbd-macro}), which may be given a repeat count
-as a numeric argument to execute the macro many times. @kbd{C-x )} can
-also be given a repeat count as an argument, in which case it repeats
-the macro that many times right after defining it, but defining the
-macro counts as the first repetition (since it is executed as you define
-it). Therefore, giving @kbd{C-x )} an argument of 4 executes the macro
-immediately 3 additional times. An argument of zero to @kbd{C-x e} or
-@kbd{C-x )} means repeat the macro indefinitely (until it gets an error
-or you type @kbd{C-g} or, on MS-DOS, @kbd{C-@key{BREAK}}).
-
- If you wish to repeat an operation at regularly spaced places in the
-text, define a macro and include as part of the macro the commands to move
-to the next place you want to use it. For example, if you want to change
-each line, you should position point at the start of a line, and define a
-macro to change that line and leave point at the start of the next line.
-Then repeating the macro will operate on successive lines.
-
- After you have terminated the definition of a keyboard macro, you can add
-to the end of its definition by typing @kbd{C-u C-x (}. This is equivalent
-to plain @kbd{C-x (} followed by retyping the whole definition so far. As
-a consequence it re-executes the macro as previously defined.
-
- You can use function keys in a keyboard macro, just like keyboard
-keys. You can even use mouse events, but be careful about that: when
-the macro replays the mouse event, it uses the original mouse position
-of that event, the position that the mouse had while you were defining
-the macro. The effect of this may be hard to predict. (Using the
-current mouse position would be even less predictable.)
-
- One thing that doesn't always work well in a keyboard macro is the
-command @kbd{C-M-c} (@code{exit-recursive-edit}). When this command
-exits a recursive edit that started within the macro, it works as you'd
-expect. But if it exits a recursive edit that started before you
-invoked the keyboard macro, it also necessarily exits the keyboard macro
-as part of the process.
-
-@findex edit-kbd-macro
-@kindex C-x C-k
- You can edit a keyboard macro already defined by typing @kbd{C-x C-k}
-(@code{edit-kbd-macro}). Follow that with the keyboard input that you
-would use to invoke the macro---@kbd{C-x e} or @kbd{M-x @var{name}} or
-some other key sequence. This formats the macro definition in a buffer
-and enters a specialized major mode for editing it. Type @kbd{C-h m}
-once in that buffer to display details of how to edit the macro. When
-you are finished editing, type @kbd{C-c C-c}.
-
-@findex apply-macro-to-region-lines
- The command @kbd{M-x apply-macro-to-region-lines} repeats the last
-defined keyboard macro on each complete line within the current region.
-It does this line by line, by moving point to the beginning of the line
-and then executing the macro.
-
-@node Save Kbd Macro
-@subsection Naming and Saving Keyboard Macros
-
-@cindex saving keyboard macros
-@findex name-last-kbd-macro
- If you wish to save a keyboard macro for longer than until you define the
-next one, you must give it a name using @kbd{M-x name-last-kbd-macro}.
-This reads a name as an argument using the minibuffer and defines that name
-to execute the macro. The macro name is a Lisp symbol, and defining it in
-this way makes it a valid command name for calling with @kbd{M-x} or for
-binding a key to with @code{global-set-key} (@pxref{Keymaps}). If you
-specify a name that has a prior definition other than another keyboard
-macro, an error message is printed and nothing is changed.
-
-@findex insert-kbd-macro
- Once a macro has a command name, you can save its definition in a file.
-Then it can be used in another editing session. First, visit the file
-you want to save the definition in. Then use this command:
-
-@example
-M-x insert-kbd-macro @key{RET} @var{macroname} @key{RET}
-@end example
-
-@noindent
-This inserts some Lisp code that, when executed later, will define the
-same macro with the same definition it has now. (You need not
-understand Lisp code to do this, because @code{insert-kbd-macro} writes
-the Lisp code for you.) Then save the file. You can load the file
-later with @code{load-file} (@pxref{Lisp Libraries}). If the file you
-save in is your init file @file{~/.emacs} (@pxref{Init File}) then the
-macro will be defined each time you run Emacs.
-
- If you give @code{insert-kbd-macro} a numeric argument, it makes
-additional Lisp code to record the keys (if any) that you have bound to the
-keyboard macro, so that the macro will be reassigned the same keys when you
-load the file.
-
-@node Kbd Macro Query
-@subsection Executing Macros with Variations
-
-@kindex C-x q
-@findex kbd-macro-query
- Using @kbd{C-x q} (@code{kbd-macro-query}), you can get an effect
-similar to that of @code{query-replace}, where the macro asks you each
-time around whether to make a change. While defining the macro,
-type @kbd{C-x q} at the point where you want the query to occur. During
-macro definition, the @kbd{C-x q} does nothing, but when you run the
-macro later, @kbd{C-x q} asks you interactively whether to continue.
-
- The valid responses when @kbd{C-x q} asks are @key{SPC} (or @kbd{y}),
-@key{DEL} (or @kbd{n}), @key{RET} (or @kbd{q}), @kbd{C-l} and @kbd{C-r}.
-The answers are the same as in @code{query-replace}, though not all of
-the @code{query-replace} options are meaningful.
-
- These responses include @key{SPC} to continue, and @key{DEL} to skip
-the remainder of this repetition of the macro and start right away with
-the next repetition. @key{RET} means to skip the remainder of this
-repetition and cancel further repetitions. @kbd{C-l} redraws the screen
-and asks you again for a character to say what to do.
-
- @kbd{C-r} enters a recursive editing level, in which you can perform
-editing which is not part of the macro. When you exit the recursive
-edit using @kbd{C-M-c}, you are asked again how to continue with the
-keyboard macro. If you type a @key{SPC} at this time, the rest of the
-macro definition is executed. It is up to you to leave point and the
-text in a state such that the rest of the macro will do what you
-want.@refill
-
- @kbd{C-u C-x q}, which is @kbd{C-x q} with a numeric argument,
-performs a completely different function. It enters a recursive edit
-reading input from the keyboard, both when you type it during the
-definition of the macro, and when it is executed from the macro. During
-definition, the editing you do inside the recursive edit does not become
-part of the macro. During macro execution, the recursive edit gives you
-a chance to do some particularized editing on each repetition.
-@xref{Recursive Edit}.
-
- Another way to vary the behavior of a keyboard macro is to use a
-register as a counter, incrementing it on each repetition of the macro.
-@xref{RegNumbers}.
+@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 Key Bindings
@section Customizing Key Bindings
* Init Rebinding:: Rebinding keys with your init file, @file{.emacs}.
* Function Keys:: Rebinding terminal function keys.
* Named ASCII Chars:: Distinguishing @key{TAB} from @kbd{C-i}, and so on.
-* Non-ASCII Rebinding:: Rebinding non-ASCII characters such as Latin-1.
+* Non-ASCII Rebinding:: Rebinding non-@acronym{ASCII} characters such as Latin-1.
* Mouse Buttons:: Rebinding mouse buttons in Emacs.
* Disabling:: Disabling a command means confirmation is required
before it can be executed. This is done to protect
@kbd{C-x @key{SELECT}} is meaningful. If you make @key{SELECT} a prefix
key, then @kbd{@key{SELECT} C-n} makes sense. You can even mix mouse
events with keyboard events, but we recommend against it, because such
-sequences are inconvenient to type in.
+key sequences are inconvenient to use.
- As a user, you can redefine any key; but it might be best to stick to
-key sequences that consist of @kbd{C-c} followed by a letter. These
-keys are ``reserved for users,'' so they won't conflict with any
-properly designed Emacs extension. The function keys @key{F5} through
-@key{F9} are also reserved for users. If you redefine some other key,
-your definition may be overridden by certain extensions or major modes
-which redefine the same key.
+ As a user, you can redefine any key; but it is usually best to stick
+to key sequences that consist of @kbd{C-c} followed by a letter (upper
+or lower case). These keys are ``reserved for users,'' so they won't
+conflict with any properly designed Emacs extension. The function
+keys @key{F5} through @key{F9} are also reserved for users. If you
+redefine some other key, your definition may be overridden by certain
+extensions or major modes which redefine the same key.
@node Prefix Keymaps
@subsection Prefix Keymaps
you are binding the key you want:
@example
-Set key C-z to command:
+Set key C-z to command:
@end example
You can redefine function keys and mouse events in the same way; just
you can specify them in your @file{.emacs} file by using their Lisp
syntax. (@xref{Init File}.)
- The simplest method for doing this works for ASCII characters and
-Meta-modified ASCII characters only. This method uses a string to
+ The simplest method for doing this works for @acronym{ASCII} characters and
+Meta-modified @acronym{ASCII} characters only. This method uses a string to
represent the key sequence you want to rebind. For example, here's how
to bind @kbd{C-z} to @code{shell}:
@example
(global-set-key "\C-xl" 'make-symbolic-link)
+@end example
+
+ To put @key{TAB}, @key{RET}, @key{ESC}, or @key{DEL} in the
+string, you can use the Emacs Lisp escape sequences, @samp{\t},
+@samp{\r}, @samp{\e}, and @samp{\d}. Here is an example which binds
+@kbd{C-x @key{TAB}}:
+
+@example
+(global-set-key "\C-x\t" 'indent-rigidly)
+@end example
+
+ These examples show how to write some other special @acronym{ASCII} characters
+in strings for key bindings:
+
+@example
+(global-set-key "\r" 'newline) ;; @key{RET}
+(global-set-key "\d" 'delete-backward-char) ;; @key{DEL}
+(global-set-key "\C-x\e\e" 'repeat-complex-command) ;; @key{ESC}
@end example
When the key sequence includes function keys or mouse button events,
-or non-ASCII characters such as @code{C-=} or @code{H-a}, you must use
+or non-@acronym{ASCII} characters such as @code{C-=} or @code{H-a}, you must use
the more general method of rebinding, which uses a vector to specify the
key sequence.
the character as it would appear in a string.
Here are examples of using vectors to rebind @kbd{C-=} (a control
-character outside of ASCII), @kbd{H-a} (a Hyper character; ASCII doesn't
-have Hyper at all), @key{F7} (a function key), and @kbd{C-Mouse-1} (a
+character not in @acronym{ASCII}), @kbd{C-M-=} (not in @acronym{ASCII} because @kbd{C-=}
+is not), @kbd{H-a} (a Hyper character; @acronym{ASCII} doesn't have Hyper at
+all), @key{F7} (a function key), and @kbd{C-Mouse-1} (a
keyboard-modified mouse button):
@example
(global-set-key [?\C-=] 'make-symbolic-link)
+(global-set-key [?\M-\C-=] 'make-symbolic-link)
(global-set-key [?\H-a] 'make-symbolic-link)
(global-set-key [f7] 'make-symbolic-link)
(global-set-key [C-mouse-1] 'make-symbolic-link)
@end example
- You can use a vector for the simple cases too. Here's how to rewrite
-the first two examples, above, to use vectors:
+ You can use a vector for the simple cases too. Here's how to
+rewrite the first three examples above, using vectors to bind
+@kbd{C-z}, @kbd{C-x l}, and @kbd{C-x @key{TAB}}:
@example
(global-set-key [?\C-z] 'shell)
-
(global-set-key [?\C-x ?l] 'make-symbolic-link)
+(global-set-key [?\C-x ?\t] 'indent-rigidly)
+(global-set-key [?\r] 'newline)
+(global-set-key [?\d] 'delete-backward-char)
+(global-set-key [?\C-x ?\e ?\e] 'repeat-complex-command)
@end example
+@noindent
+As you see, you represent a multi-character key sequence with a vector
+by listing each of the characters 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}.
+
@node Function Keys
@subsection Rebinding Function Keys
@item @code{select}, @code{print}, @code{execute}, @code{backtab}
@itemx @code{insert}, @code{undo}, @code{redo}, @code{clearline}
-@itemx @code{insertline}, @code{deleteline}, @code{insertchar}, @code{deletechar},
+@itemx @code{insertline}, @code{deleteline}, @code{insertchar}, @code{deletechar}
Miscellaneous function keys.
@item @code{f1}, @code{f2}, @dots{} @code{f35}
key.
A key sequence which contains function key symbols (or anything but
-ASCII characters) must be a vector rather than a string. The vector
+@acronym{ASCII} characters) must be a vector rather than a string. The vector
syntax uses spaces between the elements, and square brackets around the
whole vector. Thus, to bind function key @samp{f1} to the command
@code{rmail}, write the following:
@end example
@node Named ASCII Chars
-@subsection Named ASCII Control Characters
+@subsection Named @acronym{ASCII} Control Characters
@key{TAB}, @key{RET}, @key{BS}, @key{LFD}, @key{ESC} and @key{DEL}
-started out as names for certain ASCII control characters, used so often
+started out as names for certain @acronym{ASCII} control characters, used so often
that they have special keys of their own. Later, users found it
convenient to distinguish in Emacs between these keys and the ``same''
control characters typed with the @key{CTRL} key.
- Emacs distinguishes these two kinds of input, when used with the X
-Window System. It treats the ``special'' keys as function keys named
-@code{tab}, @code{return}, @code{backspace}, @code{linefeed},
+ Emacs distinguishes these two kinds of input, when the keyboard
+reports these keys to Emacs. It treats the ``special'' keys as function
+keys named @code{tab}, @code{return}, @code{backspace}, @code{linefeed},
@code{escape}, and @code{delete}. These function keys translate
-automatically into the corresponding ASCII characters @emph{if} they
+automatically into the corresponding @acronym{ASCII} characters @emph{if} they
have no bindings of their own. As a result, neither users nor Lisp
programs need to pay attention to the distinction unless they care to.
If you do not want to distinguish between (for example) @key{TAB} and
-@kbd{C-i}, make just one binding, for the ASCII character @key{TAB}
+@kbd{C-i}, make just one binding, for the @acronym{ASCII} character @key{TAB}
(octal code 011). If you do want to distinguish, make one binding for
-this ASCII character, and another for the ``function key'' @code{tab}.
+this @acronym{ASCII} character, and another for the ``function key'' @code{tab}.
- With an ordinary ASCII terminal, there is no way to distinguish
+ With an ordinary @acronym{ASCII} terminal, there is no way to distinguish
between @key{TAB} and @kbd{C-i} (and likewise for other such pairs),
because the terminal sends the same character in both cases.
@node Non-ASCII Rebinding
-@subsection Non-ASCII Characters on the Keyboard
+@subsection Non-@acronym{ASCII} Characters on the Keyboard
+@cindex rebinding non-@acronym{ASCII} keys
+@cindex non-@acronym{ASCII} keys, binding
-If your keyboard has keys that send non-ASCII characters, such as
+If your keyboard has keys that send non-@acronym{ASCII} characters, such as
accented letters, rebinding these keys is a bit tricky. There are two
solutions you can use. One is to specify a keyboard coding system,
using @code{set-keyboard-coding-system} (@pxref{Specify Coding}).
@noindent
Type @kbd{C-q} followed by the key you want to bind, to insert @var{char}.
-If you don't specify the keyboard coding system, that approach won't
+Since this puts a non-@acronym{ASCII} character in the @file{.emacs}, you should
+specify the proper coding system for that file. @xref{Init Syntax}.
+Specify the same coding system for the file that you use for your
+keyboard.
+
+If you don't specify a keyboard coding system, that approach won't
work. Instead, you need to find out the actual code that the terminal
-sends. The easiest way to do this in Emacs is to create an empty buffer
-with @kbd{C-x b temp @key{RET}}, make it unibyte with @kbd{M-x
+sends. The easiest way to do this in Emacs is to create an empty
+buffer with @kbd{C-x b temp @key{RET}}, make it unibyte with @kbd{M-x
toggle-enable-multibyte-characters @key{RET}}, then type the key to
insert the character into this buffer.
(global-set-key [@var{decimal-code}] 'some-function)
@end example
-If you bind 8-bit characters like this in your init file, you my find it
+If you bind 8-bit characters like this in your init file, you may find it
convenient to specify that it is unibyte. @xref{Enabling Multibyte}.
@node Mouse Buttons
events, if it has no binding).
@vindex double-click-time
- The variable @code{double-click-time} specifies how long may elapse
-between clicks that are recognized as a pair. Its value is measured
-in milliseconds. If the value is @code{nil}, double clicks are not
-detected at all. If the value is @code{t}, then there is no time
-limit.
+ The variable @code{double-click-time} specifies how much time can
+elapse between clicks and still allow them to be grouped as a multiple
+click. Its value is in units of milliseconds. If the value is
+@code{nil}, double clicks are not detected at all. If the value is
+@code{t}, then there is no time limit. The default is 500.
+
+@vindex double-click-fuzz
+ The variable @code{double-click-fuzz} specifies how much the mouse
+can move between clicks still allow them to be grouped as a multiple
+click. Its value is in units of pixels on windowed displays and in
+units of 1/8 of a character cell on text-mode terminals; the default is
+3.
The symbols for mouse events also indicate the status of the modifier
keys, with the usual prefixes @samp{C-}, @samp{M-}, @samp{H-},
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.
+(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
@end example
If the value of the @code{disabled} property is a string, that string
-is included in the message printed when the command is used:
+is included in the message displayed when the command is used:
@example
(put 'delete-region 'disabled
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.
+
Whether a command is disabled is independent of what key is used to
invoke it; disabling also applies if the command is invoked using
@kbd{M-x}. Disabling a command has no effect on calling it as a
input processing; the keys that are looked up in keymaps contain the
characters that result from keyboard translation.
- Under X, the keyboard key named @key{DELETE} is a function key and is
-distinct from the ASCII character named @key{DEL}. @xref{Named ASCII
-Chars}. Keyboard translations affect only ASCII character input, not
-function keys; thus, the above example used under X does not affect the
-@key{DELETE} key. However, the translation above isn't necessary under
-X, because Emacs can also distinguish between the @key{BACKSPACE} key
-and @kbd{C-h}; and it normally treats @key{BACKSPACE} as @key{DEL}.
+ On a window system, the keyboard key named @key{DELETE} is a function
+key and is distinct from the @acronym{ASCII} character named @key{DEL}.
+@xref{Named ASCII Chars}. Keyboard translations affect only @acronym{ASCII}
+character input, not function keys; thus, the above example used on a
+window system does not affect the @key{DELETE} key. However, the
+translation above isn't necessary on window systems, because Emacs can
+also distinguish between the @key{BACKSPACE} key and @kbd{C-h}; and it
+normally treats @key{BACKSPACE} as @key{DEL}.
For full information about how to use keyboard translations, see
@ref{Translating Input,,,elisp, The Emacs Lisp Reference Manual}.
All the Emacs commands which parse words or balance parentheses are
controlled by the @dfn{syntax table}. The syntax table says which
characters are opening delimiters, which are parts of words, which are
-string quotes, and so on. Each major mode has its own syntax table
-(though sometimes related major modes use the same one) which it
-installs in each buffer that uses that major mode. The syntax table
-installed in the current buffer is the one that all commands use, so we
-call it ``the'' syntax table. A syntax table is a Lisp object, a
-char-table, whose elements are numbers.
+string quotes, and so on. It does this by assigning each character to
+one of fifteen-odd @dfn{syntax classes}. In some cases it specifies
+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
+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.
@kindex C-h s
@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
+ 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
@code{modify-syntax-entry} to set up that character's current syntax,
-and some English to explain that string if necessary.
+starting with the character which designates its syntax class, plus
+some English text to explain its meaning.
- For full information on the syntax table, see @ref{Syntax Tables,,
-Syntax Tables, elisp, The Emacs Lisp Reference Manual}.
+ A syntax table is actually a Lisp object, a char-table, whose
+elements are cons cells. For full information on the syntax table,
+see @ref{Syntax Tables,, Syntax Tables, elisp, The Emacs Lisp
+Reference Manual}.
@node Init File
@section The Init File, @file{~/.emacs}
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{Entering Emacs}).
+different user's init file (@pxref{Initial Options}).
+@cindex @file{default.el}, the default init file
There can also be a @dfn{default init file}, which is the library
named @file{default.el}, found via the standard search path for
libraries. The Emacs distribution contains no such library; your site
@code{inhibit-default-init} non-@code{nil}, then @file{default} is not
loaded.
+@cindex site init file
+@cindex @file{site-start.el}, the site startup file
Your site may also have a @dfn{site startup file}; this is named
-@file{site-start.el}, if it exists. Emacs loads this library before it
-loads your init file. To inhibit loading of this library, use the
-option @samp{-no-site-file}. @xref{Initial Options}.
+@file{site-start.el}, if it exists. Like @file{default.el}, Emacs
+finds this file via the standard search path for Lisp libraries.
+Emacs loads this library before it loads your init file. To inhibit
+loading of this library, use the option @samp{-no-site-file}.
+@xref{Initial Options}.
+
+ You can place @file{default.el} and @file{site-start.el} in any of
+the directories which Emacs searches for Lisp libraries. The variable
+@code{load-path} (@pxref{Lisp Libraries}) specifies these directories.
+Many sites put these files in the @file{site-lisp} subdirectory of the
+Emacs installation directory, typically
+@file{/usr/local/share/emacs/site-lisp}.
If you have a large amount of code in your @file{.emacs} file, you
should rename it to @file{~/.emacs.el}, and byte-compile it. @xref{Byte
sequences are mandatory.
@samp{\C-} can be used as a prefix for a control character, as in
-@samp{\C-s} for ASCII control-S, and @samp{\M-} can be used as a prefix for
+@samp{\C-s} for @acronym{ASCII} control-S, and @samp{\M-} can be used as a prefix for
a Meta character, as in @samp{\M-a} for @kbd{Meta-A} or @samp{\M-\C-a} for
@kbd{Control-Meta-A}.@refill
+@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
+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
+Coding}. This is because the defaults for decoding non-@acronym{ASCII} text might
+not yet be set up by the time Emacs reads those parts of your init file
+which use such strings, possibly leading Emacs to decode those strings
+incorrectly.
+
@item Characters:
Lisp character constant syntax consists of a @samp{?} followed by
either a character or an escape sequence starting with @samp{\}.
strings and characters are not interchangeable in Lisp; some contexts
require one and some contexts require the other.
+@xref{Non-ASCII Rebinding}, for information about binding commands to
+keys which send non-@acronym{ASCII} characters.
+
@item True:
@code{t} stands for `true'.
@code{nil} stands for `false'.
@item Other Lisp objects:
-Write a single-quote (') followed by the Lisp object you want.
+Write a single-quote (@code{'}) followed by the Lisp object you want.
@end table
@node Init Examples
Here an absolute file name is used, so no searching is done.
+@item
+@cindex loading Lisp libraries automatically
+@cindex autoload Lisp libraries
+Tell Emacs to find the definition for the function @code{myfunction}
+by loading a Lisp library named @file{mypackage} (i.e.@: a file
+@file{mypackage.elc} or @file{mypackage.el}):
+
+@example
+(autoload 'myfunction "mypackage" "Do what I say." t)
+@end example
+
+@noindent
+Here the string @code{"Do what I say."} is the function's
+documentation string. You specify it in the @code{autoload}
+definition so it will be available for help commands even when the
+package is not loaded. The last argument, @code{t}, indicates that
+this function is interactive; that is, it can be invoked interactively
+by typing @kbd{M-x myfunction @key{RET}} or by binding it to a key.
+If the function is not interactive, omit the @code{t} or use
+@code{nil}.
+
@item
Rebind the key @kbd{C-x l} to run the function @code{make-symbolic-link}.
Normally Emacs uses the environment variable @env{HOME} to find
@file{.emacs}; that's what @samp{~} means in a file name. But if you
-have done @code{su}, Emacs tries to find your own @file{.emacs}, not
-that of the user you are currently pretending to be. The idea is
-that you should get your own editor customizations even if you are
-running as the super user.
+run Emacs from a shell started by @code{su}, Emacs tries to find your
+own @file{.emacs}, not that of the user you are currently pretending
+to be. The idea is that you should get your own 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
otherwise, it looks up the home directory corresponding to that user
name in the system's data base of users.
@c LocalWords: backtab
+
+@ignore
+ arch-tag: c68abddb-4410-4fb5-925f-63394e971d93
+@end ignore
HCoop / bpt / emacs.git / blobdiff