github.com/PDP-10.its
1
0
Fork 0
mirror of https://github.com/PDP-10/its.git synced 2026-01-11 23:53:12 +00:00
Code Issues Releases Wiki Activity
PDP-10.its/doc/emacs1/emacs.guide
Lars Brinkhoff 3e5e037d13 Minimal EMACS install.
2016-11-22 09:56:46 +01:00

12937 lines
642 KiB
Plaintext
Executable File
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

MASSACHUSETTS INSTITUTE OF TECHNOLOGY
ARTIFICIAL INTELLIGENCE LABORATORY
AI Memo 554 2 October 1981
EMACS MANUAL FOR ITS USERSî EMACS MANUAL FOR ITS USERSî EMACS MANUAL FOR ITS USERS
BYî BYî BY
RICHARD M. STALLMANî RICHARD M. STALLMANî RICHARD M. STALLMAN
A REFERENCE MANUALî A REFERENCE MANUALî A REFERENCE MANUAL
FOR THE EXTENSIBLE, CUSTOMIZABLE, SELF-DOCUMENTINGî FOR THE EXTENSIBLE, CUSTOMIZABLE, SELF-DOCUMENTINGî FOR THE EXTENSIBLE, CUSTOMIZABLE, SELF-DOCUMENTING
REAL-TIME DISPLAY EDITORî REAL-TIME DISPLAY EDITORî REAL-TIME DISPLAY EDITOR
This manual corresponds to EMACS version 161
This report describes work done at the Artificial Intelligence
Laboratory of the Massachusetts Institute of Technology. Support
for the laboratory's research is provided in part by the Advanced
Research Projects Agency of the Department of Defense under
Office of Naval Research contract N00014-80-C-0505.î 1 EMACS Manual for ITS Users
PREFACEî PREFACEî PREFACE
This manual documents the use and simple customization of the
display editor EMACS with the ITS operating system. The reader
___î is not expected to be a programmer. Even simple customizations
do not require programming skill, but the user who is not
interested in customizing can ignore the scattered customization
hints.
This is primarily a reference manual, but can also be used as a
primer. However, I recommend that the newcomer first use the
on-line, learn-by-doing tutorial TEACHEMACS, by typing
:TEACHEMACS<cr> while in HACTRN. With it, you learn EMACS by
using EMACS on a specially designed file which describes
commands, tells you when to try them, and then explains the
results you see. This gives a more vivid introduction than a
printed manual.
On first reading, you need not make any attempt to memorize
chapters 1 and 2, which describe the notational conventions of
the manual and the general appearance of the EMACS display
screen. It is enough to be aware of what questions are answered
in these chapters, so you can refer back when you later become
interested in the answers. After reading the Basic Editing
chapter you should practice the commands there. The next few
chapters describe fundamental techniques and concepts that are
referred to again and again. It is best to understand them
thoroughly, experimenting with them if necessary.
To find the documentation on a particular command, look in the
index if you know what the command is. Both command characters
and function names are indexed. If you know vaguely what the
command does, look in the command summary. The command summary
contains a line or two about each command, and a cross reference
to the section of the manual that describes the command in more
detail; related commands are grouped together. There is also a
glossary, with a cross reference for each term.
Many user-contributed libraries accompany EMACS, and often then
have no documentation except their on-line self-documentation.
Browsing through the catalogue of libraries in this manual is a
good way to find out what is available.
This manual has in two versions, one for ITS, and one for
Twenex, DEC's "TOPS-20" system. Each version comes in three
forms: the published form, the LPT form, and the INFO form. You
can order the published form from the Publications Department ofî 2 EMACS Manual for ITS Users
the Artificial Intelligence lab for $3.25 per copy; be sure to
specify the ITS version or the Twenex version. The LPT form is
available on line as EMACS;EMACS GUIDE for printing on
unsophisticated hard copy devices such as terminals and line
printers. The INFO form is for on-line perusal with the INFO
program. All three forms are substantially the same.
EMACS is available for distribution for use on Tenex and Twenex
systems (It does not run on Bottoms-10, and the conversion would
not be easy). Mail us a 2400 foot mag tape if you want it. It
does not cost anything; instead, you must join the EMACS
software-sharing commune. The conditions of membership are that
you must send back any improvements you make to EMACS, including
any libraries you write, and that you must not redistribute the
system except exactly as you got it, complete. (You can also
distribute your customizations, separately.)
Please do not attempt to get a copy of EMACS, for yourself or
any one else, by dumping it off of your local system. It is
almost certain to be incomplete or inconsistent. It is pathetic
to hear from sites that received incomplete copies lacking the
sources, asking me years later whether sources are available. If
you wish to give away a copy of EMACS, copy a distribution tape
from MIT, or mail me a tape and get a new one.
For information on the underlying philosophy of EMACS and the
lessons learned from its development, write to me for a copy of
AI memo 519a, "EMACS, the Extensible, Customizable
Self-Documenting Display Editor", or send Arpanet mail to
RMS@MIT-AI.
Yours in hacking,
/ 2 \ 1/2
< X >
\ /
Richard M. Stallman
Artificial Intelligence Lab
545 Tech Square, Rm 913
Cambridge, MA 02139
(617) 253-6765î 3 EMACS Manual for ITS Users
INTRODUCTIONî INTRODUCTIONî INTRODUCTION
You are about to read about EMACS, an advanced,
self-documenting, customizable, extensible real-time display
editor.
We say that EMACS is a display editor because normally the text
being edited is visible on the screen and is updated
automatically as you type your commands. See section 1
[Display], page 5.
We call it a real-time editor because the display is updated
very frequently, usually after each character or pair of
characters you type. This minimizes the amount of information
you must keep in your head as you edit. See section 3 [Basic],
page 15.
We call EMACS advanced because it provides facilities that go
beyond simple insertion and deletion: filling of text; automatic
indentation of programs; viewing two files at once; and dealing
in terms of characters, words, lines, sentences, paragraphs, and
pages, as well as expressions and comments in several different
programming languages. It is much easier to type one command
meaning "go to the end of the paragraph" than to find the desired
spot with repetition of simpler commands.
Self-documenting means that at any time you can type a special
character, the "Help" key, to find out what your options are.
You can also use it to find out what any command does, or to find
all the commands that pertain to a topic. See section 7 [Help],
page 33.
Customizable means that you can change the definitions of EMACS
commands in little ways. For example, if you use a programming
language in which comments start with <** and end with **>, you
can tell the EMACS comment manipulation commands to use those
strings. Another sort of customization is rearrangement of the
command set. For example, if you prefer the four basic cursor
motion commands (up, down, left and right) on keys in a diamond
pattern on the keyboard, you can have it. See section 21.8
[Customization], page 132.
Extensible means that you can go beyond simple customization
and write entirely new commands, programs in the language TECO.
EMACS is an "on-line extensible" system, which means that it is
divided into many functions that call each other, any of which
can be redefined in the middle of an editing session. Any partî 4 EMACS Manual for ITS Users
of EMACS can be replaced without making a separate copy of all of
EMACS. Many already written extensions are distributed with
EMACS, and some (including DIRED, PAGE, PICTURE, SORT, TAGS, and
WORDAB) are documented in this manual. Although only a
programmer can write an extension, anybody can use it afterward.
Extension requires programming in TECO, a rather obscure
language. If you are clever and bold, you might wish to learn
how. See the file INFO;CONV, for advice on learning TECO. This
manual does not even try to explain how to write TECO programs,
but it does contain some notes that are useful primarily to the
extension writer.î 5 EMACS Manual for ITS Users
CHAPTER ONEî CHAPTER ONEî CHAPTER ONE
THE ORGANIZATION OF THE SCREENî THE ORGANIZATION OF THE SCREENî THE ORGANIZATION OF THE SCREEN
EMACS divides the screen into several areas, each of which
contains its own sorts of information. The biggest area, of
course, is the one in which you usually see the text you are
editing. The terminal's cursor usually appears in the middle of
_____î the text, showing the position of point, the location at which
__î editing takes place. While the cursor appears to point at a
_______î character, point should be thought of as between two characters;
______î it points before the character that the cursor appears on top of.
Terminals have only one cursor, and when output is in progress it
must appear where the typing is being done. This does not mean
that point is moving. It is only that EMACS has no way to show
you the location of point except when the terminal is idle.
The top lines of the screen are usually available for text but
_____ _______î are sometimes pre-empted by an error message, which says that
some command you gave was illegal or used improperly, or by
_______î typeout from a command (such as, a listing of a file directory).
Error messages are typically one line, end with a question mark,
and are accompanied by ringing the bell. Typeout generally has
none of those characteristics.
The error message or typeout appears there for your
information, but it is not part of the file you are editing, and
it goes away if you type any command. If you want to make it go
away immediately but not do anything else, you can type a Space.
(Usually a Space inserts itself, but when there is an error
message or typeout on the screen it does nothing but get rid of
that.) The terminal's cursor always appears at the end of the
error message or typeout, but this does not mean that point has
moved. The cursor moves back to the location of point after the
error message or typeout goes away.
If you type a question mark when an error message is on the
screen, you enter the EMACS error handler. You probably don't
want to do this unless you know how to write TECO programs. If
you do it by accident, C-] (the standard abort character) will
get you out. Enough said.
A few lines at the bottom of the screen compose what is called
____ ____î the echo area. The variable Echo Area Height controls how many
_______î lines long it is. Echoing means printing out the commands that
you type. EMACS commands are usually not echoed at all, but if
you pause for more than a second in the middle of a
multi-character command then all the characters typed so far areî 6 EMACS Manual for ITS Users
______î echoed. This is intended to prompt you for the rest of the
command. The rest of the command is echoed, too, as you type it.
This behavior is designed to give confident users optimum
response, while giving hesitant users maximum feedback.
EMACS also uses the echo area for reading and displaying the
arguments for some commands, such as searches, and for printing
brief information in response to certain commands.
1.1 The Mode Lineî 1.1 The Mode Lineî 1.1 The Mode Line
____ ____î The line above the echo area is known as the mode line. It is
the line that usually starts with "EMACS (something)". Its
purpose is to tell you anything that may affect the meaning of
your commands aside from the text itself.
Some EMACS commands read and process more commands. They are
__________ _________ _______ ______î known as subsystems or recursive editing levels. If you are
inside a subsystem or a recursive editing level, the mode line
tells you its name. Square brackets around the mode line
indicate a recursive editing level; See section 6.3 [Recursive
__________î Editing Levels], page 30. Parentheses indicate a minibuffer; See
section 23 [Minibuffer], page 156. Neither brackets nor
parentheses indicates a subsystem; See section 6.1 [Subsystems],
page 28.
Subsystems and recursive editing levels are advanced features,
and you will not initially be using them. When you are not
inside a subsystem or recursive editing level, we say that you
___ _____î are at top level; this implies that the characters you type are
interpreted as ordinary EMACS commands. When you are at top
level, the mode line tells you what file you are editing, where
you are in it, and what editing modes are enabled which may
affect the meaning of your commands. The top level mode line has
this format:
EMACS type (major minor) bfr: file (vrs) --pos-- *
____î type is usually not there. When it is there, it indicates that
the EMACS job you are using is not an ordinary one, in that it is
acting as the servant of some other job. A type of "LEDIT"
indicates an EMACS serving one or more Lisps, while a type of
"MAILT" indicates an EMACS that you got by asking for an "edit
escape" while composing mail to send. The type can also indicateî 7 EMACS Manual for ITS Users
a subsystem that is running, such as RMAIL. The type is stored
internally as a string in the variable Editor Type. The variable
is normally zero.
_____ _____ ____î major is always the name of the major mode you are in. At any
time, EMACS is in one and only one of its possible major modes.
The major modes available include Fundamental mode (which EMACS
starts out in), Text mode, Lisp mode, PASCAL mode, and others.
See section 20.1 [Major Modes], page 102, for details of how the
modes differ and how to select one. Sometimes the name of the
major mode is followed immediately with another name inside
_______î square-brackets ("[ - ]"). This name is called the submode. The
submode indicates that you are "inside" of a command that causes
your editing commands to be changed temporarily, but does not
____î change what text you are editing. A submode is a kind of
recursive editing level. See section 6.3 [Submodes], page 30.
_____ _____ _____î minor is a list of some of the minor modes that are turned on
at the moment. "Fill" means that Auto Fill mode is on. "Save"
means that Auto-saving is on. "Save(off)" means that Auto-saving
is on by default but turned off at the moment in this buffer.
"Atom" means that Atom Word mode is on. "Abbrev" means that Word
Abbrev mode is on. "Ovwrt" means that Overwrite mode is on. See
section 22.1 [Minor Modes], page 133, for more information.
"Def" means that a keyboard macro is being defined; although this
is not exactly a minor mode, it is still useful to be reminded
about. See section 22.8 [Keyboard Macros], page 152. "Narrow"
means that editing is currently restricted to only a part of the
buffer. See section 17 [Narrowing], page 93.
___ ______î bfr is the name of the currently selected buffer. Each buffer
has its own name and holds a file being edited; this is how EMACS
can hold several files at once. But at any time you are editing
________î only one of them, the selected buffer. When we speak of what
some command does to "the buffer", we are talking about the
currently selected buffer. Multiple buffers make it easy to
switch around between several files, and then it is very useful
that the mode line tells you which one you are editing at any
time. However, before you learn how to use multiple buffers, you
will always be in the buffer called "Main", which is the only one
that exists when EMACS starts up. If the name of the buffer is
the same as the first name of the file you are visiting, then the
buffer name is left out of the mode line. See section 14
[Buffers], page 83, for how to use more than one buffer in one
EMACS.
____î file is the name of the file that you are editing. It is the
last file that was visited in the buffer you are in. It is
_______ ______î followed, in parentheses, by the file version number mostî 8 EMACS Manual for ITS Users
recently visited or saved provided the second filename visited is
">", so that version numbers are allowed. "(R-O)" after the
_________î filename means that the file or buffer is read-only; a file
visited read-only will not be saved unless you insist, while a
read-only buffer does not allow you to alter its contents at all.
See section 13.1 [Visiting], page 69, for more information.
The star at the end of the mode line means that there are
changes in the buffer that have not been saved in the file. If
the file has not been changed since it was read in or saved,
there is no star.
___î pos tells you whether there is additional text above the top of
the screen, or below the bottom. If your file is small and it is
all on the screen, --pos-- is omitted. Otherwise, it is
--TOP-- if you are looking at the beginning of the file,
--BOT-- if you are looking at the end of the file, or
--nn%-- where nn is the percentage of the file above the top of
the screen.
Sometimes you will see --MORE-- instead of --nn%--. This
happens when typeout from a command is too long to fit on the
screen. It means that if you type a Space the next screenful of
information will be printed. If you are not interested, typing
anything but a Space will cause the rest of the output to be
discarded. Typing a Rubout will discard the output and do
nothing else. Typing any other command will discard the rest of
the output and also do the command. When the output is
discarded, "FLUSHED" is printed after the --MORE--.
If you are accustomed to other display editors, you may be
surprised that EMACS does not always display the page number and
line number of point in the mode line. This is because the text
is stored in a way that makes it difficult to compute this
information. Displaying them all the time would be too slow to
be borne. When you want to know the page and line number of
point, you must ask for the information with the M-X What Page
command. See section 18 [Pages], page 94. However, once you are
adjusted to EMACS, you will rarely have any reason to be
concerned with page numbers or line numbers.
If you set the variable Display Mode Line Inverse nonzero, then
the mode line is displayed in inverse video if the terminal you
are using supports it. See section 22.3 [Variables], page 137.
The libraries MODLIN and MODE2 allow you to customize the
information that is displayed in the mode line. MODLIN replaces
the standard EMACS mode line generation routines. MODE2 makes a
second mode line, above the first, whose contents are under yourî 9 EMACS Manual for ITS Users
control. Refer to the self-documentation of these libraries; See
section 22.2 [Libraries], page 135.î 10 EMACS Manual for ITS Users
CHAPTER TWOî CHAPTER TWOî CHAPTER TWO
CHARACTER SETS AND COMMAND INPUT CONVENTIONSî CHARACTER SETS AND COMMAND INPUT CONVENTIONSî CHARACTER SETS AND COMMAND INPUT CONVENTIONS
In this chapter we introduce the terminology and concepts used
to talk about EMACS commands. EMACS is designed to be used with
a kind of keyboard with two special shift keys which can type 512
different characters, instead of the 128 different characters
which ordinary ASCII keyboards can send. The terminology of
EMACS commands is formulated in terms of these shift keys. So
that EMACS can be used on ASCII terminals, we provide
two-character ASCII circumlocutions for the command characters
which are not ASCII.
2.1 The 9-bit Command Character Setî 2.1 The 9-bit Command Character Setî 2.1 The 9-bit Command Character Set
EMACS is designed ideally to be used with terminals whose
keyboards have a pair of shift keys, labeled "Control" and
"Meta", either or both of which can be combined with any
_______î character that you can type. These shift keys produce Control
____î characters and Meta characters, which are the editing commands of
EMACS. We name each of these characters by prefixing "Control-"
(or "C-"), "Meta-" (or "M-") or both to the basic character:
thus, Meta-F or M-F is the character which is F typed with the
Meta key held down. C-M-; is the Semicolon character with both
the Control and Meta keys. Control in the EMACS command
character set is not precisely the same as Control in the ASCII
character set, but the general purpose is the same.
There are 128 basic characters. Multiplied by the four
possibilities of the Control and Meta keys, this makes 512
characters in the EMACS command character set. So it is called
the 512-character set, to distinguish it from ASCII, which has
_____î only 128 characters. It is also called the 9-bit character set
because 9 bits are required to express a number from 0 to 511.
Note that the 512-character set is used only for keyboard
commands. Characters in files being edited with EMACS are ASCII
characters.
Sadly, most terminals do not have ideal EMACS keyboards. In
fact, the only ideal keyboards are at MIT. On nonideal
keyboards, the Control key is somewhat limited (it can only be
combined with some characters, not with all), and the Meta key
may not exist at all. We make it possible to use EMACS on a
nonideal terminal by providing two-character circumlocutions,î 11 EMACS Manual for ITS Users
made up of ASCII characters that you can type, for the characters
___î that you can't type. These circumlocutions start with a bit
______î prefix character; see below. For example, to use the Meta-A
command, you could type Altmode A. Also see the appendices for
more detailed information on what to do on your type of terminal.
Both the EMACS 9-bit character set and ASCII have Control
characters, but the 9-bit character set has more different ones.
In ASCII, only letters and a few punctuation marks can be made
into Control characters; in the 9-bit character set every
character has a Control version. For example, we have
Control-Space, Control-1, and Control-=. We also have two
different characters Control-A and Control-a! But they always do
the same thing in EMACS, so you can ignore the distinction
between them, unless you are doing customization. In practice,
you can forget all about the distinction between ASCII Control
and EMACS Control, except to realize that EMACS uses some
"Control" characters which ASCII keyboards cannot type.
In addition to the 9-bit command character set, there is one
additional EMACS command character called Help. It cannot be
combined with Control or Meta. Its use is to ask for
documentation, at any time. The Help character has its own key
on an ideal keyboard, but must be represented by something else
on other keyboards. The circumlocution we use is Control-_ H
(two characters). The code used internally for Help is 4110
(octal).
We have given some command characters special names which we
always capitalize. "Return" or "<cr>" stands for the carriage
return character, code 015 (all character codes are in octal).
Note that C-R means the character Control-R, never Return.
"Rubout" is the character with code 177, labeled "Delete" on some
keyboards. "Altmode" is the character with code 033, sometimes
labeled "Escape". Other command characters with special names
are Tab (code 011), Backspace (code 010), Linefeed (code 012),
Space (code 040), Excl ("!", code 041), Comma (code 054), and
Period (code 056). Control is represented in the numeric code
for a character by 200, and Meta by 400; thus, Meta-Period is
code 456 in the 9-bit character set.
2.2 Prefix Charactersî 2.2 Prefix Charactersî 2.2 Prefix Characters
A non-ideal keyboard can only send certain Control characters,
and may completely lack the ability to send Meta characters. To
use these commands on such keyboards, you need to useî 12 EMACS Manual for ITS Users
___ ______î two-character circumlocutions starting with a bit prefix
character which turns on the Control or Meta bit in the second
character. The Altmode character turns on the Meta bit, so
Altmode X can be used to type a Meta-X, and Altmode Control-O can
_______î be used to type a C-M-O. Altmode is known as the Metizer. Other
bit prefix characters are C-^ for Control, and C-C for Control
and Meta together. Thus, C-^ < is a way of typing a Control-<,
and C-C < can be used to type C-M-<. Because C-^ is awkward to
type on most keyboards, we have tried to minimize the number of
commands for which you will need it.
The bit prefix characters are simply commands which run the
functions ^R Prefix Control, ^R Prefix Meta, and ^R Prefix
Control-Meta.
There is another prefix character, Control-X which is used as
the beginning of a large set of two-character commands known as
___ ________î C-X commands. C-X is not a bit prefix character; C-X A is not a
circumlocution for any single character, and it must be typed as
two characters on any terminal. You can create new prefix
characters when you customize. See the file INFO;CONV, node
Prefix.
2.3 Commands, Functions, and Variablesî 2.3 Commands, Functions, and Variablesî 2.3 Commands, Functions, and Variables
Most of the EMACS commands documented herein are members of
this 9-bit character set. Others are pairs of characters from
that set. However, EMACS doesn't really implement commands
_________î directly. Instead, EMACS is composed of functions, which have
long names such as "^R Down Real Line" and definitions which are
________î programs that perform the editing operations. Then commands such
_______ ________î as C-N are connected to functions through the command dispatch
_____î table. When we say that C-N moves the cursor down a line, we are
glossing over a distinction which is unimportant for ordinary
use, but essential for customization: it is the function ^R Down
Real Line which knows how to move down a line, and C-N moves down
a line because it is connected to that function. We usually
ignore this subtlety to keep things simple. To give the
extension-writer the information he needs, we state the name of
the function which really does the work in parentheses after
mentioning the command name. For example: "C-N (^R Down Real
Line) moves the cursor down a line". In the EMACS wall chart,
the function names are used as a form of very brief documentation
for the command characters. See section 5.2 [Functions],
page 24.î 13 EMACS Manual for ITS Users
The "^R " which appears at the front of the function name is
simply part of the name. By convention, a certain class of
functions have names which start with "^R ".
While we are on the subject of customization information which
you should not be frightened of, it's a good time to tell you
_________î about variables. Often the description of a command will say "to
change this, set the variable Mumble Foo". A variable is a name
used to remember a value. EMACS contains many variables which
are there so that you can change them if you want to customize.
The variable's value is examined by some command, and changing
the value makes the command behave differently. Until you are
interested in customizing, you can ignore this information. When
you are ready to be interested, read the basic information on
variables, and then the information on individual variables will
make sense. See section 22.3 [Variables], page 137.
2.4 Notational Conventions for ASCII Charactersî 2.4 Notational Conventions for ASCII Charactersî 2.4 Notational Conventions for ASCII Characters
Control characters in files, your EMACS buffer, or TECO
programs, are ordinary ASCII characters. The special 9-bit
character set applies only to typing EMACS commands. ASCII
contains the printing characters, rubout, and some control
characters. Most ASCII control characters are represented in
this manual as uparrow or caret followed by the corresponding
^î non-control character: control-E is represented as |E.
Some ASCII characters have special names. These include tab
(011), backspace (010), linefeed (012), return (015), altmode
(033), space (040), and rubout (177). To make it clear whether
we are talking about a 9-bit character or an ASCII character, we
capitalize names of 9-bit characters and leave names of ASCII
characters in lower case. Note that the 9-bit characters Tab and
Control-I are different, but the ASCII characters tab and
control-I are the same.
Lines in files are separated by a sequence of two ASCII control
characters, carriage return followed by linefeed. This sequence
____î is called CRLF. Normally, EMACS treats this two-character
____ _________î sequence as if it were a single character, a line separator. A
_____î return or a linefeed which is not part of a CRLF is called stray.
EMACS usually treats them as part of the text of a line and
displays them as ^M and ^J. If the variable Display Overprinting
is zero, they display as actual carriage return or linefeed.
Most control characters when present in the EMACS buffer areî 14 EMACS Manual for ITS Users
^î displayed with a caret; thus, ^A for ASCII |A. Rubout is
displayed as ^?, because by stretching the meaning of "control"
it can be interpreted as ASCII control-?. A backspace is usually
displayed as ^H since it is ASCII control-H, because most
displays cannot do overprinting. If you want backspace and stray
return to display as overprinting, set the variable Display
Overprinting nonzero.
Altmode is the ASCII code 033, sometimes labeled "Escape" or
"Alt". Altmode is often represented by itself in this document
(remember, it is an ASCII character and can therefore appear in
files). It looks like this: $. On most terminals, altmode looks
just like the dollar sign character. If that's so on yours, you
should assume that anything you see in the on-line documentation
which looks like a dollar sign is really an altmode unless you
are specifically told it's a dollar sign. The dollar sign
character is not particularly important in EMACS and we will
rarely have reason to mention it.î 15 EMACS Manual for ITS Users
CHAPTER THREEî CHAPTER THREEî CHAPTER THREE
BASIC EDITING COMMANDSî BASIC EDITING COMMANDSî BASIC EDITING COMMANDS
We now give the basics of how to enter text, make corrections,
and save the text in a file. If this material is new to you, you
might learn it more easily by running the :TEACHEMACS program.
3.1 Inserting Textî 3.1 Inserting Textî 3.1 Inserting Text
To insert printing characters into the text you are editing,
just type them. When EMACS is at top level, all printing
characters you type are inserted into the text at the cursor
_____î (that is, at point), and the cursor moves forward. Any
characters after the cursor move forward too. If the text in the
buffer is FOOBAR, with the cursor before the B, then if you type
XX, you get FOOXXBAR, with the cursor still before the B.
To correct text you have just inserted, you can use Rubout.
______î Rubout deletes the character before the cursor (not the one that
_____î the cursor is on top of or under; that is the character after the
cursor). The cursor and all characters after it move backwards.
Therefore, if you type a printing character and then type Rubout,
they cancel out.
To end a line and start typing a new one, type Return
(Customizers, note: this runs the function ^R CRLF). Return
operates by inserting a line separator, so if you type Return in
the middle of a line, you break the line in two. Return really
inserts two characters, a carriage return and a linefeed (a
CRLF), but almost everything in EMACS makes them look like just
one character, which you can think of as a line-separator
character. For example, typing Rubout when the cursor is at the
beginning of a line rubs out the line separator before the line,
joining that line with the preceding line.
If you add too many characters to one line, without breaking it
with a Return, the line will grow to occupy two (or more) lines
on the screen, with a "!" at the extreme right margin of all but
the last of them. The "!" says that the following screen line is
____________î not really a distinct line in the file, but just the continuation
of a line too long to fit the screen.
Direct insertion works for printing characters and space, but
other characters act as editing commands and do not insertî 16 EMACS Manual for ITS Users
themselves. If you need to insert a control character, Altmode,
_____î Tab or Rubout, you must quote it by typing the Control-Q
(^R Quoted Insert) command first. See section 2 [Characters],
^î page 10. Inserting a |Z is harder because EMACS cannot even
receive the character; you must use the minibuffer as in Altmode
Altmode 26i Altmode Altmode. See section 23 [Minibuffer],
page 156.
3.2 Moving The Cursorî 3.2 Moving The Cursorî 3.2 Moving The Cursor
To do more than insert characters, you have to know how to move
the cursor. Here are a few of the commands for doing that.
C-A Move to the beginning of the line.
C-E Move to the end of the line.
C-F Move forward over one character.
C-B Move backward over one character.
C-N Move down one line, vertically. If you start in
the middle of one line, you end in the middle of
the next. From the last line of text, it creates
a new line.
C-P Move up one line, vertically.
C-L Clear the screen and reprints everything.
C-U C-L reprints just the line that the cursor is
on.
C-T Transpose two characters (the ones before and
after the cursor).
M-< Move to the top of your text.
M-> Move to the end of your text.
3.3 Erasing Textî 3.3 Erasing Textî 3.3 Erasing Text
Rubout Delete the character before the cursor.
C-D Delete the character after the cursor.
C-K Kill to the end of the line.
You already know about the Rubout command which deletes the
character before the cursor. Another command, Control-D, deletes
the character after the cursor, causing the rest of the text on
the line to shift left. If Control-D is typed at the end of a
line, that line and the next line are joined together.î 17 EMACS Manual for ITS Users
To erase a larger amount of text, use the Control-K command,
which kills a line at a time. If Control-K is done at the
beginning or middle of a line, it kills all the text up to the
end of the line. If Control-K is done at the end of a line, it
joins that line and the next line.
See section 9.1 [Killing], page 39, for more flexible ways of
killing text.
3.4 Filesî 3.4 Filesî 3.4 Files
The commands above are sufficient for creating text in the
EMACS buffer. The more advanced EMACS commands just make things
easier. But to keep any text permanently you must put it in a
____î file. Files are the objects which ITS uses for storing data for
communication between different programs or to hold onto for a
length of time. To tell EMACS to edit text in a file, choose a
________ ______î filename, such as FOO, and type C-X C-V FOO<cr>. This visits the
file FOO (actually, FOO > on your working directory) so that its
contents appear on the screen for editing. You can make changes,
____î and then save the file by typing C-X C-S. This makes the changes
permanent and actually changes the file FOO. Until then, the
changes are only inside your EMACS, and the file FOO is not
really changed. If the file FOO doesn't exist, and you want to
create it, visit it as if it did exist. When you save your text
with C-X C-S the file will be created.
Of course, there is a lot more to learn about using files. See
section 13 [Files], page 69.
3.5 Helpî 3.5 Helpî 3.5 Help
If you forget what a command does, you can find out with the
Help character. The Help character is Top-H if you have a Top
key, or Control-_ H (two characters!) otherwise. Type Help
followed by C and the command you want to know about. Help can
help you in other ways as well. See section 7 [Help], page 33.î 18 EMACS Manual for ITS Users
3.6 Using Blank Lines Can Make Editing Fasterî 3.6 Using Blank Lines Can Make Editing Fasterî 3.6 Using Blank Lines Can Make Editing Faster
C-O Insert one or more blank lines after the
cursor.
C-X C-O Delete all but one of many consecutive blank
lines.
It is much more efficient to insert text at the end of a line
than in the middle. So if you want to stick a new line before an
existing one, the best way is to make a blank line there first
and then type the text into it, rather than inserting the new
text at the beginning of the existing line and finally inserting
a line separator. Making the blank line first also makes the
meaning of the text clearer while you are typing it in.
To make a blank line, you can type Return and then C-B. But
there is a single character for this: C-O (Customizers: this is
the built-in function ^R Open Line). So, FOO Return is
equivalent to C-O FOO.
If you want to insert many lines, you can type many C-O's at
the beginning (or you can give C-O an argument to tell it how
many blank lines to make. See section 4 [Arguments], page 19,
for how). As you then insert lines of text, you will notice that
Return behaves strangely: it "uses up" the blank lines instead of
pushing them down.
If you don't use up all the blank lines, you can type C-X C-O
(the function ^R Delete Blank Lines) to get rid of all but one.
When point is on a blank line, C-X C-O replaces all the blank
lines around that one with a single blank line. When point is on
a nonblank line, C-X C-O deletes any blank lines following that
nonblank line.î 19 EMACS Manual for ITS Users
CHAPTER FOURî CHAPTER FOURî CHAPTER FOUR
GIVING NUMERIC ARGUMENTS TO EMACS COMMANDSî GIVING NUMERIC ARGUMENTS TO EMACS COMMANDSî GIVING NUMERIC ARGUMENTS TO EMACS COMMANDS
_______ ________î Any EMACS command can be given a numeric argument. Some
commands interpret the argument as a repetition count. For
example, giving an argument of ten to the C-F command (move
forward one character) moves forward ten characters. With these
commands, no argument is equivalent to an argument of 1.
Some commands care only about whether there is an argument, and
not about its value; for example, the command M-Q (^R Fill
Paragraph) with no arguments fills text, but with an argument
justifies the text as well.
Some commands use the value of the argument, but do something
peculiar when there is no argument. For example, the C-K
(^R Kill Line) command with an argument <n> kills <n> lines and
the line separators that follow them. But C-K with no argument
is special; it kills the text up to the next line separator, or,
if point is right at the end of the line, it kills the line
separator itself. Thus, two C-K commands with no arguments can
kill a nonblank line, just like C-K with an argument of one.
The fundamental way of specifying an argument is to use the C-U
(^R Universal Argument) command followed by the digits of the
argument. Negative arguments are allowed. Often they tell a
command to move or act backwards. A negative argument is entered
with C-U followed by a minus sign and the digits of the value of
the argument.
C-U followed by a character which is neither a digit nor a
minus sign has the special meaning of "multiply by four". It
multiplies the argument for the next command by four. Two such
C-U's multiply it by sixteen. Thus, C-U C-U C-F moves forward
sixteen characters. This is a good way to move forward "fast",
since it moves about 1/4 of a line on most terminals. Other
useful combinations are C-U C-N, C-U C-U C-N (move down a good
fraction of a screen), C-U C-U C-O (make "a lot" of blank lines),
and C-U C-K (kill four lines). With commands like M-Q that care
whether there is an argument but not what the value is, C-U is a
good way of saying "I want an argument".
A few commands treat a plain C-U differently from an ordinary
argument. A few others may treat an argument of just a minus
sign differently from an argument of -1. These unusual cases
will be described when they come up; they are always for reasons
of convenience of use.î 20 EMACS Manual for ITS Users
There are other, terminal-dependent ways of specifying
arguments. They have the same effect but may be easier to type.
See the appendix. If your terminal has a numeric keypad which
sends something recognizably different from the ordinary digits,
it is possible to program EMACS to allow use of the numeric
keypad for specifying arguments. The libraries VT52 and VT100
provide such a feature for those two types of terminals. See
section 22.2 [Libraries], page 135.
4.1 Autoarg Modeî 4.1 Autoarg Modeî 4.1 Autoarg Mode
Users of ASCII keyboards may prefer to use Autoarg mode.
Autoarg mode means that you don't need to type C-U to specify a
numeric argument. Instead, you type just the digits. Digits
followed by an ordinary inserting character are themselves
inserted, but digits followed by an Altmode or Control character
serve as an argument to it and are not inserted. A minus sign
can also be part of an argument, but only at the beginning. If
you type a minus sign following some digits, both the digits and
the minus sign are inserted.
To use Autoarg mode, set the variable Autoarg Mode nonzero.
See section 22.3 [Variables], page 137.
Autoargument digits echo at the bottom of the screen; the first
nondigit causes them to be inserted or uses them as an argument.
To insert some digits and nothing else, you must follow them with
a Space and then rub it out. C-G cancels the digits, while
Rubout inserts them all and then rubs out the last.î 21 EMACS Manual for ITS Users
CHAPTER FIVEî CHAPTER FIVEî CHAPTER FIVE
EXTENDED (META-X) COMMANDS AND FUNCTIONSî EXTENDED (META-X) COMMANDS AND FUNCTIONSî EXTENDED (META-X) COMMANDS AND FUNCTIONS
Not all EMACS commands are of the one or two character variety
you have seen so far. Most commands have long names composed of
English words. This is for two reasons: the long names are
easier to remember and more suggestive, and there are not enough
two-character combinations for every command to have one.
________ ________î The commands with long names are known as extended commands
because they extend the set of two-character commands.
5.1 Issuing Extended Commandsî 5.1 Issuing Extended Commandsî 5.1 Issuing Extended Commands
M-X Begin an extended command. Follow by
command name and arguments.
C-M-X Begin an extended command. Follow by the
command name only; the command will ask
for any arguments.
C-X Altmode Re-execute recent extended command.
___ ________î Extended commands are also called M-X commands, because they
all start with the character Meta-X (^R Extended Command). The
M-X is followed by the command's long, suggestive name, actually
the name of a function to be called. Terminate the name of the
function with a Return (unless you are supplying string
arguments; see below). For example, Meta-X Auto Fill Mode<cr>
invokes the function Auto Fill Mode. This function when executed
turns Auto Fill mode on or off.
We say that M-X Foo<cr> "calls the function Foo". When
documenting the individual extended commands, we will call them
_________î functions to avoid confusion between them and the one or two
________î character commands. We will also use "M-X" as a title like "Mr."
for functions, as in "use M-X Foo". The "extended command" is
what you type, starting with M-X, and what the command does is
call a function. The name that goes in the command is the name
of the command and is also the name of the function, and both
terms will be used.
Note: Extended commands and functions were once called "MM
commands", but this term is obsolete. If you see it used either
in INFO documentation of in Help documentation, please report it.î 22 EMACS Manual for ITS Users
Ordinary one or two character commands used to be known as "^R"
commands; please report any occurrences of this obsolete term
also.
There are a great many functions in EMACS for you to call.
They will be described elsewhere in the manual, according to what
they do. Here we are concerned only with extended commands in
general.
5.1.1 Typing The Command Nameî 5.1.1 Typing The Command Nameî 5.1.1 Typing The Command Name
When you type M-X, the cursor moves down to the echo area at
the bottom of the screen. "M-X" is printed there, and when you
_______î type the command name it echoes there. This is known as reading
_ ____ __ ___ ____ ____î a line in the echo area. You can use Rubout to cancel one
character of the command name, or C-U or C-D to cancel the entire
command name. A C-G cancels the whole M-X, and so does a Rubout
when the command name is empty. These editing characters apply
any time EMACS reads a line in the echo area, not just within
M-X.
The string "M-X" which appears in the echo area is called a
______î prompt. The prompt always tells you what sort of argument is
required and what it is going to be used for; "M-X" means that
you are inside of the command M-X, and should type the name of a
function to be called. You can replace the prompt "M-X" with
some other string by defining the variable Read Command Prompt.
5.1.2 Completionî 5.1.2 Completionî 5.1.2 Completion
You can abbreviate the name of the command, typing only the
beginning of the name, as much as is needed to identify the
command unambiguously. You can also use completion on the
function name. This means that you type part of the command
name, and EMACS visibly fills in the rest, or as much as can be
determined from the part you have typed.
You request completion by typing an Altmode ($). For example,
if you type M-X Au$, the "Au" expands to "Auto " because all
command names which start with "Au" continue with "to ". If you
ask for completion when there are several alternatives for the
next character, the bell rings and nothing else happens. Altmode
is also the way to terminate the command name and begin the
string arguments, but it only does this if the command name
completes in full. In that case, an Altmode appears after theî 23 EMACS Manual for ITS Users
command name in the echo area. In practice, these two meanings
of Altmode do not conflict, because if the command name does not
complete in full, it is ambiguous and would not be accepted. So
it would be useless to type the arguments yet.
Space is another way to request completion, but it completes
only one word. Successive Spaces complete one word each, until
either there are multiple possibilities or the end of the name is
reached. If the first word of a command is Edit, List, Kill,
View or What, it is sufficient to type just the first letter and
complete it with a Space. (This does not follow from the usual
definition of completion, since the single letter is ambiguous;
it is a special feature added because these words are so common).
Typing "?" in the middle of the command name prints a list of
all the command names which begin with what you have typed so
far. You can then go on typing the name.
5.1.3 Numeric Arguments and String Argumentsî 5.1.3 Numeric Arguments and String Argumentsî 5.1.3 Numeric Arguments and String Arguments
Some functions can use numeric prefix arguments. Simply give
the Meta-X command an argument and Meta-X will pass it along to
the function which it calls. The argument appears before the
"M-X" in the prompt, as in "69 M-X", to remind you that the
function you call will receive a numeric argument.
______ _________î Some functions require string arguments (sometimes called
______ _________î suffix arguments). To specify string arguments, terminate the
function name with a single Altmode, then type the arguments,
separated by Altmodes. After the last argument, type a Return to
cause the function to be executed. For example, the function
Describe prints the full documentation of a function (or a
variable) whose name must be given as a string argument. An
example of using it is
Meta-X Describe$Apropos<cr>
which prints the full description of the function named Apropos.
An alternate way of calling extended commands is with the
command C-M-X (^R Instant Extended Command). It differs from
plain M-X in that the function itself reads any string arguments.
The function prompts for each argument individually. If an
argument is supposed to be a filename or a command name,
completion is available. However, there are compensatingî 24 EMACS Manual for ITS Users
disadvantages. For one thing, since the function has already
been invoked, you can't rub out from the arguments into the
function name. For another, it is not possible to save the whole
thing, function name and arguments, for you to recall with C-X
Altmode (see below). So C-M-X saves nothing for C-X Altmode.
The prompt for C-M-X is "C-M-X". You can override it with the
variable Instant Command Prompt.
5.1.4 Repeating an Extended Commandî 5.1.4 Repeating an Extended Commandî 5.1.4 Repeating an Extended Command
The last few extended commands you have executed are saved and
you can repeat them. We say that the extended command is saved,
rather than that the function is saved, because the whole
command, including arguments, is saved.
To re-execute a saved command, use the command C-X Altmode
(^R Re-execute Minibuffer). It retypes the last extended command
and asks for confirmation. With an argument, it repeats an
earlier extended command: 2 means repeat the next to the last
command, etc. You can also use the minibuffer to edit a previous
extended command and re-execute it with changes (See section 23
[Minibuffer], page 156.).
5.2 Arcane Information about M-X Commandsî 5.2 Arcane Information about M-X Commandsî 5.2 Arcane Information about M-X Commands
You can skip this section if you are not interested in
customization, unless you want to know what is going on behind
the scenes.
5.2.1 MMî 5.2.1 MMî 5.2.1 MM
Extended commands were once called "MM" commands, because "MM"
is a TECO expression which looks up a command name to find the
associated program, and runs that program. Thus, the TECO
expression
MM Apropos$Word$
means to run the Apropos command with the argument "word". You
could type this expression into a minibuffer and get the sameî 25 EMACS Manual for ITS Users
results as you would get from Meta-X Apropos$Word<cr>. In fact,
for the first year or so, EMACS had no Meta-X command, and that's
what people did. See section 23 [Minibuffer], page 156, for
information on the minibuffer.
"MM" actually tells TECO to call the subroutine in q-register
"M". The first "M" means "call", and the second "M" says what to
call. This subroutine takes a string argument which is the name
of a function and looks it up. Calling a function is built into
TECO, but looking up the name is not; it is implemented by the
program in q-register M. That's why "MM" is called that and not
^î "Run" or "F|Q".
5.2.2 Arguments in TECO Codeî 5.2.2 Arguments in TECO Codeî 5.2.2 Arguments in TECO Code
______ _________ _______î Functions can use one or two prefix arguments or numeric
_________î arguments. These are numbers (actually, TECO expressions) which
go before the "MM". Meta-X can only give the MM command one
argument. If you want to give it two, you must type it in using
the minibuffer. When TECO code passes prefix arguments, they
don't have to be numbers; they can also be string objects, TECO
buffer objects, etc. However, no more about that here.
______ _________ ______ _________î TECO code can also pass string arguments or suffix arguments.
When TECO code passes a string argument, it appears, terminated
by an Altmode, after the Altmode which ends the function name.
There can be any number of string arguments. In fact, the
function can decide at run time how many string arguments to
read. This makes it impossible to compile TECO code!
Since Altmode terminates a string argument, TECO has a quoting
convention to allow Altmodes to be part of a string argument.
^î This convention is to use the two characters |] Altmode to cause
^î just an Altmode to be part of the argument. |] also must be
^ ^î quoted, as |] |]. The M-X command hides all of this: there is no
way to quote an Altmode; every Altmode always terminates a string
^î argument; |] is not special, because M-X automatically replaces
^ ^î each |] with two. If you understand the TECO meaning of |] you
can enable its use in M-X command arguments by setting the
variable Quote Execute Command nonzero. Then M-X does no special
^î processing to |] characters. You can use them to quote Altmodes,
^î and you must also take care of quoting |] characters themselves.î 26 EMACS Manual for ITS Users
5.2.3 Commands and Functionsî 5.2.3 Commands and Functionsî 5.2.3 Commands and Functions
Actually, every command in EMACS simply runs a function. For
example, when you type the command C-N, it runs the function
"^R Down Real Line". You could just as well do C-U 1 M-X ^R Down
Real Line<cr> and get the same effect. C-N can be thought of as
a sort of abbreviation. We say that the command C-N has been
_________î connected to the function ^R Down Real Line. The name is looked
up once when the command and function are connected, so that it
does not have to be looked up again each time the command is
used. For historical reasons, the default argument passed to a
function which is connected to a command you typed is 1, but the
default for MM and for M-X is 0. This is why the C-U 1 was
necessary in the example above. The documentation for individual
EMACS commands usually gives the name of the function which
really implements the command in parentheses after the command
itself.
Just as any function can be called directly with M-X, so almost
any function can be connected to a command. You can use the
function Set Key to do this. Set Key takes the name of the
function as a string argument, then reads the character command
(including metizers or other prefix characters) directly from the
terminal. To define C-N, you could type
M-X Set Key$^R Down Real Line<cr>
and then type C-N. If you use the function View File often, you
could connect it to the command C-X V (not normally defined).
You could even connect it to the command C-M-V, replacing that
command's normal definition. Set Key is good for redefining
commands in the middle of editing. An init file or EVARS file
can do it each time you run EMACS. See section 22.6 [Init],
page 143.
5.2.4 Subroutinesî 5.2.4 Subroutinesî 5.2.4 Subroutines
EMACS is composed of a large number of functions, each with a
name. Some of these functions are connected to commands; some
are there for you to call with M-X; some are called by other
functions. The last group are called subroutines. They usually
have names starting with "&", as in "& Read Line", the subroutine
which reads a line in the echo area. Although most subroutines
have such names, any function can be called as a subroutine.î 27 EMACS Manual for ITS Users
Functions like ^R Down Real Line have names starting with ^R
because you are not expected to call them directly, either. The
purpose of the "&" or "^R" is to get those function names out of
the way of command completion in M-X. M-X allows the command
name to be abbreviated if the abbreviation is unique, and the
commands that you are not interested in might have names that
would interfere and make some useful abbreviation cease to be
unique. The funny characters at the front of the name prevent
this from happening.
5.2.5 Built-in Functionsî 5.2.5 Built-in Functionsî 5.2.5 Built-in Functions
Not all of the functions in EMACS are written in TECO. A few
of the most frequently used single-character commands have
definitions written in machine language. These include
self-inserting characters, Rubout, C-F, and others. Such
functions defined in machine language as part of TECO are called
________î built-in functions. Whereas the actual definition of an ordinary
function is a string, the definition of a built-in function is
just a number, the address of a routine in TECO. The EMACS
"definitions" of these commands exist only to give the commands
names and documentation, and live in a special library called
BARE which is loaded when necessary to make the names and
documentation available. For example, ^R Forward Character is
the name of the function which implements the C-F command.î 28 EMACS Manual for ITS Users
CHAPTER SIXî CHAPTER SIXî CHAPTER SIX
MOVING UP AND DOWN LEVELSî MOVING UP AND DOWN LEVELSî MOVING UP AND DOWN LEVELS
Subsystems and recursive editing levels are two states in which
you are temporarily doing something other than editing the
visited file as usual. For example, you might be editing a
message that you wish to send, or looking at a documentation file
with INFO.
6.1 Subsystemsî 6.1 Subsystemsî 6.1 Subsystems
_________î A subsystem is an EMACS function which is an interactive
program in its own right: it reads commands in a language of its
own, and displays the results. You enter a subsystem by typing
an EMACS command which invokes it. Once entered, the subsystem
runs until a specific command to exit the subsystem is typed. An
example of an EMACS subsystem is INFO, the documentation reading
program. Others are Backtrace and TDEBUG, used for debugging
TECO programs, and RMAIL and BABYL, used for reading and editing
mail files.
The commands understood by a subsystem are usually not like
EMACS commands, because their purpose is something other than
editing text. For example, INFO commands are designed for moving
around in a tree-structured documentation file. In EMACS, most
commands are Control or Meta characters because printing
characters insert themselves. In most subsystems, there is no
insertion of text, so non-Control non-Meta characters can be the
commands.
While you are inside a subsystem, the mode line usually gives
the name of the subsystem (as well as other information supplied
by the subsystem, such as the filename and node name in INFO).
You can tell that you are inside a subsystem because the mode
line does not start with "EMACS", or with an open bracket ("[")
which would indicate a recursive editing level. See section 1.1
[Mode Line], page 6.
Because each subsystem implements its own commands, we cannot
guarantee anything about them. However, there are conventions
for what certain commands ought to do:
C-] Aborts (exits without finishing up).î 29 EMACS Manual for ITS Users
Backspace Scrolls backward, like M-V in EMACS.
Space Scrolls forward, like C-V in EMACS.
Q Exits normally.
X Begins an extended command, like M-X in
EMACS.
Help or ? Prints documentation on the subsystem's
commands.
Not all of these necessarily exist in every subsystem, however.
6.2 Reading Mailî 6.2 Reading Mailî 6.2 Reading Mail
The easiest way to look at your new mail is to use M-X View
Mail. This displays the mail file with View File. See
section 13.7 [View File], page 79. To view someone else's mail,
give his user name as an argument to M-X View Mail.
When you want to edit your mail instead of just looking at it,
use C-X R (Read Mail). This invokes the mail reading subsystem
RMAIL. See the file INFO;RMAIL, node Top. If you prefer some
other mail reader, you can set the variable Mail Reader Library
to the name of the library to use.
You can send mail from within RMAIL as well as edit your mail.
But if you want to send just one message, the easiest way is
Control-X M (Send Mail). You edit the message, exit with C-M-C,
and the message is sent; or else you abort with C-]. C-X M works
by invoking RMAIL or whatever library you use to read mail at a
special entry point named & Mail Message. The same library used
for reading mail is used, normally, but you can specify a
different one by setting the variable Mail Sender Library.
The function Type Mailing List in the TMACS library is useful
for finding out where a mailing list forwards to. Invoke it with
M-X Run Library$TMACS$Type Mailing List$<mail address>
and the equivalences of the mail address will be printed. Type
Mailing List prints the immediate equivalences of the mailing
list you specify, then traces their equivalences, down to
terminal addresses or addresses on non-ITS machines. Mailing
lists on other ITS machines can be traced; simply include theî 30 EMACS Manual for ITS Users
site name in the argument. However, no lists on DM can be traced
because DM's forwarding data base is incompatible. See
section 22.2 [Libraries], page 135.
6.3 Recursive Editing Levelsî 6.3 Recursive Editing Levelsî 6.3 Recursive Editing Levels
_________ _______ _____î A recursive editing level is a state in which part of the
execution of one command involves doing some editing. You may be
editing the file you are working on, or you may be editing
completely something totally different from what you were working
on at top level. Recursive editing levels are indicated in the
mode line by square brackets ("[" and "]").
For example, the command M-X Edit Options allows you to change
the settings of EMACS options. During the execution of this
command, you enter a recursive editing level in which you edit a
list of options names and values using the usual EMACS editing
commands. While this is going on, the mode line says "[Edit
Options]" to inform you that you are in a recursive editing level
____î and why. When you exit the recursive editing level, the Edit
Options command continues its work by looking at the changes you
have made in the list of options and changing the actual option
values accordingly. Only then is the original Edit Options
command finished.
_____î Alternatively, you can abort the recursive editing level, which
gets you out of the Edit Options command and back to top level,
without allowing the command to finish.
A recursive editing level differs from a subsystem in that the
commands are ordinary EMACS commands (though a handful may have
been changed slightly), whereas a subsystem defines its own
command language.
The text you edit inside a recursive editing level depends on
the command which invoked the recursive editing level. It could
be a list of options and values, or a list of tab stop settings,
syntax table settings, a message to be sent, or any text that you
might wish to compose.
Sometimes in a recursive editing level you edit text of the
file you are visiting, just as at top level. Why would this be?
Usually because a few commands are temporarily changed. For
example, Edit Picture in the PICTURE library defines commands
good for editing a picture made out of characters, then enters a
recursive editing level. When you exit, the specialî 31 EMACS Manual for ITS Users
picture-editing commands go away. Until then, the brackets in
the mode line serve to remind you that, although the text you are
editing is your file, all is not normal. See section 26
[PICTURE], page 183.
In any case, if the mode line says "[...]" you are inside a
recursive editing level, and the way to exit (send the message,
redefine the options, get rid of the picture-editing commands,
etc.) is with the command C-M-C (^R Exit). See section 6.4
[Exiting], page 31. If you change your mind about the command
(you don't want to send the message, or change your options,
etc.) then you should use the command C-] (Abort Recursive Edit)
to get out. See section 24.1 [Aborting], page 159.
Inside recursive editing levels, the help option Help R is
defined to print the full documentation of the command which
invoked the recursive editing level. The other normal Help
options are still available for asking about commands you want to
use while inside the recursive edit.
When the text in the mode line is surrounded by parentheses, it
__________î means that you are inside a Minibuffer. A minibuffer is a
special case of the recursive editing level. Like any other, it
can be aborted safely with C-]. See section 23 [Minibuffer],
page 156.
6.4 Exiting Levels; Exiting EMACSî 6.4 Exiting Levels; Exiting EMACSî 6.4 Exiting Levels; Exiting EMACS
C-X C-C Exit from EMACS to the superior job.
C-M-C Exit from EMACS or from a recursive editing
level.
The general EMACS command to exit is C-M-C (^R Exit). This
command is used to exit from a recursive editing level back to
the top level of EMACS, and to exit from EMACS at top level back
to HACTRN. If your keyboard does not have a Meta key, you must
type this command by means of a bit prefix character, as C-C C-C
or as Altmode C-C. Note carefully the difference between exiting
a recursive editing level and aborting it: exiting allows the
command which invoked the recursive editing level to finish its
job with the text as you have edited it, whereas aborting cancels
whatever the command was going to do. See section 24.1
[Aborting], page 159.
We cannot say in general how to exit a subsystem, since eachî 32 EMACS Manual for ITS Users
subsystem defines its own command language, but the convention is
to use the character "Q".
You can exit from EMACS back to the superior job, usually
HACTRN, at any time, even within a recursive editing level, with
the command C-X C-C (^R Return to Superior). If this is used
while you are inside a recursive editing level, then when EMACS
is re-entered you will still be inside the recursive editing
level.
Exiting EMACS does not normally save the visited file, because
it is not the case that users exit EMACS only when they are
"finished editing". If you want the file saved, you must use C-X
C-S. Exiting does cause an auto save if Auto Save mode is in
use.
Exiting from EMACS runs the function & Exit EMACS. This
function executes the value of the variable Exit Hook, if it is
nonzero; otherwise, it does auto-save if Auto Save mode is on.
& Exit EMACS also executes the value of the variable Exit to
Superior Hook, if it is defined. If EMACS is continued, the
value of Return from Superior Hook is executed.î 33 EMACS Manual for ITS Users
CHAPTER SEVENî CHAPTER SEVENî CHAPTER SEVEN
SELF-DOCUMENTATION COMMANDSî SELF-DOCUMENTATION COMMANDSî SELF-DOCUMENTATION COMMANDS
EMACS provides extensive self-documentation features which
revolve around a single character, called the Help character. At
any time while using EMACS, you can type the Help character to
ask for help. How to type the Help character depends on the
terminal you are using, but aside from that the same character
always does the trick. If your keyboard has a key labeled Help
(above the H), type that key (together with the Top key).
Otherwise the way you type the Help character is actually C-_
(Control-Underscore) followed by an H (this is two characters to
type, but let's not worry about that). Whatever it is you have
to type, to EMACS it is just the Help character. On some
terminals just figuring out how to type a Control-Underscore is
hard! Typing Underscore and adding the Control key is what
logically ought to work, but on some terminals it does not.
Sometimes Control-Shift-O works. On VT-100 terminals, typing
Control-/ or Control-? sends a Control-_ character.
If you type Help while you are using a subsystem such as INFO,
it prints a list of the commands of that subsystem.
If you type Help in the middle of a multi-character command, it
often tells you about what sort of thing you should type next.
For example, if you type M-X and then Help, it tells you about
M-X and how to type the name of the command. If you finish the
function name and the Altmode and then type Help, it tells you
about the function you have specified so you can know what
arguments it needs. If you type C-X and then type Help, it tells
you about the C-X commands.
But normally, when it's time for you to start typing a new
command, Help offers you several options for asking about what
commands there are and what they do. It prompts with "Doc (? for
help):" at the bottom of the screen, and you should type a
character to say what kind of help you want. You could type Help
or "?" at this point to find out what options are available. The
ones you are most likely to need are described here.
The most basic Help options are Help C and Help D. You can use
them to ask what a particular command does. Help C is for
character commands; type the command you want to know about after
the Help and the "C" ("C" stands for Character). Thus, Help C
M-F or Help C Altmode F tells you about the M-F command. Help D
is for asking about functions (extended commands); type the name
of the function and a Return. Thus, Help D Lisp Mode<cr> tellsî 34 EMACS Manual for ITS Users
you about M-X Lisp Mode. Help D can also tell you the
documentation of a variable, if you give it a variable's name
instead of a function's name. "D" stands for "Describe", since
Help D actually uses the function Describe to do the work.
A more complicated sort of question to ask is, "what are the
commands for working with files?" For this, you can type Help A,
followed by the string "file" and a Return. It prints a list of
all the functions that have "file" anywhere in their names,
including Save All Files, ^R Save File, Append to File, etc. If
some of the functions are connected to commands, it tells you
that too. For example, it would say that you can invoke ^R Save
File by typing C-X C-S. "A" stands for "Apropos", since Help A
actually uses the function Apropos to do the substring matching.
Help A does not list internal functions, only those the
nonprogrammer is likely to use. If you want subroutines to be
listed as well, you must call Apropos yourself.
Because Apropos looks only for functions whose names contain
the string which you specify, you must use ingenuity in choosing
substrings. If you are looking for commands for killing
backwards and Help A Kill Backwards doesn't reveal any, don't
give up. Try just Kill, or just Backwards, or just Back. Be
persistent. Pretend you are playing Adventure.
Here is a set of Apropos strings that covers many classes of
EMACS commands, since there are strong conventions for naming the
standard EMACS commands. By giving you a feel for the naming
conventions, this set should also serve to aid you in developing
a technique for picking Apropos strings.
character, line, word, sentence, paragraph, region, page,
buffer, screen, window, bounds, file, dir, beginning,
end, case, mode, forward, backward, next, previous, up,
down, search, kill, delete, mark, fill, indent, change.
There is also a convention for how command names start for
certain common kinds of operations: many commands start with one
of the words "Edit", "View", "Insert", "List", or "What".
If you are inside a recursive editing level, Help R prints out
the complete documentation of that recursive editing level. See
section 6.3 [Recursive], page 30. Help ? also tells you briefly
what sort of recursive editing level you are in, in addition to
describing the available Help options. If you are not inside a
recursive editing level, Help R says that you are at top level.î 35 EMACS Manual for ITS Users
If something surprising happens, and you are not sure what
commands you typed, use Help L. Help L prints the last 60
command characters you typed in. This is also helpful if you
suffer from line noise. If you see commands that you don't know,
you can use Help C to find out what they do.
If a command doesn't do what you thought you knew it should do,
you can ask to see whether it has changed recently. Help N
prints out the file called EMACS;EMACS NEWS which is an archive
of announcements of changes to EMACS.
To find out about the other Help options, type Help Help. That
is, when the first Help asks for an option, type Help to ask what
is available.
Finally, you should know about the documentation files for
EMACS, which are EMACS;EMACS GUIDE and EMACS;EMACS CHART.
EMACS GUIDE is a version of the manual formatted to be printed
out on a terminal or line printer. EMACS CHART has a brief
description of all the commands, known as the wall chart, because
it is good to post on the wall near your terminal.î 36 EMACS Manual for ITS Users
CHAPTER EIGHTî CHAPTER EIGHTî CHAPTER EIGHT
THE MARK AND THE REGIONî THE MARK AND THE REGIONî THE MARK AND THE REGION
In general, a command which processes an arbitrary part of the
buffer must know where to start and where to stop. In EMACS,
___î such commands usually operate on the text between point and the
____ ___ ______î mark. This range of text is called the region. To specify a
region, you set point to one end of it and mark at the other. It
doesn't matter which one is set first chronologically, or which
one comes earlier in the text. Here are some commands for
setting the mark:
C-@ Set the mark where point is.
C-Space The same.
C-X C-X Interchange mark and point.
M-@ Set mark after end of next word. This
command and the following three do not move
point.
C-M-@ Set mark after end of next Lisp s-expression.
C-< Set mark at beginning of buffer.
C-> Set mark at end of buffer.
M-H Put region around current paragraph.
C-M-H Put region around current Lisp defun.
C-X H Put region around entire buffer.
C-X C-P Put region around current page.
For example, if you wish to convert part of the buffer to all
upper-case, you can use the C-X C-U command, which operates on
the text in the region. You can first go to the beginning of the
text to be capitalized, put the mark there, move to the end, and
then type C-X C-U. Or, you can set the mark at the end of the
text, move to the beginning, and then type C-X C-U. C-X C-U runs
the function ^R Uppercase Region, whose name signifies that the
region, or everything between point and the mark, is to be
capitalized.
The most common way to set the mark is with the C-@ command or
the C-Space command (^R Set/Pop Mark). They set the mark where
point is. Then you can move point away, leaving the mark behind.
It isn't actually possible to type C-Space on non-Meta
keyboards. Yet on many terminals the command appears to work
anyway! This is because trying to type a Control-Space on those
terminals actually sends the character C-@, which means the same
thing as C-Space. A few keyboards just send a Space. If you
have one of them, you type C-@, or customize your EMACS.î 37 EMACS Manual for ITS Users
Since terminals have only one cursor, there is no way for EMACS
to show you where the mark is located. You have to remember.
The usual solution to this problem is to set the mark and then
use it soon, before you forget where it is. But you can see
where the mark is with the command C-X C-X (^R Exchange Point and
Mark) which puts the mark where point was and point where the
mark was. The extent of the region is unchanged, but the cursor
and point are now at the previous location of the mark.
C-X C-X is also useful when you are satisfied with the location
of point but want to move the mark; do C-X C-X to put point there
and then you can move it. A second use of C-X C-X, if necessary,
puts the mark at the new location with point back at its original
location.
If you insert or delete before the mark, the mark may drift
through the text. If the buffer contains "FOO BAR" and the mark
is before the "B", then if you delete the "F" the mark will be
before the "A". This is an unfortunate result of the simple way
the mark is implemented. It is best not to delete or insert at
places above the mark until you are finished using it and don't
care where it drifts to.
8.1 Commands to Mark Textual Objectsî 8.1 Commands to Mark Textual Objectsî 8.1 Commands to Mark Textual Objects
There are commands for placing the mark on the other side of a
certain object such as a word or a list, without having to move
there first. M-@ (^R Mark Word) puts the mark at the end of the
next word, while C-M-@ (^R Mark Sexp) puts it at the end of the
next s-expression. C-> (^R Mark End) puts the mark at the end of
the buffer, while C-< (^R Mark Beginning) puts it at the
beginning. These characters allow you to save a little typing or
redisplay, sometimes.
Other commands set both point and mark, to delimit an object in
the buffer. M-H (^R Mark Paragraph) puts point at the beginning
of the paragraph it was inside of (or before), and puts the mark
at the end. M-H does all that's necessary if you wish to indent,
case-convert, or kill a whole paragraph. C-M-H (^R Mark Defun)
similarly puts point before and the mark after the current or
next defun. C-X C-P (^R Mark Page) puts point before the current
page (or the next or previous, according to the argument), and
mark at the end. The mark goes after the terminating page
delimiter (to include it), while point goes after the preceding
page delimiter (to exclude it). Finally, C-X H (^R Mark Whole
Buffer) makes the region the entire buffer by putting point at
the beginning and the mark at the end.î 38 EMACS Manual for ITS Users
8.2 The Ring of Marksî 8.2 The Ring of Marksî 8.2 The Ring of Marks
Aside from delimiting the region, the mark is also useful for
remembering a spot that you may want to go back to. To make this
feature more useful, EMACS remembers 16 previous locations of the
mark. Most commands that set the mark push the old mark onto
this stack. To return to a marked location, use C-U C-@ (or
C-U C-Space). This moves point to where the mark was, and
restores the mark from the stack of former marks. So repeated
use of this command moves point to all of the old marks on the
stack, one by one. Since the stack is actually a ring, enough
uses of C-U C-@ bring point back to where it was originally.
Insertion and deletion can cause the saved marks to drift, but
they will still be good for this purpose because they are
unlikely to drift very far.
Some commands whose primary purpose is to move point a great
distance take advantage of the stack of marks to give you a way
to undo the command. The best example is M-<, which moves to the
beginning of the buffer. It sets the mark first, so that you can
use C-U C-@ or C-X C-X to go back to where you were. Searches
sometimes set the mark; it depends on how far they move. Because
of this uncertainty, searches type out "^@" if they set the mark.
The normal situation is that searches leave the mark behind if
they move at least 500 characters, but you can change that value
since it is kept in the variable Auto Push Point Option. By
setting it to 0, you can make all searches set the mark. By
setting it to a very large number such as ten million, you can
prevent all searches from setting the mark. The string to be
typed out when this option does its thing is kept in the variable
Auto Push Point Notification.î 39 EMACS Manual for ITS Users
CHAPTER NINEî CHAPTER NINEî CHAPTER NINE
KILLING AND MOVING TEXTî KILLING AND MOVING TEXTî KILLING AND MOVING TEXT
The commonest way of moving or copying text with EMACS is to
kill it, and get it back again in one or more places. This is
very safe because the last several pieces of killed text are all
remembered, and it is versatile, because the many commands for
killing syntactic units can also be used for moving those units.
There are also other ways of moving text for special purposes.
9.1 Deletion and Killingî 9.1 Deletion and Killingî 9.1 Deletion and Killing
Most commands which erase text from the buffer save it so that
you can get it back if you change your mind, or move or copy it
____î to other parts of the buffer. These commands are known as kill
commands. The rest of the commands that erase text do not save
______î it; they are known as delete commands. The delete commands
include C-D and Rubout, which delete only one character at a
time, and those commands that delete only spaces or line
separators. Commands that can destroy significant amounts of
nontrivial data generally kill. The commands' names and
individual descriptions use the words "kill" and "delete" to say
which they do. If you do a kill command by mistake, you can use
the Undo command to undo it (See section 24.3 [Undo], page 163.).
C-D Delete next character.
Rubout Delete previous character.
M-\ Delete spaces and tabs around point.
C-X C-O Delete blank lines around the current
line.
M-^ Join two lines by deleting the CRLF and
any indentation.
C-K Kill rest of line or one or more lines.
C-W Kill region (from point to the mark).
M-D Kill word.
M-Rubout Kill word backwards.
C-X Rubout Kill back to beginning of sentence.
M-K Kill to end of sentence.
C-M-K Kill s-expression.
C-M-Rubout Kill s-expression backwards. î 40 EMACS Manual for ITS Users
9.1.1 Deletionî 9.1.1 Deletionî 9.1.1 Deletion
The most basic delete commands are C-D and Rubout. C-D deletes
the character after the cursor, the one the cursor is "on top of"
or "underneath". The cursor doesn't move. Rubout deletes the
character before the cursor, and moves the cursor back. Line
separators act like single characters when deleted. Actually,
C-D and Rubout aren't always delete commands; if you give an
argument, they kill instead. This prevents you from losing a
great deal of text by typing a large argument to a C-D or Rubout.
The other delete commands are those which delete only
formatting characters: spaces, tabs and line separators. M-\
(^R Delete Horizontal Space) deletes all the spaces and tab
characters before and after point. C-X C-O (^R Delete Blank
Lines) deletes all blank lines after the current line, and if the
current line is blank deletes all blank lines preceding the
current line as well (leaving one blank line, the current line).
M-^ (^R Delete Indentation) joins the current line and the
previous line, or the current line and the next line if given an
argument. See section 11.3 [Indentation], page 54.
A function ^R Delete Region used to exist, but it was too
dangerous. When you want to delete a large amount of text
without saving a copy of it (perhaps because it is very big), you
can set point and mark around the text and then type
M-Altmode
MRK$$
(This is a use of the minibuffer. See section 23 [Minibuffer],
page 156.).
9.1.2 Killing by Linesî 9.1.2 Killing by Linesî 9.1.2 Killing by Lines
The simplest kill command is the C-K command (^R Kill Line).
If given at the beginning of a line, it kills all the text on the
line, leaving it blank. If given on a blank line, the blank line
disappears. As a consequence, if you go to the front of a
non-blank line and type two C-K's, the line disappears
completely.
More generally, C-K kills from point up to the end of the line,
unless it is at the end of a line. In that case it kills theî 41 EMACS Manual for ITS Users
line separator following the line, thus merging the next line
into the current one. Invisible spaces and tabs at the end of
the line are ignored when deciding which case applies, so if
point appears to be at the end of the line, you can be sure the
line separator will be killed.
If C-K is given a positive argument, it kills that many lines,
and the separators that follow them (however, text on the current
line before point is spared). With a negative argument, it kills
back to a number of line beginnings. An argument of -2 means
kill back to the second line beginning. If point is at the
beginning of a line, that line beginning doesn't count, so
C-U - 2 C-K with point at the front of a line kills the two
previous lines.
C-K with an argument of zero kills all the text before point on
the current line.
9.1.3 Other Kill Commandsî 9.1.3 Other Kill Commandsî 9.1.3 Other Kill Commands
A kill command which is very general is C-W (^R Kill Region),
which kills everything between point and the mark. With this
command, you can kill any contiguous characters, if you first set
the mark at one end of them and go to the other end.
Other syntactic units can be killed: words, with M-Rubout and
M-D (See section 11.1 [Words], page 50.); s-expressions, with
C-M-Rubout and C-M-K (See section 20.6.1 [S-expressions],
page 111.); sentences, with C-X Rubout and M-K (See section 11.2
[Sentences], page 52.).
9.2 Un-Killingî 9.2 Un-Killingî 9.2 Un-Killing
Un-killing is getting back text which was killed. The usual
way to move or copy text is to kill it and then un-kill it one or
more times.
C-Y Yank (re-insert) last killed text.
M-Y Replace re-inserted killed text with the
previously killed text.
M-W Save region as last killed text without killing.
C-M-W Append next kill to last batch of killed text. î 42 EMACS Manual for ITS Users
____ ______ ____ ____î Killed text is pushed onto a ring buffer called the kill ring
that remembers the last 8 blocks of text that were killed. (Why
it is called a ring buffer will be explained below). The command
C-Y (^R Un-kill) reinserts the text of the most recent kill. It
leaves the cursor at the end of the text, and puts the mark at
the beginning. Thus, a single C-W undoes the C-Y (M-X Undo also
does so). C-U C-Y leaves the cursor in front of the text, and
the mark after. This is only if the argument is specified with
just a C-U, precisely. Any other sort of argument, including C-U
and digits, has an effect described below.
If you wish to copy a block of text, you might want to use M-W
(^R Copy Region), which copies the region into the kill ring
without removing it from the buffer. This is approximately
equivalent to C-W followed by C-Y, except that M-W does not mark
the buffer as "changed" and does not temporarily change the
screen.
There is only one kill ring, and switching buffers or files has
no effect on it. After visiting a new file, whatever was last
killed in the previous file is still on top of the kill ring.
This is important for moving text between files.
9.2.1 Appending Killsî 9.2.1 Appending Killsî 9.2.1 Appending Kills
Normally, each kill command pushes a new block onto the kill
ring. However, two or more kill commands in a row combine their
text into a single entry on the ring, so that a single C-Y
command gets it all back as it was before it was killed. This
means that you don't have to kill all the text in one command;
you can keep killing line after line, or word after word, until
you have killed it all, and you can still get it all back at
once. (Thus we join television in leading people to kill
thoughtlessly).
Commands that kill forward from point add onto the end of the
previous killed text. Commands that kill backward from point add
onto the beginning. This way, any sequence of mixed forward and
backward kill commands puts all the killed text into one entry
without rearrangement.
If a kill command is separated from the last kill command by
other commands, it starts a new entry on the kill ring, unless
you tell it not to by saying C-M-W (^R Append Next Kill) in front
of it. The C-M-W tells the following command, if it is a kill
command, to append the text it kills to the last killed text,
instead of starting a new entry. With C-M-W, you can killî 43 EMACS Manual for ITS Users
several separated pieces of text and accumulate them to be yanked
back in one place.
9.2.2 Un-killing Earlier Killsî 9.2.2 Un-killing Earlier Killsî 9.2.2 Un-killing Earlier Kills
To recover killed text that is no longer the most recent kill,
you need the Meta-Y (^R Un-kill Pop) command. The M-Y command
should be used only after a C-Y command or another M-Y. It takes
the un-killed text inserted by the C-Y and replaces it with the
text from an earlier kill. So, to recover the text of the
next-to-the-last kill, you first use C-Y to recover the last
kill, and then use M-Y to move back to the previous kill.
You can think of all the last few kills as living in a ring.
After a C-Y command, the text at the front of the ring is also
present in the buffer. M-Y "rotates" the ring, bringing the
previous string of text to the front, and this text replaces the
other text in the buffer as well. Enough M-Y commands can rotate
any part of the ring to the front, so you can get at any killed
text as long as it is recent enough to be still in the ring.
Eventually the ring rotates all the way around and the most
recent killed text comes to the front (and into the buffer)
again. M-Y with a negative argument rotates the ring backwards.
If the region doesn't match the text at the front of the ring,
M-Y is not allowed.
In any case, when the text you are looking for is brought into
the buffer, you can stop doing M-Y's and it will stay there.
It's really just a copy of what's at the front of the ring, so
editing it does not change what's in the ring. And the ring,
once rotated, stays rotated, so that doing another C-Y gets
another copy of what you rotated to the front with M-Y.
If you change your mind about un-killing, a C-W or M-X Undo
gets rid of the un-killed text at any point, after any number of
M-Y's. C-W pushes the text onto the ring again. M-X Undo does
not.
If you know how many M-Y's it would take to find the text you
want, then there is an alternative. C-Y with an argument greater
than one restores the text the specified number of entries down
on the ring. Thus, C-U 2 C-Y gets the next to the last block of
killed text. It differs from C-Y M-Y in that C-U 2 C-Y does not
permanently rotate the ring.
A way of viewing the contents of the kill ring is î 44 EMACS Manual for ITS Users
M-X View Q-register$..K<cr>
You must add one to the indices listed by this command, to get
the argument to use with C-Y to yank any particular string.
9.3 Other Ways of Copying Textî 9.3 Other Ways of Copying Textî 9.3 Other Ways of Copying Text
Usually we copy or move text by killing it and un-killing it,
but there are other ways that are useful for copying one block of
text in many places, or for copying many scattered blocks of text
into one place. In addition to those described here, see the
self-documentation of the MOVE library.
9.3.1 Accumulating Textî 9.3.1 Accumulating Textî 9.3.1 Accumulating Text
You can accumulate blocks of text from scattered locations
either into a buffer or into a file if you like.
To append them into a buffer, use the command C-X A
<buffername><cr> (^R Append to Buffer), which inserts a copy of
the region into the specified buffer at the location of point in
that buffer. If there is no buffer with the name you specify,
one is created. If you append text into a buffer which has been
used for editing, the copied text goes into the middle of the
text of the buffer, wherever point happens to be in it.
Point in that buffer is left at the end of the copied text, so
successive uses of C-X A accumulate the text in the specified
buffer in the same order as they were copied. If C-X A is given
an argument, point in the other buffer is left before the copied
text, so successive uses of C-X A add text in reverse order.
You can retrieve the accumulated text from that buffer with M-X
Insert Buffer$<buffername><cr>. This inserts a copy of the text
in that buffer into the selected buffer. You can also select the
other buffer for editing. See section 14 [Buffers], page 83, for
background information on buffers.
Strictly speaking, C-X A does not always append to the text
already in the buffer. But if it is used on a buffer which
starts out empty, it does keep appending to the end.
Instead of accumulating text within EMACS, in a buffer, you canî 45 EMACS Manual for ITS Users
append text directly into a disk file with the command M-X Append
to File$<filename><cr>. It adds the text of the region to the
end of the specified file. M-X Prepend to File adds the text to
the beginning of the file instead. The file is changed
immediately on disk. These commands are normally used with files
that are not being visited in EMACS. They have the advantage of
working even on files too large to fit into the EMACS address
space.
9.3.2 Copying Text Many Timesî 9.3.2 Copying Text Many Timesî 9.3.2 Copying Text Many Times
When you want to insert a copy of the same piece of text
frequently, the kill ring becomes impractical, since the text
moves down on the ring as you edit, and will be in an
unpredictable place on the ring when you need it again. For this
case, you can use the commands C-X X (^R Put Q-register) and C-X
G (^R Get Q-register) to move the text.
C-X X<q> stores a copy of the text of the region in a place
called q-register <q>. With an argument, C-X X deletes the text
as well. <q> can be a letter or a digit. This gives 36 places
in which you can store a piece of text. C-X G<q> inserts in the
buffer the text from q-register <q>. Normally it leaves point
before the text and places the mark after, but with a numeric
argument it puts point after the text and the mark before.
The q-registers are important temporary variables in TECO
programming, but you don't have to understand them, only to know
that what you save with C-X X A is what you will get with C-X G
A.
Do not use q-registers M and R in this way, if you are going to
use the TECO commands MM and MR.î 46 EMACS Manual for ITS Users
CHAPTER TENî CHAPTER TENî CHAPTER TEN
SEARCHINGî SEARCHINGî SEARCHING
Like other editors, EMACS has commands for searching for an
occurrence of a string. The search command is unusual in that it
___________î is incremental; it begins to search before you have finished
typing the search string. As you type in the search string,
EMACS shows you where it would be found. When you have typed
enough characters to identify the place you want, you can stop.
Depending on what you will do next, you may or may not need to
terminate the search explicitly with an Altmode first.
C-S Search forward.
C-R Search backward.
C-S $ C-W Word search, ignoring whitespace.
The command to search is C-S (^R Incremental Search). C-S
reads in characters and positions the cursor at the first
occurrence of the characters that you have typed. If you type
C-S and then F, the cursor moves right after the first "F". Type
an "O", and see the cursor move to after the first "FO". After
another "O", the cursor is after the first "FOO" after the place
where you started the search. At the same time, the "FOO" has
echoed at the bottom of the screen.
If you type a mistaken character, you can rub it out. After
the FOO, typing a rubout makes the "O" disappear from the bottom
of the screen, leaving only "FO". The cursor moves back to the
"FO". Rubbing out the "O" and "F" moves the cursor back to where
you started the search.
When you are satisfied with the place you have reached, you can
type an Altmode, which stops searching, leaving the cursor where
the search brought it. Also, any command not specially
meaningful in searches stops the searching and is then executed.
Thus, typing C-A would exit the search and then move to the
beginning of the line. Altmode is necessary only if the next
command you want to type is a printing character, Rubout,
Altmode, C-Q, or another search command, since those are the
characters that have special meanings inside the search.
Sometimes you search for "FOO" and find it, but not the one you
expected to find. There was a second FOO that you forgot about,
before the one you were looking for. Then type another C-S and
the cursor will find the next FOO. This can be done any number
of times. If you overshoot, you can rub out the C-S's.î 47 EMACS Manual for ITS Users
After you exit a search, you can search for the same string
again by typing just C-S C-S: one C-S command to start the search
and then another C-S to mean "search again".
If your string is not found at all, the echo area says "Failing
I-Search". The cursor is after the place where EMACS found as
much of your string as it could. Thus, if you search for FOOT,
and there is no FOOT, you might see the cursor after the FOO in
FOOL. At this point there are several things you can do. If
your string was mistyped, you can rub some of it out and correct
it. If you like the place you have found, you can type Altmode
or some other EMACS command to "accept what the search offered".
Or you can type C-G, which throws away the characters that could
not be found (the "T" in "FOOT"), leaving those that were found
(the "FOO" in "FOOT"). A second C-G at that point undoes the
search entirely.
The C-G "quit" command does special things during searches;
just what, depends on the status of the search. If the search
has found what you specified and is waiting for input, C-G
cancels the entire search. The cursor moves back to where you
started the search. If C-G is typed while the search is actually
searching for something or updating the display, or after search
failed to find some of your input (having searched all the way to
the end of the file), then only the characters which have not
been found are discarded. Having discarded them, the search is
now successful and waiting for more input, so a second C-G will
cancel the entire search. Make sure you wait for the first C-G
to ding the bell before typing the second one; if typed too soon,
the second C-G may be confused with the first and effectively
lost.
You can also type C-R at any time to start searching backwards.
If a search fails because the place you started was too late in
the file, you should do this. Repeated C-R's keep looking for
more occurrences backwards. A C-S starts going forwards again.
C-R's can be rubbed out just like anything else. If you know
that you want to search backwards, you can use C-R instead of C-S
to start the search, because C-R is also a command (^R Reverse
Incremental Search) to search backward. Note to all customizers:
all this command does is call the current definition of
^R Incremental Search with a negative argument.
All sorts of searches in EMACS normally ignore the case of the
text they are searching through; if you specify searching for
FOO, then Foo and foo are also considered a match. If you do not
want this feature, set the variable Case Search to zero. See
section 22.3 [Variables], page 137.î 48 EMACS Manual for ITS Users
Recall that Altmode exits a search without doing anything else,
while other Control and Meta characters exit the search and then
have their normal function. The variable Search Exit Char says
which character should exit and do nothing else; its initial
value is 033 octal, for Altmode. This value is a 9-bit
character, so 300 octal means that Control-@ is the exit
character. Any other character whose definition indirects to the
specified one also serves as an exit character; so if you specify
C-B, C-b will also exit, and if you specify C-@, then C-Space
will also exit. Set the variable to -1, and there is no exit
character.
Bit prefix characters are not processed before the decision as
to whether and how to exit, so if you specify M-: as the exit
character, you must have a meta key on your terminal in order to
type it. I do not know if this can be changed easily.
Search Exit Option says what to do with other Control and Meta
characters. 0 says that they should be part of the search
string. A nonzero value says that they should exit and then have
their normal function. If this variable is nonzero, the Search
Exit Char is distinguished only by not having its normal function
when it exits. If this is zero, the Search Exit Char is the only
way to exit.
A non-incremental search is also available. Type Altmode (or
the Search Exit Char) right after the C-S to get it. Do
M-X Describe$^R String Search<cr>
for details. Some people who prefer non-incremental searches put
that function on Meta-S, and ^R Character Search (do M-X
Describe$ for details) on C-S. It can do one useful thing which
incremental search cannot: search for words regardless of where
the line breaks.
Word search searches for a sequence of words without regard to
how the words are separated. More precisely, you type a string
of many words, using single spaces to separate them, and the
string can be found even if there are multiple spaces or line
separators between the words. Other punctuation such as commas
or periods must match exactly. This is useful in conjunction
with documents formatted by text justifiers. If you edit while
looking at the printed, formatted version, you can't tell where
the line breaks are in the source file. With word search, you
can search without having to know.î 49 EMACS Manual for ITS Users
Word search is a special case of non-incremental search and is
invoked with C-S Altmode C-W. This is followed by the search
string, which must always be terminated with an Altmode.
Searching does not start until the final Altmode is typed.
Search Exit Char and Search Exit Option do not apply to word
search.
You do not even have to type each word in full, in a word
search. An abbreviation is good enough. Word search finds the
first occurrence of a sequence of words whose beginnings match
the words of the argument.î 50 EMACS Manual for ITS Users
CHAPTER ELEVENî CHAPTER ELEVENî CHAPTER ELEVEN
COMMANDS FOR ENGLISH TEXTî COMMANDS FOR ENGLISH TEXTî COMMANDS FOR ENGLISH TEXT
EMACS enables you to manipulate words, sentences, or paragraphs
of text. In addition, there are commands to fill text, and
convert case. For text-justifier input files, there are commands
that may help manipulate font change commands and underlining.
Editing files of text in a human language ought to be done
using Text mode rather than Fundamental mode. Invoke M-X Text
Mode to enter Text mode. See section 20.1 [Major Modes],
page 102. M-X Text Mode causes Tab to run the function ^R Tab to
Tab Stop, which allows you to set any tab stops with M-X Edit Tab
Stops (See section 11.3 [Indentation], page 54.). Features
concerned with comments in programs are turned off except when
explicitly invoked. Automatic display of parenthesis matching is
turned off, which is what most people want. Finally, the syntax
table is changed so that periods are not considered part of a
word, while apostrophes, backspaces and underlines are.
If you are editing input for the text justifier TEX, you might
want to use TEX mode instead of Text mode. See the file INFO;
ETEX. For editing SCRIBE input, use SCRIBE mode. See
section 11.8 [SCRIBE], page 61. Someday there may be special
major modes for other text justifiers.
11.1 Word Commandsî 11.1 Word Commandsî 11.1 Word Commands
EMACS has commands for moving over or operating on words. By
convention, they are all Meta- characters.
M-F Move Forward over a word.
M-B Move Backward over a word.
M-D Kill up to the end of a word.
M-Rubout Kill back to the beginning of a word.
M-@ Mark the end of the next word.
M-T Transpose two words; drag a word forward or
backward across other words.
Notice how these commands form a group that parallels the
character based commands C-F, C-B, C-D, C-T and Rubout. M-@ is
related to C-@.î 51 EMACS Manual for ITS Users
The commands Meta-F (^R Forward Word) and Meta-B (^R Backward
Word) move forward and backward over words. They are thus
analogous to Control-F and Control-B, which move over single
characters. Like their Control- analogues, Meta-F and Meta-B
move several words if given an argument. Meta-F with a negative
argument moves backward like Meta-B, and Meta-B with a negative
argument moves forward. Forward motion stops right after the
last letter of the word, while backward motion stops right before
the first letter.
It is easy to kill a word at a time. Meta-D (^R Forward Kill
Word) kills the word after point. To be precise, it kills
everything from point to the place Meta-F would move to. Thus,
if point is in the middle of a word, only the part after point is
killed. If some punctuation comes after point and before the
next word, it is killed along with the word. If you wish to kill
only the next word but not the punctuation, simply do Meta-F to
get the end, and kill the word backwards with Meta-Rubout.
Meta-D takes arguments just like Meta-F.
Meta-Rubout (^R Backward Kill Word) kills the word before
point. It kills everything from point back to where Meta-B would
move to. If point is after the space in "FOO, BAR", then "FOO, "
is killed. If you wish to kill just "FOO", then do a Meta-B and
a Meta-D instead of a Meta-Rubout.
Meta-T (^R Transpose Words) moves the cursor forward over a
word, dragging the word preceding or containing the cursor
forward as well. A numeric argument serves as a repeat count.
Meta-T with a negative argument undoes the effect of Meta-T with
a positive argument; it drags the word behind the cursor backward
over a word. An argument of zero, instead of doing nothing,
transposes the word at point (surrounding or adjacent to it) with
the word at mark. In any case, the delimiter characters between
the words do not move. For example, "FOO, BAR" transposes into
"BAR, FOO" rather than "BAR FOO,".
To operate on the next n words with an operation which applies
between point and mark, you can either set the mark at point and
then move over the words, or you can use the command
Meta-@ (^R Mark Word) which does not move point, but sets the
mark where Meta-F would move to. It can be given arguments just
like Meta-F.
Note that if you are in Atom Word mode and in Lisp mode, all
the word commands regard an entire Lisp atom as a single word.
See section 22.1 [Minor Modes], page 133.
The word commands' understanding of syntax is completelyî 52 EMACS Manual for ITS Users
controlled by the syntax table. Any character can, for example,
be declared to be a word delimiter. See section 22.4 [Syntax],
page 139.
11.2 Sentence and Paragraph Commandsî 11.2 Sentence and Paragraph Commandsî 11.2 Sentence and Paragraph Commands
The EMACS commands for manipulating sentences and paragraphs
are mostly Meta- commands, so as to resemble the word-handling
commands.
M-A Move back to the beginning of the sentence.
M-E Move forward to the end of the sentence.
M-K Kill forward to the end of the sentence.
M-[ Move back to previous paragraph beginning.
M-] Move forward to next paragraph end.
M-H Put point and mark around this paragraph (around
the following one, if between paragraphs).
C-X Rubout
Kill back to the beginning of the sentence.
11.2.1 Sentencesî 11.2.1 Sentencesî 11.2.1 Sentences
The commands Meta-A and Meta-E (^R Backward Sentence and
^R Forward Sentence) move to the beginning and end of the current
sentence, respectively. They were chosen to resemble Control-A
and Control-E, which move to the beginning and end of a line.
Unlike them, Meta-A and Meta-E if repeated or given numeric
arguments move over successive sentences. EMACS considers a
sentence to end wherever there is a ".", "?" or "!" followed by
the end of a line or two spaces, with any number of ")"'s, "]"'s,
"'"'s, or '"' 's allowed in between. Neither M-A nor M-E moves
past the CRLF or spaces which delimit the sentence.
Just as C-A and C-E have a kill command, C-K, to go with them,
so M-A and M-E have a corresponding kill command M-K (^R Kill
Sentence) which kills from point to the end of the sentence.
With minus one as an argument it kills back to the beginning of
the sentence. Larger arguments serve as a repeat count.
There is a special command, C-X Rubout (^R Backward Kill
Sentence) for killing back to the beginning of a sentence,
because this is useful when you change your mind in the middle of
composing text.î 53 EMACS Manual for ITS Users
11.2.2 Paragraphsî 11.2.2 Paragraphsî 11.2.2 Paragraphs
Meta-[ (^R Backward Paragraph) moves to the beginning of the
current or previous paragraph, while Meta-] (^R Forward
Paragraph) moves to the end of the current or next paragraph.
Blank lines and text justifier command lines separate paragraphs
and are not part of any paragraph. Also, an indented line starts
a new paragraph.
In major modes for programs (as opposed to Text mode),
paragraphs are determined only by blank lines. This makes the
paragraph commands continue to be useful even though there are no
paragraphs per se.
When there is a fill prefix, then paragraphs are delimited by
all lines which don't start with the fill prefix. See
section 11.4 [Filling], page 56.
When you wish to operate on a paragraph, you can use the
command Meta-H (^R Mark Paragraph) to set the region around it.
This command puts point at the beginning and mark at the end of
the paragraph point was in. Before setting the new mark at the
end, a mark is set at the old location of point; this allows you
to undo a mistaken Meta-H with two C-U C-@'s. If point is
between paragraphs (in a run of blank lines, or at a boundary),
the paragraph following point is surrounded by point and mark.
Thus, for example, Meta-H C-W kills the paragraph around or after
point.
One way to make an "invisible" paragraph boundary that does not
show if the file is printed is to put space-backspace at the
front of a line. The space makes the line appear (to the EMACS
paragraph commands) to be indented, which usually means that it
starts a paragraph.
The variable Paragraph Delimiter should be a TECO search string
(See section 19.3 [TECO search strings], page 101.) composed of
^î various characters or character sequences separated by |O's. A
line whose beginning matches the search string is either the
beginning of a paragraph or a text justifier command line part of
no paragraph. If the line begins with period, singlequote, "-",
"\" or "@", it can be a text justifier command line; otherwise,
it can be the beginning of a paragraph; but it cannot be either
one unless Paragraph Delimiter is set up to recognize it. Thus,
^î ".|O " as the Paragraph Delimiter string means that lines
starting with spaces start paragraphs, lines starting with
periods are text justifier commands, and all other nonblank lines
are nothing special.î 54 EMACS Manual for ITS Users
11.3 Indentation Commands for Textî 11.3 Indentation Commands for Textî 11.3 Indentation Commands for Text
Tab Indents "appropriately" in a mode-dependent
fashion.
M-Tab Inserts a tab character.
Linefeed Is the same as Return followed by Tab.
M-^ Undoes a Linefeed. Merges two lines.
M-M Moves to the line's first nonblank character.
M-I Indent to tab stop. In Text mode, Tab does
this also.
C-M-\ Indent several lines to same column.
C-X Tab Shift block of lines rigidly right or left.
The way to request indentation is with the Tab command. Its
precise effect depends on the major mode. In Text mode, it
indents to the next tab stop. You can set the tab stops with
Edit Tab Stops (see below). If you just want to insert a tab
character in the buffer, you can use M-Tab or C-Q Tab.
For English text, usually only the first line of a paragraph
should be indented. So, in Text mode, new lines created by Auto
Fill mode are not indented. Text mode tells Auto Fill mode not
to indent new lines by setting the variable Space Indent Flag to
zero.
But sometimes you want to have an indented paragraph. In such
cases, use M-X Edit Indented Text, which enters a submode in
which Tab and Auto Fill indent each line under the previous line,
and only blank lines delimit paragraphs. Alternatively, you can
specify a fill prefix (see below).
To undo a line-break, whether done manually or by Auto Fill,
use the Meta-^ (^R Delete Indentation) command to delete the
indentation at the front of the current line, and the line
boundary as well. They are replaced by a single space, or by no
space if before a ")" or after a "(", or at the beginning of a
line. To delete just the indentation of a line, go to the
beginning of the line and use Meta-\ (^R Delete Horizontal
Space), which deletes all spaces and tabs around the cursor.
To insert an indented line before the current line, do C-A,
C-O, and then Tab. To make an indented line after the current
line, use C-E Linefeed.
To move over the indentation on a line, do Meta-M or C-M-M
(^R Back to Indentation). These commands, given anywhere on a
line, position the cursor at the first nonblank character on the
line.î 55 EMACS Manual for ITS Users
There are also commands for changing the indentation of several
lines at once. Control-Meta-\ (^R Indent Region) gives each line
which begins in the region the "usual" indentation by invoking
Tab at the beginning of the line. A numeric argument specifies
the indentation, and each line is shifted left or right so that
it has exactly that much. C-X Tab (^R Indent Rigidly) moves all
of the lines in the region right by its argument (left, for
negative arguments). The whole group of lines move rigidly
sideways, which is how the command gets its name.
11.3.1 Tab Stopsî 11.3.1 Tab Stopsî 11.3.1 Tab Stops
For typing in tables, you can use Text mode's definition of
Tab, ^R Tab to Tab Stop, which may be given anywhere in a line,
and indents from there to the next tab stop. If you are not in
Text mode, this function can be found on M-I anyway.
Set the tab stops using Edit Tab Stops, which allows you to
edit some text which defines the tab stops. Here is what it
would look like for ordinary tab stops every eight columns.
: : : : : :
123456789 123456789 123456789 123456789 123456789 1234
0 10 20 30 40 50
The first line contains a colon or period at each tab stop.
Colon indicates an ordinary tab, which fills with whitespace; a
period specifies that characters be copied from the corresponding
columns of the second line below it. Thus, you can tab to a
column automatically inserting dashes or periods, etc. It is
your responsibility to put in the second line the text to be
copied. In the example above there are no periods, so the second
line is not used, and is left blank.
The third and fourth lines you see contain column numbers to
help you edit. They are only there while you are editing the tab
stops; they are not really part of the tab settings. The first
two lines reside in the variable Tab Stop Definitions when they
are not being edited. If the second line is not needed, Tab Stop
Definitions can be just one line, with no CRLFs. This makes it
easier to set the variable in a local modes list. See
section 22.7 [Locals], page 150.
EMACS normally uses both tabs and spaces to indent lines, andî 56 EMACS Manual for ITS Users
displays tab characters using eight-character tab stops. (How
the ASCII character tab is displayed has nothing to do with the
definition of the Tab character as a command). If you prefer,
all indentation can be made from spaces only. To request this,
turn off Indent Tabs mode with the command M-X Indent Tabs Mode.
To display tabs with different tab stops, set the TECO flag FS
TAB WIDTH$ to the desired interval. This is useful for
displaying files brought from other operating systems whose
normal tab stop spacing is not 8. See section 22.5 [FS Flags],
page 142.
To convert all tabs in a file to spaces, you can use M-X
Untabify. M-X Tabify performs the opposite transformation,
replacing spaces with tabs whenever possible, but only if there
are at least three of them so as not to obscure ends of
sentences. A numeric argument to Tabify or Untabify specifies
the interval between tab stops to use for computing how to change
the file. By default, they use the same interval being used for
display. The visual appearance of the text should never be
changed by Tabify or Untabify without a numeric argument.
11.4 Text Fillingî 11.4 Text Fillingî 11.4 Text Filling
Space in Auto Fill mode, breaks lines when appropriate.
M-Q Fill paragraph.
M-G Fill region (G is for Grind, by analogy with
Lisp).
M-S Center a line.
C-X = Show current cursor position.
______î Auto Fill mode lets you type in text that is filled (broken up
into lines that fit in a specified width) as you go. If you
alter existing text and thus cause it to cease to be properly
filled, EMACS can fill it again if you ask.
Entering Auto Fill mode is done with M-X Auto Fill. From then
on, lines are broken automatically at spaces when they get longer
than the desired width. New lines created by Auto Fill are
usually indented, but in Text mode they are not. To leave Auto
Fill mode, execute M-X Auto Fill again. When Auto Fill mode is
in effect, the word "Fill" appears in the mode line.
When you finish a paragraph, you can type Space with an
argument of zero. This doesn't insert any spaces, but it does
move the last word of the paragraph to a new line if it doesn'tî 57 EMACS Manual for ITS Users
fit in the old line. Return also moves the last word, but it may
create another blank line.
If you edit the middle of a paragraph, it may no longer be
correctly filled. To refill a paragraph, use the command Meta-Q
(^R Fill Paragraph). It causes the paragraph that point is
inside, or the one after point if point is between paragraphs, to
be refilled. All the line-breaks are removed, and then new ones
are inserted where necessary. M-Q can be undone with M-X Undo
(See section 24.3 [Undo], page 163.).
If you are not happy with Meta-Q's idea of where paragraphs
start and end (the same as Meta-H's. See section 11.2
[Paragraphs], page 52.), you can use Meta-G (^R Fill Region)
which refills everything between point and mark. Sometimes, it
is ok to fill a region of several paragraphs at once. Meta-G
recognizes a blank line or an indented line as starting a
paragraph and does not fill it in with the preceding line. The
sequence space-backspace at the front of a line prevents it from
being filled into the preceding line but is invisible when the
file is printed. However, the full sophistication of the
paragraph commands in recognizing paragraph boundaries is not
available. The purpose of M-G is to allow you to override
EMACS's usual criteria for paragraph boundaries. M-G can be
undone with M-X Undo.
Giving an argument to M-G or M-Q causes the text to be
_________î justified as well as filled. This means that extra spaces are
inserted between the words so as to make the right margin come
out exactly even. I do not recommend doing this. If someone
else has uglified some text by justifying it, you can unjustify
it (remove the spaces) with M-G or M-Q without an argument.
The command Meta-S (^R Center Line) centers a line within the
current line width. With an argument, it centers several lines
individually and moves past them.
The maximum line width for filling is in the variable Fill
Column. Both M-Q and Auto Fill make sure that no line exceeds
this width. The easiest way to set the variable is to use the
command C-X F (^R Set Fill Column), which places the margin at
the column point is on, or at the column specified by a numeric
argument. The fill column is initially column 70.
To fill a paragraph in which each line starts with a special
marker (which might be a few spaces, giving an indented
____ ______î paragraph), use the fill prefix feature. Move point to a spot
right after the special marker and give the command C-X Period
(^R Set Fill Prefix). Then, filling the paragraph will removeî 58 EMACS Manual for ITS Users
the marker from each line beforehand, and put the marker back in
on each line afterward. Auto Fill when there is a fill prefix
inserts the fill prefix at the front of each new line. Also, any
line which does not start with the fill prefix is considered to
start a paragraph. To turn off the fill prefix, do C-X Period
with point at the front of a line. The fill prefix is kept in
the variable Fill Prefix.
The command C-X = (What Cursor Position) can be used to find
out the column that the cursor is in, and other miscellaneous
information about point which is quick to compute. It prints a
line in the echo area that looks like this:
X=5 Y=7 CH=101 .=3874(35% of 11014) H=<3051,4640>
In this line, the X value is the column the cursor is in (zero at
the left), the Y value is the screen line that the cursor is in
(zero at the top), the CH value is the octal value of the
character after point (101 is "A"), the "point" value is the
number of characters in the buffer before point, and the values
in parentheses are the percentage of the buffer before point and
the total size of the buffer.
The H values are the virtual buffer boundaries, indicate which
part of the buffer is still visible when narrowing has been done.
If you have not done narrowing, the H values are omitted. For
more information about the virtual buffer boundaries, See
section 17 [Narrowing], page 93.
11.5 Case Conversion Commandsî 11.5 Case Conversion Commandsî 11.5 Case Conversion Commands
EMACS has commands for converting either a single word or any
arbitrary range of text to upper case or to lower case.
M-L Convert following word to lower case.
M-U Convert following word to upper case.
M-C Capitalize the following word.
C-X C-L Convert region to lower case.
C-X C-U Convert region to upper case.
The word conversion commands are the most useful. Meta-L
(^R Lowercase Word) converts the word after point to lower case,î 59 EMACS Manual for ITS Users
moving past it. Thus, successive Meta-L's convert successive
words. Meta-U (^R Uppercase Word) converts to all capitals
instead, while Meta-C (^R Uppercase Initial) puts the first
letter of the word into upper case and the rest into lower case.
All these commands convert several words at once if given an
argument. They are especially convenient for converting a large
amount of text from all upper case to mixed case, because you can
move through the text using M-L, M-U or M-C on each word as
appropriate.
When given a negative argument, the word case conversion
commands apply to the appropriate number of words before point,
but do not move point. This is convenient when you have just
typed a word in the wrong case. You can give the case conversion
command and continue typing.
If a word case conversion command is given in the middle of a
word, it applies only to the part of the word which follows the
cursor, treating it as a whole word.
The other case conversion commands are C-X C-U (^R Uppercase
Region) and C-X C-L (^R Lowercase Region), which convert
everything between point and mark to the specified case. Point
and mark do not move. These commands ask for confirmation if the
region contains more than Region Query Size characters; they also
save the original contents of the region so you can undo them
(See section 24.3 [Undo], page 163.).
11.6 Font-Changingî 11.6 Font-Changingî 11.6 Font-Changing
EMACS has commands to insert and move font change commands as
understood by the TJ6, R and BOLIO text justifiers. A font
^î change is assumed to be of the form |F<digit> meaning select the
^î specified font, or |F* meaning select the previously selected
font.
M-# Change previous word's font, or next word's.
C-X # Change font of region.
M-# (^R Change Font Word) is a command to change the font of a
word. Its action is rather complicated to describe, but that is
because it tries to be as versatile and convenient as possible in
practice.î 60 EMACS Manual for ITS Users
If you type M-# with an argument, the previous word is put into
the font specified by the argument. Point is not changed. This
means that, if you want to insert a word and put it in a specific
font, you can type the word, then use M-# to change its font, and
^î then go on inserting. The font is changed by putting a |F<digit>
^î before the word and a |F* after.
If you type M-# with no argument, it takes the last font change
^ ^î (either a |F<digit> or |F*, whichever is later) and moves it one
word forward. What this implies is that you can change the font
of several consecutive words incrementally by moving after the
first word, issuing M-# with an argument to set that word's font,
and then typing M-# to extend the font change past more words.
Each M-# advances past one more word.
M-# with a negative argument is the opposite of M-# with no
____î argument; it moves the last font change back one word. If you
type too many M-#'s, you can undo them this way. If you move one
font change past another, one or both are eliminated, so as to do
the right thing. As a result, M-Minus M-# will undo a M-# with
an argument. Try it!
You can also change the font of a whole region by putting point
and the mark around it and issuing C-X # (^R Change Font Region),
with the font number as argument. C-X # with a negative argument
removes all font changes inside or adjacent to the region.
11.7 Underliningî 11.7 Underliningî 11.7 Underlining
EMACS has two commands for manipulating text-justifier
underlining command characters. These commands do not produce
any sort of overprinting in the text file itself; they insert or
move command characters which direct text justifiers to produce
underlining. By default, commands for the text justifier R are
used.
M-_ Underline previous word or next word.
C-X _ Underline region.
M-_ is somewhat like M-# in that it either creates an underline
around the previous word or extends it past the next word.
However, where a font change requires that you specify a font
number, an underline is just an underline and has no parameter
for you to specify. Also, it is assumed that the textî 61 EMACS Manual for ITS Users
justifier's commands for starting and ending underlines are
distinguishable, whereas you can't tell from a font change
whether it is "starting" something or "ending" something. M-_
differs slightly from M-# as a result.
M-_ with no argument creates an underline around the previous
word if there is none. If there is an underline there, it is
extended one word forward. Thus, you can insert an underlined
word by typing the word and then a M-_. Or you can underline
several existing words by moving past the first of them, and
typing one M-_ for each word.
__î M-_ given in the vicinity of an underline-begin moves it
forward. Thus, it should be thought of as applying to any
boundary, where underlining either starts or stops, and moving it
forward. If a begin underlining is moved past an end, or vice
versa, they both disappear.
Giving M-_ an argument merely tells it to apply to several
words at once instead of one. M-_ with a positive argument of n
underlines the next n words, either creating an underlined area
or extending an existing one. With a negative argument, that
many previous words are underlined. Thus, M-_ can do more things
with underlines than M-# can do with font changes, because of the
facts that you don't need to use the argument to say which font,
and you can tell a beginning from an end.
For larger scale operations, you can use C-X _ to place
underlines from point to mark, or C-X _ with a negative argument
to remove all underlining between point and mark.
^ ^î By default, |B is used to begin an underline and |E is used to
end one. The variables Underline Begin and Underline End may be
created and set to strings to use instead. For a single
character you can use the numeric ASCII code for it.
11.8 SCRIBE Modeî 11.8 SCRIBE Modeî 11.8 SCRIBE Mode
SCRIBE mode provides many special editing commands for
manipulating the commands for the text justifier SCRIBE.
Instances of SCRIBE commands are referred to in EMACS as
____________î environments, though strictly speaking it is the command name
which is the environment, and not all commands either.
C-M-N Move forward over SCRIBE environment.î 62 EMACS Manual for ITS Users
C-M-P Move backward over SCRIBE environment.
C-M-U Move up to beginning of containing SCRIBE
environment.
C-M-D Move forward and down inside next SCRIBE
environment.
C-M-E Move up to end of containing SCRIBE
environment.
C-M-H Put point and mark around containing SCRIBE
environment.
C-M-G Change name of containing SCRIBE environment.
C-M-Q Change form of containing SCRIBE environment.
In SCRIBE mode the standard expression motion and killing
commands C-M-F, C-M-B, C-M-K and C-M-Rubout operate on units of
balanced SCRIBE delimiters. Additional commands specific to
SCRIBE mode move around the structure of SCRIBE environments.
C-M-N (^R Forward Environment) moves forward over an entire
SCRIBE expression (@, environment name and arguments), C-M-P
(^R Backward Environment) moves back, C-M-U (^R Backward Up
Environment) moves up, and C-M-D (^R Down Environment) moves
down. C-M-E (^R End of Environment) moves up to the end of the
containing SCRIBE environment. C-M-H (^R Mark Environment) puts
point and mark around the containing SCRIBE environment.
Speaking of balanced delimiters, SCRIBE mode does not work
properly when the characters ' and ` are used as delimiters for
arguments. This is because the parser expects each character to
be either a parenthesis (which matches a different character) or
a string quote (which matches itself), not both. See
section 22.4 [Syntax Table], page 139. SCRIBE mode simply does
not treat these characters as possible delimiters, and it is best
not to use them. It is just as well, since if SCRIBE mode
actually tried to handle these delimiters it would be confused by
apostrophes in the text.
Other commands transform SCRIBE environments. C-M-G (^R Change
Environment Name) changes the name of the SCRIBE environment that
point is inside. For example, if point is somewhere inside an
@I[...] environment, C-M-G could be used to change the @I to an
@U. C-M-G reads the new environment name from the terminal and
replaces the old environment name with it.
C-M-Q (^R Change Form) changes the containing SCRIBE
environment between the brief form such as @Example[...] and the
longer form @Begin(Example)...@End(Example). If the environment
has the brief form, it is changed to the longer form, and vice
versa.î 63 EMACS Manual for ITS Users
In SCRIBE mode, paragraphs are redefined to understand SCRIBE
commands in a way that is usually right. Any line that consists
entirely of one SCRIBE command is considered a
paragraph-separating line, just like a blank line. This does the
right thing for @Begin and @End, and for many other cases. So is
any line that starts with an @; or @' command. The @; and @'
commands are supposed to be no-ops at the beginning of a line,
and can therefore be used to mark lines that you think should
separate paragraphs. Which one works, and when, depends on the
version of SCRIBE. Eventually, @; will always work.
Aside from the above cases, SCRIBE commands are considered part
of the text, so an @I command which happens to end up at the
front of a line will not separate paragraphs. SCRIBE mode
accomplishes this by redefining M-[ and the function ^R Backward
Paragraph to be the function ^R Backward SCRIBE Paragraph. Lines
starting with page delimiters are paragraph delimiters as usual,
and lines starting with space or tab start paragraphs as usual.
The comment commands know that comments in SCRIBE files start
with "@Comment{" and end with "}". See section 20.5 [Comments],
page 107.
You can use the M-X Compile command to invoke SCRIBE. See
section 20.2 [Compile], page 103. It operates on the file
currently visited. You can use a string argument to specify
switches. After SCRIBE is finished, you must type $P to resume
EMACS. Then, if there were any errors, EMACS splits the screen
and displays the errors in the bottom window. The command M-X
Next Scribe Error moves to the point in the file at which the
next error occurred. Currently the only ITS machine on which
SCRIBE is installed is MC.
The functions listed in this section live in the library
SCRIBE, which is loaded automatically if you enter SCRIBE mode.
11.9 Dissociated Pressî 11.9 Dissociated Pressî 11.9 Dissociated Press
M-X Dissociated Press is a command for scrambling a file of
text either word by word or character by character. Starting
from a bufferfull of straight English, it produces extremely
amusing output. Dissociated Press prints its output on the
terminal. It does not change the contents of the buffer.
Dissociated Press operates by jumping at random from one point
in the buffer to another. In order to produce plausible outputî 64 EMACS Manual for ITS Users
rather than gibberish, it insists on a certain amount of overlap
between the end of one run of consecutive words or characters and
the start of the next. That is, if it has just printed out
"president" and then decides to jump to a different point in the
file, it might spot the "ent" in "pentagon" and continue from
there, producing "presidentagon". Long sample texts produce the
best results.
A negative argument to M-X Dissociated Press tells it to
operate character by character, and specifies the number of
overlap characters. A positive argument tells it to operate word
by word and specifies the number of overlap words. In this mode,
whole words are treated as the elements to be permuted, rather
than characters. No argument is equivalent to an argument of
two. For your againformation, the output is only printed on the
terminal. The file you start with is not changed.
Dissociated Press produces nearly the same results as a Markov
chain based on a frequency table constructed from the sample
text. It is, however, an independent, ignoriginal invention.
Dissociated Press techniquitously copies several consecutive
characters from the sample between random choices, whereas a
Markov chain would choose randomly for each word or character.
This makes for more plausible sounding results.
It is a mustatement that too much use of Dissociated Press can
be a developediment to your real work. Sometimes to the point of
outragedy. And keep dissociwords out of your documentation, if
you want it to be well userenced and properbose. Have fun. Your
buggestions are welcome.î 65 EMACS Manual for ITS Users
CHAPTER TWELVEî CHAPTER TWELVEî CHAPTER TWELVE
COMMANDS FOR FIXING TYPOSî COMMANDS FOR FIXING TYPOSî COMMANDS FOR FIXING TYPOS
In this section we describe the commands that are especially
useful for the times when you catch a mistake in your text just
after you have made it, or change your mind while composing text
on line.
Rubout Delete last character.
M-Rubout Kill last word.
C-X Rubout Kill to beginning of sentence.
C-T Transpose two characters.
C-X C-T Transpose two lines.
C-X T Transpose two arbitrary regions.
M-Minus M-L Convert last word to lower case.
M-Minus M-U Convert last word to all upper case.
M-Minus M-C Convert last word to lower case with
capital initial.
M-' Fix up omitted shift key on digit.
M-$ (Meta-Dollar Sign) Check and correct
spelling of word.
Correct Spelling
Check and correct spelling of entire
buffer.
12.1 Killing Your Mistakesî 12.1 Killing Your Mistakesî 12.1 Killing Your Mistakes
The Rubout command is the most important correction command.
When used among printing (self-inserting) characters, it can be
thought of as canceling the last character typed.
When your mistake is longer than a couple of characters, it
might be more convenient to use M-Rubout or C-X Rubout. M-Rubout
kills back to the start of the last word, and C-X Rubout kills
back to the start of the last sentence. C-X Rubout is
particularly useful when you are thinking of what to write as you
type it, in case you change your mind about phrasing. M-Rubout
and C-X Rubout save the killed text for C-Y and M-Y to retrieve
(See section 9.2 [Un-killing], page 41.).
M-Rubout is often useful even when you have typed only a few
characters wrong, if you know you are confused in your typing and
aren't sure exactly what you typed. At such a time, you cannotî 66 EMACS Manual for ITS Users
correct with Rubout except by looking at the screen to see what
you did. It requires less thought to kill the whole word and
start over again, especially if the system is heavily loaded.
12.2 Transpositionî 12.2 Transpositionî 12.2 Transposition
The common error of transposing two characters can be fixed,
when they are adjacent, with the C-T command. Normally, C-T
transposes the two characters on either side of the cursor. When
given at the end of a line, rather than transposing the last
character of the line with the line separator, which would be
useless, C-T transposes the last two characters on the line. So,
if you catch your transposition error right away, you can fix it
with just a C-T. If you don't catch it so fast, you must move
the cursor back to between the two transposed characters. If you
transposed a space with the last character of the word before it,
the word motion commands are a good way of getting there.
Otherwise, a reverse search (C-R) is often the best way. See
section 10 [Search], page 46.
To transpose two lines, use the C-X C-T command (^R Transpose
Lines). M-T transposes words and C-M-T transposes s-expressions.
A more general transpose command is C-X T (^R Transpose
Regions). This transposes two arbitrary blocks of text, which
need not even be next to each other. To use it, set the mark at
one end of one block, then at the other end of the block; then go
to the other block and set the mark at one end, and put point at
the other. In other words, point and the last three marks should
be at the four locations which are the ends of the two blocks.
It does not matter which of the four locations point is at, or
which order the others were marked. C-X T transposes the two
blocks of text thus identified, and relocates point and the three
marks without changing their order.
12.3 Case Conversionî 12.3 Case Conversionî 12.3 Case Conversion
A very common error is to type words in the wrong case.
Because of this, the word case-conversion commands M-L, M-U and
M-C have a special feature when used with a negative argument:
they do not move the cursor. As soon as you see you have
mistyped the last word, you can simply case-convert it and go on
typing. See section 11.5 [Case], page 58.î 67 EMACS Manual for ITS Users
Another common error is to type a special character and miss
the shift key, producing a digit instead. There is a special
command for fixing this: M-' (^R Upcase Digit), which fixes the
last digit before point in this way (but only if that digit
appears on the current line or the previous line. Otherwise, to
minimize random effects of accidental use, M-' does nothing).
Once again, the cursor does not move, so you can use M-' when you
notice the error and immediately continue typing. Because M-'
needs to know the arrangement of your keyboard, the first time
you use it you must supply the information by typing the row of
_______ ____ ___ _____ ___î digits 1, 2, ... , 9, 0 but holding down the shift key. This
tells M-' the correspondence between digits and special
characters, which is remembered for the duration of the EMACS in
the variable Digit Shift Table. This command is called M-'
because its main use is to replace "7" with a single-quote.
12.4 Checking and Correcting Spellingî 12.4 Checking and Correcting Spellingî 12.4 Checking and Correcting Spelling
When you write a paper, you should correct its spelling at some
point close to finishing it (and maybe earlier as well). To
correct the entire buffer, do M-X Correct Spelling. This invokes
the SPELL spelling corrector program, which will ask you what to
do with each misspelled word. Refer to its documentation. When
it finished, you will be back in EMACS.
To check the spelling of the word before point, and optionally
correct it as well, use the command M-$ (^R Correct Word
Spelling). This is a Dollar sign, not an Altmode! This command
sends the word to the SPELL program for correction.
If SPELL recognizes the word as a correctly spelled one
(although not necessarily the one you meant!) you will see "Found
it" or "Found it because of" followed by the word without its
suffix. If the program cannot at all recognize the word, it will
print "Couldn't find it."
If SPELL recognizes the word as a misspelling, it displays on
the screen the other words which are possibilities for the
correct spelling, and gives each one a number. Then, you can
type one of the following things:
0 to 9 Replace misspelled word with that spelling
(preserving case, just like Replace String
and Query Replace, unless Case Replace is
zero).î 68 EMACS Manual for ITS Users
Space Exit and make no changes.
% Read a digit as above and Query Replace (M-%)
the incorrect spelling with the correct one
from the beginning of the buffer.
No other responses are allowed.
The cursor need not be immediately after the word you want to
correct; it can be in the middle, or following any word-separator
characters after the end of the word. Note that the major mode
you are using affects which characters are word-separators. See
section 22.4 [Syntax Table], page 139.
The first time you use an EMACS spelling correction command, it
creates a SPELL job for you. From then on it uses the same SPELL
job. It's ok to kill the job if you don't think you'll be using
M-$ again during that session. But if you do leave the
job around checking words will much quicker. Giving M-$ a
negative argument (as in M-- M-$) kills the SPELL job. Of
course, you can kill it from DDT also.
If you are a regular user of the SPELL program, you might have
a dictionary file of words which you use but which are foreign to
SPELL. If there are words in this file which you might want to
use M-$ to correct, you can specify that you want this dictionary
to be loaded into the spell job which EMACS uses. To do this,
set the variable Spell Initialization to the string of
SPELL program commands you want to use. For loading a
dictionary, this string would be a "Load " followed by the
dictionary filename. Other initialization commands for SPELL can
appear there also. The commands must be separated by altmodes.
You can also pass arbitrary commands to the SPELL job with
command M-X Command to Spell.
Because of the way the handling of other jobs from EMACS is
implemented on ITS, it is not possible to use M-$ in an EMACS
whose superior is not DDT. This typically applies to EMACS jobs
running under LISP (LISPT) and under :MAIL (MAILT).î 69 EMACS Manual for ITS Users
CHAPTER THIRTEENî CHAPTER THIRTEENî CHAPTER THIRTEEN
FILE HANDLINGî FILE HANDLINGî FILE HANDLING
The basic unit of stored data is the file. Each program, each
paper, lives usually in its own file. To edit a program or
paper, the editor must be told the name of the file that contains
________î it. This is called visiting the file. To make your changes to
____î the file permanent on disk, you must save the file. EMACS also
has facilities for deleting files conveniently, and for listing
your file directory. Special text in a file can specify the
modes to be used when editing the file.
13.1 Visiting Filesî 13.1 Visiting Filesî 13.1 Visiting Files
C-X C-V Visit a file.
C-X C-Q Change regular visiting to read only, or vice
versa.
C-X C-S Save the visited file.
Meta-~ Tell EMACS to forget that the buffer has been
changed.
________î Visiting a file means copying its contents into EMACS where you
can edit them. EMACS remembers the name of the file you visited.
Unless you use the multiple buffer or window features of EMACS,
you can only be visiting one file at a time. The name of the
file you are visiting in the currently selected buffer is visible
in the mode line when you are at top level, followed by its
version number if it has one in parentheses.
The changes you make with EMACS are made in a copy inside
EMACS. The file itself is not changed. The changed text is not
____î permanent until you save it in a file. The first time you change
the text, a star appears at the end of the mode line; this
indicates that the text contains fresh changes which will be lost
unless you save them.
To visit a file, use the command C-X C-V (^R Visit File).
Follow the command with the name of the file you wish to visit,
terminated by a Return. If you can see a filename in the mode
line, then that name is the default, and any component of the
filename which you don't specify is taken from it. If EMACS
thinks you can't see the defaults, they are included in the
prompt. You can abort the command by typing C-G, or edit theî 70 EMACS Manual for ITS Users
filename with Rubout or C-U. If you do type a Return to finish
the command, the new file's text appears on the screen, and its
name and version appear in the mode line.
When you wish to save the file and make your changes permanent,
type C-X C-S (^R Save File). After the save is finished, C-X C-S
prints "Written: <filenames>" in the echo area at the bottom of
the screen. If there are no changes to save (no star at the end
of the mode line), the file is not saved; it would be redundant
to save a duplicate of the previous version.
Because a system crash can cause you to lose everything you
have done since the last save, we provide Auto Save mode, which
saves the files you are visiting at regular intervals
automatically. See section 13.3 [Auto Save], page 72.
Alternatively, you can use journal files. See section 24.4
[Journals], page 164.
What if you want to create a file? Just visit it. EMACS
prints "(New File)" but aside from that behaves as if you had
visited an existing empty file. If you make any changes and save
them, the file is created. If you visit a nonexistent file
unintentionally (because you typed the wrong file name), go ahead
and visit the file you meant. If you don't save the unwanted
file, it is not created.
If you visit a file which is a link, EMACS prints
"(Link to <filenames>)" to inform you of this. When you read a
file which is a link, you get the contents of the target file,
but if you save under the name of the link, you replace the link
and the target does not change. If you would prefer to alter the
target file, use Set Visited Filename to change the visited name
to the target file's name. See section 13.7 [Advanced File
Commands], page 79.
If you alter one file and then visit another in the same
buffer, EMACS offers to save the old one. If you answer Y, the
old file is saved; if you answer N, all the changes you have made
to it since the last save are lost. You should not type ahead
after a file visiting command, because your type-ahead might
answer an unexpected question in a way that you would regret.
The variable Visit File Save Old controls this offer; normally,
it is one, which means that the offer is made. If it is minus
one, then the old file is always saved when you visit a new one
in the same buffer; no question is asked. If it is zero, the old
file is never saved.
_________î A nonzero argument to C-X C-V specifies read-only visiting.
This means that EMACS prevents you from modifying the file unlessî 71 EMACS Manual for ITS Users
you insist. You should use this when you visit a file that you
do no want to change, just to avoid changing it accidentally. If
you give C-X C-V a positive argument, then the file is read-only.
This means you can change the text in the buffer, but EMACS
requires extra confirmation if you ask to save the file, and
never offers to save it. If you give C-X C-V a negative
argument, then the buffer itself is read-only; commands to change
the text are not allowed. If the visited file is visited
read-only, in either fashion, then the characters "(R-O)" appear
in the mode line after the filename. The command C-X C-Q (^R Set
File Read-Only) is used to switch between read-only and normal
visiting. Its numeric argument means the same thing as the
argument to C-X C-V: zero means changes are allowed, positive
makes the file read-only, and negative makes the text itself
read-only.
Sometimes you will change a buffer by accident. Even if you
undo the change by hand, EMACS still knows that "the buffer has
been changed". You can tell EMACS to believe that there have
been no changes with the Meta-~ (^R Buffer Not Modified) command.
This command simply clears the "modified" flag which says that
the buffer contains changes which need to be saved. Even if the
buffer really is changed EMACS will still act as if it were not.
If we take "~" to mean "not", then Meta-~ is "not" metafied.
If EMACS is about to do an unrequested save, and discovers that
the text is now a lot shorter than it used to be, it tells you so
and asks for confirmation (Y or N). If you aren't sure what to
answer (because you are surprised that it has shrunk), type C-G
to abort everything, and take a look around.
If EMACS is about to save a file and sees that the date of the
latest version on disk does not match what EMACS last read or
wrote, EMACS notifies you of this fact, and asks what to do,
because this probably means that something is wrong. For
example, someone else may have been editing the same file. If
this is so, there is a good chance that your work or his work
will be lost if you don't take the proper steps. You should
first find out exactly what is going on. The C-X C-D command to
list the directory will help. If you determine that someone else
has modified the file, save your file under different names (or
at least making a new version) and then SRCCOM the two files to
merge the two sets of changes. Also get in touch with the other
person so that he doesn't continue editing.î 72 EMACS Manual for ITS Users
13.2 How to Undo Drastic Changes to a Fileî 13.2 How to Undo Drastic Changes to a Fileî 13.2 How to Undo Drastic Changes to a File
If you have made extensive changes to a file and then change
your mind about them, you can get rid of them by reading in the
previous version of the file. To do this, use M-X Revert File.
If you have been using Auto Save mode, it reads in the last
version of the visited file or the last auto save file, whichever
is more recent.
In Auto Save mode, saving under special Auto Save filenames,
then you can ask to revert to the last "real" save, ignoring
subsequent auto saves, with C-U M-X Revert File. If you are
using the style of auto saving which saves under the real
filenames, this is not possible.
M-X Revert File does not change point, so that if the file was
only edited slightly, you will be at approximately the same piece
of text after the Revert as before. If you have made drastic
changes, the same value of point in the old file may address a
totally different piece of text.
Because M-X Revert File can be a disaster if done by mistake,
it asks for confirmation (Y or N) before doing its work. A
pre-comma argument can be used to inhibit the request for
confirmation when you call the function Revert File from a TECO
program, as in 1,M(M.M Revert File$).
13.3 Auto Save Mode: Protection Against Disastersî 13.3 Auto Save Mode: Protection Against Disastersî 13.3 Auto Save Mode: Protection Against Disasters
In Auto Save mode, EMACS saves your file from time to time
(based on counting your commands) without being asked. Your file
is also saved if you stop typing for more than a few minutes when
there are changes in the buffer. This prevents you from losing
more than a limited amount of work in a disaster. (Another
method of protection is the journal file. See section 24.4
[Journals], page 164.).
You can turn auto saving on or off in an individual buffer with
M-X Auto Save. In addition, you can have auto saving by default
in all buffers by setting the option Auto Save Default. The
frequency of saving, and the number of saved versions to keep,
can both be specified.
Each time you visit a file, no matter how, auto saving is
turned on for that file if Auto Save Default is nonzero. Onceî 73 EMACS Manual for ITS Users
you have visited a file, you can turn auto saving on or off with
M-X Auto Save. Like other minor mode commands, M-X Auto Save
turns the mode on with a positive argument, off with a zero or
negative argument; with no argument, it toggles. If you start
typing a new file into a buffer without visiting anything, Auto
Save mode is initially off, but you can turn it on with M-X Auto
Save.
When an auto save happens, "(Auto Save)" is printed in the echo
area (On a printing terminal, the bell is rung instead). An
error in the process of auto saving prints "(Auto Save Error!)".
Let us suppose that it is time for an automatic save to be
done: where should the file be saved?
Two workable methods have been developed: save the file under
the names you have visited, or save it under some special "auto
save file name". Each solution has its good and bad points. The
first one is excellent some of the time, but intolerable the rest
of the time. The second is usually acceptable. Auto saving
under the visited file's actual names means that you need do
nothing special to gobble the auto save file when you need it;
and it means that there is no need to worry about interference
between two users sharing a directory, as long as they aren't
editing the same file at once. However, this method can
sometimes have problems:
If you visit a file on a device other than DSK, auto
saves can't go there, because it would probably be slow.
If the file is visited read-only, then auto saves should
certainly not go under the names that are visited.
If your file does not have a numeric version number, or
you have visited a fixed version, auto saves can't go
under that name, because they would clobber the original
file.
If you haven't visited a file, there aren't any names to
use.
If none of those cases apply then it is possible to store auto
saves under the visited name. This is done, provided that you
enable it by setting the variable Auto Save Visited File to a
nonzero value. Otherwise, or if one of the cases listed above
applies, then the filename used for auto saves is taken from the
variable Auto Save Filenames, modified slightly so that differentî 74 EMACS Manual for ITS Users
buffers save under different names. If the last two characters
of the FN1 are "00", then they are replaced by the last two
digits (or the only digit) of the buffer number, the number which
appears at the beginning of each line printed by C-X C-B. Auto
Save Filenames is usually set up by the default init file to
DSK:<working directory>;_SAV00 >.
When you want to save your file "for real", use C-X C-S, as
always. C-U C-X C-S is a way to request an "auto" save
explicitly. When you are auto saving under the visited
filenames, there is not much difference between an auto save and
a "real" save, except that an auto save will eventually be
deleted automatically by EMACS a few auto saves later, while a
"real" save will be left around forever (at least, Auto Save
won't delete it).
When it is time to recover from a system crash by reloading the
auto save file, if auto saving was using the visited file names
you have nothing special to do. If auto saving was using special
auto save filenames, read in the last auto save file and then use
C-X C-W (Write File) to write it out in its real location. If
you want to go back to an auto save file to throw away changes
that you don't like, you can use M-X Revert File, which knows how
to find the most recent save, permanent or not, under whatever
filenames. See section 13.2 [Revert], page 72.
For your protection, if a file has shrunk by more than 30%
since the last save, auto saving does not save. Instead it
prints a message that the file has shrunk. You can save
explicitly if you wish; after that, auto saving will resume.
Although auto saving generates large numbers of files, it does
not clog directories, because it cleans up after itself. Only
the last Auto Save Max auto save files are kept; as further saves
are done, old auto saves are deleted. However, only files made
by auto saving (or by explicitly requested auto-saves with C-U
C-X C-S) are deleted in this way. If Auto Save Max is 1, then
repeated auto saves rewrite the same version of the file; the
version number is only incremented after a real save. (It will
write a new version if it is unable to rewrite the old one).
The variable Auto Save Max is initially 2. Changing the value
may not take effect in a given buffer until you turn auto saving
off and on in that buffer.
The number of characters of input between auto saves is
controlled by the variable Auto Save Interval. It is initially
500. Changing this takes effect immediately.î 75 EMACS Manual for ITS Users
If you use the multiple-buffer features of EMACS (See
section 14 [Buffers], page 83.) then you may want to have auto
saving for all buffers, not just the one that is selected at the
moment. To get this, set the variable Auto Save All Buffers
nonzero.
13.4 Listing a File Directoryî 13.4 Listing a File Directoryî 13.4 Listing a File Directory
To look at a part of a file directory, use the C-X C-D command
(^R Directory Display). With no argument, it shows you the file
you are visiting, and related files with the same first name.
C-U C-X C-D reads a filename from the terminal and shows you the
files related to that filename.
To see the whole directory in a brief format, use the function
List Files, which takes the directory name as a string argument.
The function View Directory prints a verbose listing of a whole
directory.
The variable Auto Directory Display can be set to make many
file operations display the directory automatically. The
variable is normally 0; making it positive causes write
operations such as Write File to display the directory, and
making it negative causes read operations such as Insert File or
visiting to display it as well. The display is done using the
default directory listing function which is kept in the variable
Directory Lister. Normally this is the function & Subset
Directory that displays only the files related to the current
default file. An alternative type of directory listing can be
obtained by setting Directory Lister to the function & Rotated
Directory Listing. After this function display the particular
file you are interested in, it offers to display the rest. If
you say "yes" (with a Space), it displays through the end of the
directory, and around to the beginning of the directory, stopping
where it originally started. See section 22.6 [Init], page 143.
The function List Directories prints an alphabetized list of
all the file directories on the system.
13.5 Cleaning a File Directoryî 13.5 Cleaning a File Directoryî 13.5 Cleaning a File Directory
The normal course of editing constantly creates new versions of
files. If you don't eventually delete the old versions, theî 76 EMACS Manual for ITS Users
directory will fill up and further editing will be impossible.
EMACS has commands that make it easy to delete the old versions.
For complete flexibility to delete precisely the files you want
to delete, you can use the DIRED package. See section 13.6
[DIRED], page 76, for more details.
M-X Reap File and M-X Clean Directory are more convenient ways
to do the usual thing: keep only the two (or other number) most
recent versions.
M-X Reap File$<file><cr> counts the number of versions of
<file>. If there are more than two, you are told the names of
the recent ones (to be kept) and the names of the older ones (to
be deleted), and asked whether to do the deletion (answer Y or
N).
Reap File makes a special offer to delete individual files
whose FN2 indicates that they are likely to be temporary. The
list of temporary names is contained in a TECO search string in
the variable Temp File FN2 List. See section 19.3 [TECO search
strings], page 101.
If you give M-X Reap File a null filename argument, or no
argument, then it applies to the file you are visiting.
M-X Clean Directory$<dirname>; <cr> cleans a whole directory of
old versions. Each file in the directory is processed a la M-X
Reap File. M-X Clean Directory with a null argument, or no
argument, cleans the directory containing the file you are
visiting.
M-X Reap File and M-X Clean Directory can be given a numeric
argument which specifies how many versions to keep. For example,
C-U 4 M-X Reap File would keep the four most recent versions.
The default when there is no argument is the value of the
variable File Versions Kept, which is initially 2.
13.6 DIRED, the Directory Editor Subsystemî 13.6 DIRED, the Directory Editor Subsystemî 13.6 DIRED, the Directory Editor Subsystem
DIRED makes it easy to delete many of the files in a single
directory at once. It presents a copy of a listing of the
directory, which you can move around in, marking files for
deletion. When you are satisfied, you can tell DIRED to go ahead
and delete the marked files.î 77 EMACS Manual for ITS Users
Invoke DIRED with M-X DIRED to edit the current default
directory, or M-X DIRED$<dir>;<cr> to edit directory <dir>. You
are then given a listing of the directory which you can move
around in with all the normal EMACS motion commands. Some EMACS
commands are made illegal and others do special things, but it's
still a recursive editing level which you can exit normally with
C-M-C and abort with C-].
13.6.1 Basic DIRED Commandsî 13.6.1 Basic DIRED Commandsî 13.6.1 Basic DIRED Commands
You can mark a file for deletion by moving to the line
describing the file and typing D, C-D, K, or C-K. The deletion
mark is visible as a D at the beginning of the line. Point is
moved to the beginning of the next line, so that several D's
delete several files. Alternatively, if you give D an argument
it marks that many consecutive files. Given a negative argument,
it marks the preceding file (or several files) and puts point at
the first (in the buffer) line marked. Most of the DIRED
commands (D, U, !, $, P, S, C, E, Space) repeat this way with
numeric arguments.
If you wish to remove a deletion mark, use the U (for Undelete)
command, which is invoked like D: it removes the deletion mark
from the current line (or next few lines, if given an argument).
The Rubout command removes the deletion mark from the previous
line, moving up to that line. Thus, a Rubout after a D precisely
cancels the D.
For extra convenience, Space is made a command similar to C-N.
Moving down a line is done so often in DIRED that it deserves to
be easy to type. Rubout is often useful simply for moving up.
If you are not sure whether you want to delete a file, you can
examine it by typing E. This enters a recursive editing mode on
the file, which you can exit with C-M-C. The file is not really
visited at that time, and you are not allowed to change it. When
you exit the recursive editing level, you return to DIRED. The V
command is like E but uses View File to look at the file.
When you have marked the files you wish to mark, you can exit
DIRED with C-M-C. If any files were marked for deletion, DIRED
lists them in a concise format, several per line. A file with
"!" appearing next to it in this list has not been saved on tape
and will be gone forever if deleted. A file with ">" in front of
it is the most recent version of a sequence and you should be
wary of deleting it. Then DIRED asks for confirmation of the
list. You can type "YES" (Just "Y" won't do) to go ahead andî 78 EMACS Manual for ITS Users
delete them, "N" to return to editing the directory so you can
change the marks, or "X" to give up and delete nothing. No
Return character is needed. No other inputs are accepted at this
point.
13.6.2 Other DIRED Commandsî 13.6.2 Other DIRED Commandsî 13.6.2 Other DIRED Commands
The "!" command moves down (or up, with an argument of -1) to
the next undumped file (one with a "!" before its date).
N finds the next "hog": the next file which has at least three
versions (or, more than File Versions Kept).
T when given on a line describing a link marks for deletion the
file which the link points to. This file need not be in the
directory you are editing to be deleted in this way.
1 copies the file you are pointing at to the primary pack. 2
copies it to SECOND:. 3 copies it to THIRD:. 4 copies it to
FOURTH:.
$ complements the don't-reap attribute of the file; this is
displayed as a dollar sign to the left of the file date.
M moves the file to any other directory or device. You must
say where to move it.
C runs SRCCOM to compare the file version you are pointing at
with the latest version of the same file. You must confirm the
SRCCOM command with a Return before it is executed; you can add
extra SRCCOM switches before the Return. When you return to
EMACS, the cursor moves down a line to the next file.
H helps you clean up. It marks "old" versions of the current
file, and versions with "temporary" second file names, for
deletion. You can then use the D and U commands to add and
remove marks before deleting the files. The variables File
Versions Kept and Temp File FN2 List control which files H picks
for deletion. With an argument (C-U H), it does the whole
directory instead of just the current file.
? displays a list of the DIRED commands.î 79 EMACS Manual for ITS Users
13.6.3 Invoking DIREDî 13.6.3 Invoking DIREDî 13.6.3 Invoking DIRED
There are some other ways to invoke DIRED. The command C-X D
(^R Dired) puts you in DIRED on the directory containing the file
you are currently editing. With a numeric argument of 1 (C-U 1
C-X D), only the current file is displayed instead of the whole
directory. In combination with the H command this can be useful
for cleaning up excess versions of a file after a heavy editing
session. With a numeric argument of 4 (C-U C-X D), it asks you
for the directory name. Type a directory name followed by a
semicolon, and/or a file name. If you explicitly specify a file
name only versions of that file are displayed, otherwise the
whole directory is displayed.
13.6.4 Editing the DIRED Buffer Yourselfî 13.6.4 Editing the DIRED Buffer Yourselfî 13.6.4 Editing the DIRED Buffer Yourself
It is unwise to try to edit the text of the directory listing
yourself, without using the special DIRED commands, unless you
know what you are doing, since you can confuse DIRED that way.
To make it less likely that you will do so accidentally, the
self-inserting characters are all made illegal inside DIRED.
However, deleting whole lines at a time is certainly safe. This
does not delete the files described by those lines; instead, it
makes DIRED forget that they are there and thus makes sure they
___î will not be deleted. Thus, M-X Delete Non-Matching Lines$FOO<cr>
is useful if you wish to delete only files with a FOO in their
names. See section 19 [Replacement], page 98.
For more complicated things, you can use the minibuffer. When
you call the minibuffer from within DIRED, you get a perfectly
normal one. The special DIRED commands are not present while you
are editing in the minibuffer. To mark a file for deletion,
replace the space at the beginning of its line with a "D". To
remove a mark, replace the "D" with a space.
13.7 Miscellaneous File Operationsî 13.7 Miscellaneous File Operationsî 13.7 Miscellaneous File Operations
EMACS has extended commands for performing many other
operations on files.
M-X View File$<file><cr> allows you to scan or read a file by
sequential screenfuls without visiting the file. It enters a
subsystem in which you type a Space to see the next screenful orî 80 EMACS Manual for ITS Users
a Backspace to see the previous screenful. Typing anything else
exits the command. View File does not visit the file; it does
not alter the contents of any buffer. The advantage of View File
is that the whole file does not need to be loaded before you can
begin reading it. The inability to do anything but page forward
or backward is a consequence.
M-X Write File$<file><cr> writes the contents of the buffer
into the file <file>, and then visits that file. It can be
thought of as a way of "changing the name" of the file you are
visiting. Unlike C-X C-S, Write File saves even if the buffer
has not been changed. C-X C-W is another way of getting at this
command.
M-X Insert File$<file><cr> inserts the contents of <file> into
the buffer at point, leaving point unchanged before the contents
and mark after them. The current defaults are used for <file>,
and are updated.
M-X Write Region$<file><cr> writes the region (the text between
point and mark) to the specified file. It does not set the
visited filenames. The buffer is not changed.
M-X Append to File$<file><cr> appends the region to <file>.
The text is added to the end of <file>.
M-X Prepend to File$<file><cr> adds the text to the beginning
of <file> instead of the end.
M-X Set Visited Filename$<file><cr> changes the name of the
file being visited without reading or writing the data in the
buffer. M-X Write File is approximately equivalent to this
command followed by a C-X C-S.
M-X Delete File$<file><cr> deletes the file. If you did not
get a chance to see the default filenames before typing the
filename to delete, then Delete File asks for confirmation before
deleting the file.
M-X Copy File$<old file>$<new file><cr> copies the file.
M-X Rename File$<old name>$<new name><cr> renames the file.
____î The default filenames for all of these operations are TECO
_______ _________î default filenames. Most of these operations also leave the TECO
default names set to the file they operated on. The TECO default
___ ______î is not always the same as the file you are visiting. When you
visit a file, they start out the same; the commands mentioned
above change the TECO default, but do not change the visited
filenames. Each buffer has its own TECO default filenames.î 81 EMACS Manual for ITS Users
The operation of visiting a file is available as a function
under the name M-X Visit File$<file><cr>. In this form, it uses
the TECO default as its defaults, though it still sets both the
TECO default and the visited filenames.
13.8 The Directory Comparison Subsystemî 13.8 The Directory Comparison Subsystemî 13.8 The Directory Comparison Subsystem
The function Compare Directories makes it easy to compare two
directories to see which files are present in both and which are
present only in one. It compares a directory on the local
machine with the directory of the same name on another machine.
Do M-X Compare Directories$<machine>:<dir spec> <switch>$,
where <machine> is AI, ML, MC or DM, and is not the machine you
are on, <dir spec> is an optional directory name and semicolon,
and the optional switch is a slash followed by S, D or L.
After a while of crunching, you will be placed in a recursive
editing level on a listing of both directories. The reason for
the recursive editing level is simply to make it easy for you to
view the comparison; unlike DIRED, Compare Directories does not
have any commands for moving or deleting the files. To exit, do
C-M-C.
Here is a sample of part of a directory comparison:
AI RMS #1=72 #2=78 #3=71 #4=77 #5=87 -
MC RMS #0=231 #1=254 #13=2844
AI MC .DDT. (INIT) 1 11/18/76 01:08 10/21/76 05:06
AI MC L .DDT_ (INIT) STAN.K ML EXIT
MC L .TECO. (INIT) .TECO. .TECO. (INIT)
AI AR2 1 16 2/6/77 17:51
AI AR3 1 13 2/17/77 21:37
AI L ATS ORDER .INFO. @ ORDER
MC FTPU 4 9 !3/4/77 16:46
MC FTPU 5 9 !3/4/77 16:49
AI MC MATCH 1 15 !3/4/77 15:39 !3/4/77 15:39
It begins with one line for each of the two directories. These
lines say which two directories they are, and how much disk space
is available on each of the machines.
Then there comes the list of files, one line for each distinct
pair of filenames that appears. At the beginning of the lineî 82 EMACS Manual for ITS Users
appear the names of the machines on which the file exists. At
the end of the line come the creation dates (or names pointed at,
for links) of the file for the machines it is on. Note that all
the dates/link names for the first machine line up, and so do all
those for the second machine.
The switches allow you to view only some of the files. The /S
switch shows only files present on both machines. /D shows only
those not present on both machines. /L shows only files which
are the most recent (largest-numbered) of a sequence. Only one
switch is allowed.î 83 EMACS Manual for ITS Users
CHAPTER FOURTEENî CHAPTER FOURTEENî CHAPTER FOURTEEN
USING MULTIPLE BUFFERSî USING MULTIPLE BUFFERSî USING MULTIPLE BUFFERS
When we speak of "the buffer", which contains the text you are
editing, we have given the impression that there is only one. In
fact, there may be many of them, each with its own body of text.
________î At any time only one buffer can be selected and available for
editing, but it isn't hard to switch to a different one. Each
buffer individually remembers which file it is visiting, what
modes are in effect, and whether there are any changes that need
saving.
C-X B Select or create a buffer.
C-X C-F Visit a file in its own buffer.
C-X C-B List the existing buffers.
C-X K Kill a buffer.
Each buffer in EMACS has a single name, which normally doesn't
change. A buffer's name can be any length. The name of the
currently selected buffer, and the name of the file visited in
it, are visible in the mode line when you are at top level. A
newly started EMACS has only one buffer, named "Main".
As well as the visited file and the major mode, a buffer can,
_______î if ordered to, remember many other things locally, which means,
independently of all other buffers. See section 22.3
[Variables], page 137.
14.1 Creating and Selecting Buffersî 14.1 Creating and Selecting Buffersî 14.1 Creating and Selecting Buffers
To create a new buffer, you need only think of a name for it
(say, "FOO") and then do C-X B FOO<cr>, which is the command C-X
B (Select Buffer) followed by the name. This makes a new, empty
buffer and selects it for editing. The new buffer is not
visiting any file, so if you try to save it you will be asked for
the filenames to use. Each buffer has its own major mode; the
new buffer's major mode is taken from the value of the variable
Default Major Mode, or from the major mode of the previously
selected buffer if the value of Default Major Mode is the null
string. Normally the Default Major Mode is Fundamental mode.
To return to buffer FOO later after having switched to another,î 84 EMACS Manual for ITS Users
the same command C-X B FOO<cr> is used, since C-X B can tell
whether a buffer named FOO exists already or not. It does not
matter whether you use upper case or lower case in typing the
name of a buffer. C-X B Main<cr> reselects the buffer Main that
EMACS started out with. Just C-X B<cr> reselects the previous
buffer. Repeated C-X B<cr>'s alternate between the last two
buffers selected.
You can also read a file into its own newly created buffer, all
with one command: C-X C-F (Find File), followed by the filename.
The first name of the file becomes the buffer name. C-F stands
for "Find", because if the specified file already resides in a
buffer in your EMACS, that buffer is reselected. So you need not
remember whether you have brought the file in already or not. A
buffer created by C-X C-F can be reselected later with C-X B or
C-X C-F, whichever you find more convenient. Nonexistent files
can be created with C-X C-F just as they can be with C-X C-V. A
nonzero argument to C-X C-F makes the file or buffer read-only;
it is like the argument to C-X C-V. See section 13.1 [Visiting],
page 69.
Sometimes EMACS needs to visit a file as part of some other
operation. By default, it visits the file in whatever buffer was
selected. If you like to use C-X C-F and multiple buffers, you
can tell EMACS to use multiple buffers for implicit visiting by
setting the variable TAGS Find File to a nonzero value. This
causes automatic visiting to be done by means of C-X C-F instead
of C-X C-V. Automatic visiting is done by the TAGS package (See
section 21 [TAGS], page 122.) or by invoking EMACS with a
filename
:EMACS <filename><cr>
If the buffer with the same name that C-X C-F wants to use
already exists but with the wrong contents (often a different
file with a similar name), then you are asked what to do. You
can type Return meaning go ahead and reuse that buffer for this
new file, or you can type another buffer name to use instead. If
C-X C-F does find the file already in a buffer, then it checks to
see whether the version on disk is the same as the last version
read or written from that buffer, for safety. If they are
different, you are warned that someone else may be editing the
file, and left with the version which was already in the EMACS.
To get the new version from disk instead, use M-X Revert File.î 85 EMACS Manual for ITS Users
14.2 Using Existing Buffersî 14.2 Using Existing Buffersî 14.2 Using Existing Buffers
To get a list of all the buffers that exist, do C-X C-B (List
Buffers). Each buffer's name, major mode, and visited filenames
are printed. A star at the beginning of a line indicates a
buffer which contains changes that have not been saved. The
number that appears before a buffer's name in a C-X C-B listing
______ ______î is that buffer's buffer number. You can select a buffer by
giving its number as a numeric argument to C-X B, which then does
not need to read a string from the terminal.
If several buffers have stars, you should save some of them
with M-X Save All Files. This finds all the buffers that need
saving and asks about each one individually. Saving the buffers
this way is much easier and more efficient than selecting each
one and typing C-X C-S.
A quick way of glancing at another buffer, faster than
selecting it, is to use M-X View Buffer$<buffername><cr>. This
displays the contents of the other buffer and lets you move
forward and back a screen at a time with Space and Backspace.
See section 15 [Display], page 87.
M-X Rename Buffer$<new name><cr> changes the name of the
currently selected buffer. If <new name> is the null string, the
first filename of the visited file is used as the new name of the
buffer.
The commands C-X A (^R Append to Buffer) and M-X Insert Buffer
can be used to copy text from one buffer to another. See
section 9.3 [Copying], page 44.
14.3 Killing Buffersî 14.3 Killing Buffersî 14.3 Killing Buffers
After you use an EMACS for a while, it may fill up with buffers
which you no longer need. Eventually you can reach a point where
trying to create any more results in an "URK" error. So whenever
it is convenient you should do M-X Kill Some Buffers, which asks
about each buffer individually. You can say Y or N to kill it or
not. Or you can say Control-R to take a look at it first. This
does not actually select the buffer, as the mode line shows, but
gives you a recursive editing level in which you can move around
and look at things. When you have seen enough to make up your
mind, exit the recursive editing level with a C-M-C and you will
be asked the question again. If you say to kill a buffer thatî 86 EMACS Manual for ITS Users
needs saving, you will be asked whether it should be saved. See
section 24.2.5 [Storage Exhausted], page 161. .
You can kill the buffer FOO by doing C-X K FOO<cr>. You can
kill the selected buffer, a common thing to do if you use C-X
C-F, by doing C-X K<cr>. If you kill the selected buffer, in any
way, EMACS asks you which buffer to select instead. Saying just
<cr> at that point tells EMACS to choose one reasonably. C-X K
runs the function Kill Buffer.î 87 EMACS Manual for ITS Users
CHAPTER FIFTEENî CHAPTER FIFTEENî CHAPTER FIFTEEN
CONTROLLING THE DISPLAYî CONTROLLING THE DISPLAYî CONTROLLING THE DISPLAY
Since only part of a large file fits on the screen, EMACS tries
to show the part that is likely to be interesting. The display
control commands allow you to ask to see a different part of the
file.
C-L Clear and redisplay screen, putting point at a
specified vertical position.
C-V Scroll forwards (a screen or a few lines).
M-V Scroll backwards.
M-R Move point to the text at a given vertical
position.
C-M-R Shift the function point is in onto the screen.
The terminal screen is rarely large enough to display all of
your file. If the whole buffer doesn't fit on the screen, EMACS
shows a contiguous portion of it, containing point. It continues
to show approximately the same portion until point moves outside
of it; then EMACS chooses a new portion centered around the new
point. This is EMACS's guess as to what you are most interested
in seeing. But if the guess is wrong, you can use the display
control commands to see a different portion. The finite area of
___î screen through which you can see part of the buffer is called the
______î window, and the choice of where in the buffer to start displaying
___ ______î is also called the window.
First we describe how EMACS chooses a new window position on
its own. The goal is usually to place point 35 percent of the
way down the screen. This is controlled by the variable Cursor
Centering Point, whose value is the percent of the screen down
from the top. However, if the end of the buffer is on the
screen, EMACS tries to leave at most 35 percent of the screen
blank beneath it, so that the screen is not wasted. This
percentage is controlled by the variable End of Buffer Display
Margin. These variables work by controlling FS flags, and their
values must never be negative or greater than 99.
Normally EMACS only chooses a new window position if you move
point off the screen. However, you can ask for a new window
position to be computed whenever point gets too close to the top
of the screen by setting the variable Top Display Margin to the
percentage of the screen in which point must not appear. Bottom
Display Margin does the same thing for a region near the bottom.î 88 EMACS Manual for ITS Users
The basic display control command is C-L (^R New Window). In
its simplest form, with no argument, it clears the screen and
tells EMACS to choose a new window position, centering point 35
percent of the way from the top as usual.
C-L with a positive argument chooses a new window so as to put
point that many lines from the top. An argument of zero puts
point on the very top line. Point does not move with respect to
the text; rather, the text and point move rigidly on the screen.
C-L with a negative argument puts point that many lines from the
bottom of the window. For example, C-U -1 C-L puts point on the
bottom line, and C-U -5 C-L puts it five lines from the bottom.
C-L with an argument does not clear the screen, so that it can
move the text on the screen instead of printing it again if the
terminal allows that.
C-U C-L is different from C-L with any other sort of argument.
It causes just the line containing point to be redisplayed.
_________î The scrolling commands C-V and M-V let you move the whole
display up or down a few lines. C-V (^R Next Screen) with an
argument shows you that many more lines at the bottom of the
screen, moving the text and point up together as C-L might. C-V
with a negative argument shows you more lines at the top of the
screen, as does Meta-V (^R Previous Screen) with a positive
argument.
To read the buffer a screenful at a time, use the C-V command
with no argument. It takes the last two lines at the bottom of
the screen and puts them at the top, followed by nearly a whole
screenful of lines not visible before. Point is put at the top
of the screen. Thus, each C-V shows the "next screenful", except
for two lines of overlap to provide continuity. The variable
Next Screen Context Lines, if defined, controls how many lines
from the bottom of the screen move to the top; the default if the
variable is not defined is 2. To move backward, use M-V without
an argument, which moves a whole screenful backwards (again with
overlap).
Scanning by screenfuls through the buffer for some distance is
most conveniently done with the M-X View Buffer command. This
command enters a simple subsystem in which Space moves a
screenful forward and Backspace moves a screenful backward. The
Return character exits, leaving point centered in whatever part
of the buffer was visible. Any other character exits and returns
point to its former location, and is then executed as a command
(unless it is a Rubout; Rubout exits but is not executed). View
Buffer can be used to view another buffer by giving the buffer's
name as a string argument. In this case, exiting with Returnî 89 EMACS Manual for ITS Users
moves point permanently in the other buffer, but does not select
it. See section 14 [Buffers], page 83.
With the M-X View File command, you can scan by screenfuls
through a file which you have not visited. See section 13.7
[Advanced File Commands], page 79.
To scroll the buffer so that the current function or paragraph
is positioned conveniently on the screen, use the C-M-R command
(^R Reposition Window). This command tries to get as much as
possible of the current function or paragraph onto the screen,
preferring the beginning to the end, but not moving point off the
screen. A "function" in Lisp mode is a defun; otherwise it is
defined to be a set of consecutive unindented lines, or a set of
consecutive indented lines.
C-L in all its forms changes the position of point on the
screen, carrying the text with it. Another command moves point
the same way but leaves the text fixed. It is called Meta-R
(^R Move to Screen Edge). With no argument, it puts point at the
beginning of the line at the center of the screen. An argument
is used to specify the line to put it on, counting from the top
if the argument is positive, or from the bottom if it is
negative. Thus, Meta-R with an argument of 0 puts point on the
top line of the screen. Meta-R never causes any text to move on
the screen; it causes point to move with respect to the screen
and the text.î 90 EMACS Manual for ITS Users
CHAPTER SIXTEENî CHAPTER SIXTEENî CHAPTER SIXTEEN
TWO WINDOW MODEî TWO WINDOW MODEî TWO WINDOW MODE
_______î EMACS allows you to split the screen into two windows and use
them to display parts of two files, or two parts of the same
file.
C-X 2 Start showing two windows.
C-X 3 Show two windows but stay "in" the top one.
C-X 1 Show only one window again.
C-X O Switch to the Other window
C-X 4 Find buffer, file or tag in other window.
C-X ^ Make this window bigger.
C-M-V Scroll the other window.
___ ______î In two window mode, the text display portion of the screen is
_______î divided into two parts called windows, which display different
pieces of text. The two windows can display two different files,
or two parts of the same file. Only one of the windows is
selected; that is the window which the cursor is in. Editing
normally takes place in that window alone. To edit in the other
window, you would give a special command to move the cursor to
the other window, and then edit there. Since there is only one
mode line, it applies to the window you are in at the moment.
The command C-X 2 (^R Two Windows) enters two-window mode. A
line of dashes appears across the middle of the screen, dividing
the text display area into two halves. Window one, containing
the same text as previously occupied the whole screen, fills the
top half, while window two fills the bottom half. The cursor
moves to window two. If this is your first entry to two-window
mode, window two contains a new buffer named W2. Otherwise, it
contains the same text it held the last time you looked at it.
To return to viewing only one window, use the command C-X 1
(^R One Window). Window one expands to fill the whole screen,
and window two disappears until the next C-X 2. C-U C-X 1 gets
rid of window one and makes window two use the whole screen.
Neither of these depends on which window the cursor is in when
the command is given.
While you are in two window mode you can use C-X O (^R Other
Window) to switch between the windows. After doing C-X 2, the
cursor is in window two. Doing C-X O moves the cursor back to
window one, to exactly where it was before the C-X 2. Theî 91 EMACS Manual for ITS Users
difference between this and doing C-X 1 is that C-X O leaves
window two visible on the screen. A second C-X O moves the
cursor back into window two, to where it was before the first
C-X O. And so on...
Often you will be editing one window while using the other just
for reference. Then, the command C-M-V (^R Scroll Other Window)
is very useful. It scrolls the other window without switching to
it and switching back. It scrolls the same way C-V does: with
no argument, a whole screen up; with an argument, that many lines
up (or down, for a negative argument). With just a minus sign
(no digits) as an argument, C-M-V scrolls a whole screenful
backwards (what M-V does).
The C-X 3 (^R View Two Windows) command is like C-X 2 but
leaves the cursor in window one. That is, it makes window two
appear at the bottom of the screen but leaves the cursor where it
was. C-X 2 is equivalent to C-X 3 C-X O. C-X 3 is equivalent to
C-X 2 C-X O, but C-X 3 is much faster.
M-X Compare Windows compares the text in the two windows.
Starting from the existing values of point in each window, it
advances point in both windows to the first mismatch. The
variable Collapse in Comparison, if it exists, should be a string
containing all the "insignificant" characters; any string of
insignificant characters matches any other string of those
characters. If the variable does not exist, the insignificant
characters are return, linefeed, space and tab.
If you quit with C-G in the middle of Compare Windows, point is
advanced in both windows as far as the matching has proceeded.
As a result, calling Compare Windows again resumes the
comparison.
Normally, the screen is divided evenly between the two windows.
You can also redistribute screen space between the windows with
the C-X ^ (^R Grow Window) command. It makes the currently
selected window get one line bigger, or as many lines as is
specified with a numeric argument. With a negative argument, it
makes the selected window smaller. The allocation of space to
the windows is remembered while you are in one window mode and
the same allocation is used when you return to two window mode.
The allocation changes only when you give a C-X ^ command.
After leaving two-window mode, you can still use C-X O, but its
meaning is different. Window two does not appear, but whatever
was being shown in it appears, in window one (the whole screen).
Whatever buffer used to be in window one is stuck, invisibly,
into window two. Another C-X O reverses the effect of the first.î 92 EMACS Manual for ITS Users
For example, if window one shows buffer B and window two shows
buffer W2 (the usual case), and only window one is visible, then
after a C-X O window one shows buffer W2 and window two shows
buffer B.
16.1 Multiple Windows and Multiple Buffersî 16.1 Multiple Windows and Multiple Buffersî 16.1 Multiple Windows and Multiple Buffers
Buffers can be selected independently in each window. The C-X
B command selects a new buffer in whichever window the cursor is
in. The other window's buffer does not change. Window two's
buffer is remembered while you are in one window mode, and when
you return to two window mode that same buffer reappears in
window two. See section 14 [Buffers], page 83.
You can view one buffer in both windows. Give C-X 2 an
argument as in C-U C-X 2 to go into two window mode, with both
windows showing the buffer which used to be in window one alone.
Although the same buffer appears in both windows, they have
different values of point, so you can move around in window two
while window one continues to show the same text. Then, having
found in window two the place you wish to refer to, you can go
back to window one with C-X O to make your changes. Finally you
can do C-X 1 to make window two leave the screen. If you are
already in two window mode, C-U C-X O switches windows carrying
the buffer from the old window to the new one so that both
windows show that buffer.
If you have the same buffer in both windows, you must beware of
trying to visit a different file in one of the windows with C-X
C-V, because if you bring a new file into this buffer, it will
____î replace the old file in both windows. To view different files in
the two windows again, you must switch buffers in one of the
windows first (with C-X B or C-X C-F, perhaps).
A convenient "combination" command for viewing something in the
other window is C-X 4 (^R Visit in Other Window). With this
command you can ask to see any specified buffer, file or tag in
the other window. Follow the C-X 4 with either B and a buffer
name, F or C-F and a file name, or T or "." and a tag name (See
section 21 [TAGS], page 122.). This switches to the other window
and finds there what you specified. If you were previously in
one-window mode, two-window mode is entered. C-X 4 B is similar
to to C-X 2 C-X B. C-X 4 F is similar to C-X 2 C-X C-F. C-X 4 T
is similar to C-X 2 M-Period. The difference is one of
efficiency, and also that C-X 4 works equally well if you are
already using two windows.î 93 EMACS Manual for ITS Users
CHAPTER SEVENTEENî CHAPTER SEVENTEENî CHAPTER SEVENTEEN
NARROWINGî NARROWINGî NARROWING
_________î Narrowing means focusing in on some portion of the buffer,
making the rest temporarily invisible and inaccessible.
C-X N Narrow down to between point and mark.
C-X P Narrow down to the page point is in.
C-X W Widen to view the entire buffer.
When you have narrowed down to a part of the buffer, that part
appears to be all there is. You can't see the rest, you can't
move into it (motion commands won't go outside the visible part),
you can't change it in any way. However, it is not gone, and if
you save the file all the invisible text will be saved. In
addition to sometimes making it easier to concentrate on a single
subroutine or paragraph by eliminating clutter, narrowing can be
used to restrict the range of operation of a replace command.
The word "Narrow" appears in the mode line whenever narrowing is
in effect.
The primary narrowing command is C-X N (^R Narrow Bounds to
_______ ______ __________î Region). It sets the virtual buffer boundaries at point and the
mark, so that only what was between them remains visible. Point
and mark do not change.
The way to undo narrowing is to widen with C-X W (^R Widen
Bounds). This makes all text in the buffer accessible again.
Another way to narrow is to narrow to just one page, with C-X P
(^R Narrow Bounds to Page). See section 18 [Pages], page 94.
You can get information on what part of the buffer you are
narrowed down to using the C-X = command. See section 11.4
[Filling], page 56.
The virtual buffer boundaries are a powerful TECO mechanism
used internally in EMACS in many ways. While only the commands
described here set them so as you can see, many others set them
temporarily using the TECO commands FS VB$ and FS VZ$, but
restore them before they are finished.î 94 EMACS Manual for ITS Users
CHAPTER EIGHTEENî CHAPTER EIGHTEENî CHAPTER EIGHTEEN
COMMANDS FOR MANIPULATING PAGESî COMMANDS FOR MANIPULATING PAGESî COMMANDS FOR MANIPULATING PAGES
_____î Files are often thought of as divided into pages by the ASCII
^î character formfeed (|L). For example, if a file is printed on a
line printer, each page of the file, in this sense, will start on
a new page of paper. Most editors make the division of a file
into pages extremely important. For example, they may be unable
to show more than one page of the file at any time. EMACS treats
a formfeed character just like any other character. It can be
inserted with C-Q C-L (or, C-M-L), and deleted with Rubout.
Thus, you are free to paginate your file, or not. However, since
pages are often meaningful divisions of the file, commands are
provided to move over them and operate on them.
C-M-L Insert formfeed.
C-X C-P Put point and mark around this page (or
another page).
C-X [ Move point to previous page boundary.
C-X ] Move point to next page boundary.
C-X P Narrow down to just this (or next) page.
C-X L Count the lines in this page.
M-X What Page
Print current page and line number.
The C-X [ (^R Previous Page) command moves point to the
previous page delimiter (actually, to right after it). If point
starts out right after a page delimiter, it skips that one and
stops at the previous one. A numeric argument serves as a repeat
count. The C-X ] (^R Next Page) command moves forward past the
next page delimiter.
The command M-X What Page prints the page and line number of
the cursor in the echo area. There is a separate command to
print this information because it is likely to be slow and should
not slow down anything else. The design of TECO is such that it
is not possible to know the absolute number of the page you are
in, except by scanning through the whole file counting pages.
The C-X C-P command (^R Mark Page) puts point at the beginning
of the current page and the mark at the end. The page delimiter
at the end is included (the mark follows it). The page delimiter
at the front is excluded (point follows it). This command can be
followed by a C-W to kill a page which is to be moved elsewhere.
If it is inserted after a page delimiter, at a place where C-X ]î 95 EMACS Manual for ITS Users
or C-X [ would take you, then the page will be properly delimited
before and after once again.
A numeric argument to C-X C-P is used to specify which page to
go to, relative to the current one. Zero means the current page.
One means the next page, and -1 means the previous one.
The command C-X P (^R Narrow Bounds to Page) narrows down to
just one page. Everything before and after becomes temporarily
invisible and inaccessible (See section 17 [Narrowing],
page 93.). Use C-X W (^R Widen Bounds) to undo this. Both page
terminators, the preceding one and the following one, are
excluded from the visible region. Like C-X C-P, the C-X P
command normally selects the current page, but allows you to
specify which page explicitly relative to the current one with a
numeric argument. However, when you are already narrowed down to
one page, C-X P with no argument moves you to the next page
(otherwise, it would be a useless no-op). So several C-X P's in
a row get first the current page and then successive pages.
If you prefer to see only one page of the file at a time as a
general rule, use the PAGE library. See section 18.1 [PAGE],
page 96.
Just what delimits pages is controlled by the variable Page
Delimiter, which should contain a TECO search string (See
section 19.3 [TECO search strings], page 101.) which matches all
^î page separators. Normally, it is a string containing just |L.
^ ^ ^ ^î For an INFO file, it might usefully be changed to |_|L|O|_, which
^ ^ ^î means that either a |_|L or just a |_ (either of the two strings
that separate INFO nodes) should be a page separator. Then each
node counts as a page. In any case, page separators are
recognized as such only at the beginning of a line. The
paragraph commands consider each page boundary a paragraph
boundary as well.
The C-X L command (^R Count Lines Page) is good for deciding
where to break a page in two. It prints in the echo area the
total number of lines in the current page, and then divides it up
into those preceding the current line and those following, as in
Page has 96 lines (72+25)
Notice that the sum is off by one; this is correct if point is
not at the front of a line.î 96 EMACS Manual for ITS Users
18.1 Editing Only One Page at a Timeî 18.1 Editing Only One Page at a Timeî 18.1 Editing Only One Page at a Time
The PAGE library allows you to edit only within a single page
at a time, with special commands to move between pages, and split
and join pages. It contrives to show the number of the page you
are looking at in the mode line. You can also ask to see a
_________î directory of the pages in the file, or to insert it into the
file. This is an extension of and replacement for the facility
provided by the C-X P command in standard EMACS. It is an
optional library because we do not think it is necessarily an
improvement.
The commands in the PAGE library supplant and redefine commands
in standard EMACS. Therefore, you cannot use them unless you
give the command M-X Load Library$PAGE<cr> explicitly. See
section 22.2 [Libraries], page 135.
C-X ] Move to next page.
C-X [ Move to previous page.
C-X C-P Move to page by absolute number.
C-X P Split this page at point.
C-X J Join this page to the next or previous one.
C-X W See the whole file again.
The most fundamental thing to do with PAGE is to go to a
specific page. This can be done by giving the page number as an
argument to C-X C-P (^R Goto Page). If you give a number too
big, the last page in the file is selected.
For convenience, C-X C-P with no argument when you are looking
at the whole file selects the page containing point. When you
are looking at only one page, C-X C-P with no argument goes to
the next page and with a negative argument goes to the previous
page.
However, the main commands for moving forward or backward by
pages are C-X [ and C-X ] (^R Goto Previous Page and ^R Goto Next
Page). These take a numeric argument (either sign) and move that
many pages.
To go back to viewing the whole file instead of just one page,
you can use the C-X W (^R PAGE Widen Bounds) command. These are
the same characters that you would use in standard EMACS, but
they run a different function that knows to remove the page
number from the mode line.î 97 EMACS Manual for ITS Users
The C-S (^R Incremental Search) and C-R (^R Reverse Search)
commands are redefined to widen bounds first and narrow them
again afterwards. So you can search through the whole file, but
afterward see only the page in which the search ended. In fact,
PAGE goes through some trouble to work with whatever search
functions you prefer to use, and find them wherever you put them.
^î To split an existing page, you could insert a |L, but unless
you do this while viewing the whole file, PAGE might get
confused. The clean way is to use C-X P (^R Insert Pagemark)
which inserts the page mark, and narrows down to the second of
the two pages formed from the old page. The clean way to get rid
of a page mark is to use C-X J (^R Join Next Page). It gets rid
of the page mark after the current page; or, with a negative
argument, gets rid of the page mark before this page.
^î A page mark is defined as <CRLF>|L. If you set the variable
^î PAGE Flush CRLF to 1, a page mark is <CRLF>|L<CRLF>, which has
the effect of making the CRLF at the beginning of each page
invisible. This may be desirable for EMACS library source files.
^î You can also specify some other string in place of |L by setting
the variable Page Delimiter. If Page Delimiter specifies
^î multiple alternatives, separated by |O, PAGE always inserts the
first of them, but recognizes them all.
To see a list of all the pages in the file, each one
represented by its first nonempty line, use M-X View Page
Directory. It prints out the first non-blank line on each page,
preceded by its page number. M-X Insert Page Directory inserts
the same directory into the buffer at point. If you give it an
argument, it tries to make the whole thing into a comment by
putting the Comment Start string at the front of each line and
the Comment End string at the end.
If the variable Page Setup Hook exists, PAGE will execute its
value as the function for placing PAGE's functions on keys. This
is done instead of the normal assignments to C-X [, C-X ], C-X
C-P, C-X P, and C-X J. î 98 EMACS Manual for ITS Users
CHAPTER NINETEENî CHAPTER NINETEENî CHAPTER NINETEEN
REPLACEMENT COMMANDSî REPLACEMENT COMMANDSî REPLACEMENT COMMANDS
Global search-and-replace operations are not needed as often in
EMACS as they are in other editors, but they are available. In
addition to the simple Replace operation which is like that found
in most editors, there is a Query Replace operation which asks
you, for each occurrence of the pattern, whether to replace it.
To replace every instance of FOO after point with BAR, you can
do
M-X Replace$FOO$BAR<cr>
Replacement occurs only after point, so if you want to cover the
whole buffer you must go to the beginning first. Replacement
continues to the end of the buffer, but you can restrict it by
narrowing. See section 17 [Narrowing], page 93.
Unless the variable Case Replace is zero, Replace tries to
preserve case; give both FOO and BAR in lower case, and if a
particular FOO is found with a capital initial or all
capitalized, the BAR which replaces it will be given the same
case pattern. Thus,
M-X Replace$foo$bar<cr>
would replace "foo" with "bar", "Foo" with "Bar" and "FOO" with
"BAR". If Case Replace is zero, the replacement string is
inserted with the case you used when you typed it. If Case
Search is zero, the string to be replaced is found only when it
has the same case as what you typed.
If you give Replace (or Query Replace) an argument, then it
replaces only occurrences of FOO delimited by break characters
(or an end of the buffer). So you can replace only FOO the word,
and not FOO when it is part of FOOBAR.
The string FOO to be replaced is actually a TECO search string,
^ ^ ^ ^ ^î a type of pattern, in which the characters |B, |N, |O, |Q, |S,
^ ^î |X, and |] are special. See section 19.3 [TECO search strings],
page 101.î 99 EMACS Manual for ITS Users
19.1 Query Replaceî 19.1 Query Replaceî 19.1 Query Replace
If you want to change only some of the occurrences of FOO, not
all, then you cannot use an ordinary Replace. Instead, use M-X
Query Replace$FOO$BAR<cr>. This displays each occurrence of FOO
and waits for you to say whether to replace it with a BAR. The
things you can type when you are shown an occurrence of FOO are:
Space to replace the FOO (preserving case, just
like plain Replace, unless Case Replace is
zero).
Rubout to skip to the next FOO without replacing
this one.
Comma to replace this FOO and display the result.
You are then asked for another input
character, except that since the replacement
has already been made, Rubout and Space are
equivalent.
Altmode to exit without doing any more replacements.
Period to replace this FOO and then exit.
! to replace all remaining FOO's without
asking.
^ to go back to the previous FOO (or, where it
was), in case you have made a mistake. This
works by jumping to the mark (Query Replace
sets the mark each time it finds a FOO).
C-R to enter a recursive editing level, in case
the FOO needs to be edited rather than just
replaced with a BAR. When you are done, exit
the recursive editing level with C-M-C and
the next FOO will be displayed.
C-W to delete the FOO, and then start editing the
buffer. When you are finished editing
whatever is to replace the FOO, exit the
recursive editing level with C-M-C and the
next FOO will be displayed.
If you type any other character, the Query Replace is exited,
and the character executed as a command. To restart the Query
Replace, use C-X Altmode which is a command to re-execute the
previous minibuffer command or extended command. See section 5
[M-X], page 21.î 100 EMACS Manual for ITS Users
19.1.1 Running Query Replace with the Minibufferî 19.1.1 Running Query Replace with the Minibufferî 19.1.1 Running Query Replace with the Minibuffer
Meta-% gives you a minibuffer pre-initialized with "MM Query
Replace$". See section 23 [Minibuffer], page 156. This is the
easiest way to invoke Query Replace. It also allows you to get
Returns and Altmodes into the arguments.
With the minibuffer, Query Replace can be given a precomma
argument, which says that the second string argument is actually
a TECO program to be executed to perform the replacement, rather
than simply a string to replace with.
When you invoke Query Replace from the minibuffer, the
^î character |] becomes special (because it is special in TECO
^î programs). In order to get a |] into the search string or the
replacement string, you must use two of them. You can also use a
^î |] to quote an Altmode. In the minibuffer, Return has no
syntactic significance, so there is no need for a way to quote
it. However, in order to insert any control characters into the
^î arguments, you need to quote them again with C-Q. So, to get |Q
^ ^î |X into the search string so as to search for a |X, you have to
type C-Q C-Q C-Q C-X.
19.2 Other Search-and-loop Functionsî 19.2 Other Search-and-loop Functionsî 19.2 Other Search-and-loop Functions
Here are some other functions related to replacement. Their
arguments are TECO search strings (See section 19.3 [TECO search
strings], page 101.). They all operate from point to the end of
the buffer (or where narrowing stops them).
M-X List Matching Lines$FOO<cr>
prints each line containing FOO. With an
argument, it prints that many lines before and
after each occurrence.
M-X Count Occurrences$FOO<cr>
prints the number of occurrences of FOO after
point.
M-X Delete Non-Matching Lines$FOO<cr>
kills all lines after point that don't contain
FOO.
M-X Delete Matching Lines$FOO<cr>
kills all lines after point that contain FOO. î 101 EMACS Manual for ITS Users
19.3 TECO Search Stringsî 19.3 TECO Search Stringsî 19.3 TECO Search Strings
The first string argument to Replace and Query Replace is
actually a TECO search string. This means that the characters
^ ^ ^ ^ ^ ^î |X, |B, |N, |S, |O, and |Q have special meanings.
^ ^î |X matches any character. |B matches any "delimiter" character
(anything which the word commands consider not part of a word,
according to the syntax table. See section 22.4 [Syntax],
^ ^î page 139.). |N negates what follows, so that |N A matches
^ ^ ^î anything but A, and |N |B matches any non-delimiter. |S is
followed by a parameter character, and matches anything whose
^î Lisp syntax equals the parameter. So |S( matches any character
^ ^î given the syntax of an open-parenthesis. |N|SA matches any
character which is not part of symbol names.
^ ^ ______î |O means "or", so that XYXY |O ZZZ matches either XYXY or ZZZ.
^ ^î |O can be used more than once in a pattern. |Q quotes the
following character, in case you want to search for one of the
special control characters. However, you can't quote an Altmode
or a Return in this way because its specialness is at an earlier
stage of processing.
Some variables are supposed to have TECO search strings as
their values. For example, Page Delimiter is supposed to be a
search string to match anything which should start a page. This
^î is so that you can use |O to match several alternatives. In the
^ ^ ^ ^ ^ ^ ^î values of such variables, |B, |N, |O, |Q, |S, |X and |] are
^ ^ ^î special, but Altmode is not. |B through |X are quoted with a |Q,
^ ^î and |] is quoted with another |].
The function Apropos (or, Help A) and all similar functions
actually take TECO search strings as arguments, so you can search
for more than one substring at a time. This is useful because
^î doing Apropos on word|Opara is not really slower than searching
for just "word" or just "para".î 102 EMACS Manual for ITS Users
CHAPTER TWENTYî CHAPTER TWENTYî CHAPTER TWENTY
EDITING PROGRAMSî EDITING PROGRAMSî EDITING PROGRAMS
Special features for editing programs include automatic
indentation, comment alignment, parenthesis matching, and the
ability to move over and kill balanced expressions. Many of
these features are parameterized so that they can work for any
programming language.
_____ ____î For each language there is a special major mode which
customizes EMACS slightly to be better suited to editing programs
written in that language. These modes sometimes offer special
facilities as well.
See section 11.1 [Words], page 50. Moving over words is useful
for editing programs as well as text.
See section 11.2 [Paragraphs], page 52. Most programming
language major modes define paragraphs to be separated only by
blank lines and page boundaries. This makes the paragraph
commands useful for editing programs.
See section 21 [Tags], page 122. The TAGS package can remember
all the labels or functions in a multi-file program and find any
one of them quickly.
20.1 Major Modesî 20.1 Major Modesî 20.1 Major Modes
_____ _____î EMACS has many different major modes, each of which customizes
EMACS for editing text of a particular sort. The major modes are
mutually exclusive, and one major mode is current at any time.
When at top level, EMACS always says in the mode line which major
mode you are in.
___________ ____î When EMACS starts up, it is in what is called Fundamental mode,
which means that the character commands are defined so as to be
convenient in general. More precisely, in Fundamental mode every
EMACS option is set in its default state. For editing any
specific type of text, such as Lisp code or English text, you
should switch to the appropriate major mode. This tells EMACS to
change the meanings of a few commands to become more specifically
adapted to the language being edited. Most commands remain
unchanged; the ones which usually change are Tab, Rubout, and
Linefeed. In addition, the commands which handle comments use
the mode to determine how comments are to be delimited.î 103 EMACS Manual for ITS Users
Selecting a new major mode is done with an M-X command. Each
major mode is the name of the function to select that mode.
Thus, you can enter Lisp mode by executing M-X Lisp (short for
M-X Lisp Mode). You can specify which major mode should be used
for editing a certain file by putting -*-<mode name>-*- somewhere
in the first nonblank line of the file. For example, this file
has -*-SCRIBE-*-. In a program, this string is surrounded by
appropriate other characters to hide it from the compiler in a
comment.
Many major modes redefine the syntactical properties of
characters appearing in the buffer. See section 22.4 [Syntax],
page 139.
Most programming language major modes specify that only blank
lines separate paragraphs. This is so that the paragraph
commands remain useful. They also cause Auto Fill mode to use
the definition of Tab to indent the new lines it creates. This
is because most lines in a program are usually indented.
To find out what a particular major mode redefines, use the
command M-X List Redefinitions while that mode is in effect.
This command describes all the local variables and commands of
the selected buffer, in a form designed to be easy to understand.
Major modes are available for the languages LISP, MUDDLE,
MIDAS, PALX, IBM370 (assembler), CLU, FORTRAN, MACSYMA, PASCAL,
PL1, SAIL, and TECO.
There is also Text mode, designed for editing English text, and
TEX and SCRIBE modes, for editing input to those text justifier
programs. See section 11 [Text], page 50.
20.2 Compiling Your Programî 20.2 Compiling Your Programî 20.2 Compiling Your Program
The command M-X Compile<cr> is used to compile the visited
file. It knows how to compile it based on the major mode; for
example, in TECO mode, it invokes the generator for EMACS
libraries. Usually it assumes that the major mode name is the
name of the compiler or assembler to use.
The first thing M-X Compile does is offer to save each buffer.
This is because it is likely that other buffers contain parts of
the same program you are about to compile.
Then M-X Compile invokes the appropriate compiler and passes itî 104 EMACS Manual for ITS Users
the name of the visited file as the source file. If you give a
string argument to M-X Compile, that is passed to the compiler
also. This can be used to specify switches or the name of an
output file.
The major mode or the file's local modes list can specify a
different compiler by setting the variable Compiler Filename
locally. They can specify switches to be used by setting the
variable Compiler Switches (the default is to use no switches
except those specified by the user in the string argument to M-X
Compile).
After compilation, you must type $P to resume EMACS. When
EMACS starts up again, it executes the value of the variable
After Compilation Hook, if that is nonzero. This can be used for
such tasks as reading the compiler's file of error messages into
EMACS.
The major mode or the file's local modes list can completely
override the normal processing of M-X Compile by giving a nonzero
local value to the variable Compile Command. This should be a
TECO expression which takes complete responsibility for the
compilation. It can find the filename to use in q-register 1.
____ ^î It must use |\ to exit. All the other hooks described above are
ignored. This is often used when several input files must be
compiled together in order to compile any of them. See the file
AI:EMACS1;CCL > for an example of doing this for an EMACS
library.
20.3 Indentation Commands for Codeî 20.3 Indentation Commands for Codeî 20.3 Indentation Commands for Code
Tab Indents current line.
Linefeed Equivalent to Return followed by Tab.
M-^ Joins two lines, leaving one space between if
appropriate.
M-\ Deletes all spaces and tabs around point.
M-M Moves to the first nonblank character on the
line.
Most programming languages have some indentation convention.
For Lisp code, lines are indented according to their nesting in
parentheses. For assembler code, almost all lines start with a
single tab, but some have one or more spaces as well. Indenting
TECO code is an art rather than a science, but it is often useful
to indent a line under the previous one.î 105 EMACS Manual for ITS Users
Whatever the language, to indent a line, use the Tab command.
Each major mode defines this command to perform the sort of
indentation appropriate for the particular language. In Lisp
mode, Tab aligns the line according to its depth in parentheses.
No matter where in the line you are when you type Tab, it aligns
the line as a whole. In MIDAS mode, Tab inserts a tab, that
being the standard indentation for assembly code. In TECO mode,
Tab realigns the current line to match a previous line. PL1 mode
(See the file INFO;EPL1.) knows in great detail about the
keywords of the language so as to indent lines according to the
nesting structure.
The command Linefeed (^R Indent New Line) does a Return and
then does a Tab on the next line. Thus, Linefeed at the end of
the line makes a following blank line and supplies it with the
usual amount of indentation. Linefeed in the middle of a line
breaks the line and supplies the usual indentation in front of
the new line.
The inverse of Linefeed is Meta-^ or C-M-^ (^R Delete
Indentation). This command deletes the indentation at the front
of the current line, and the line separator as well. They are
replaced by a single space, or by no space if before a ")" or
after a "(", or at the beginning of a line. To delete just the
indentation of a line, go to the beginning of the line and use
Meta-\ (^R Delete Horizontal Space), which deletes all spaces and
tabs around the cursor.
To insert an indented line before the current one, do C-A, C-O,
and then Tab. To make an indented line after the current one,
use C-E Linefeed.
To move over the indentation on a line, use Meta-M or C-M-M
(^R Back to Indentation). These commands move the cursor forward
or back to the first nonblank character on the line.
20.4 Automatic Display Of Matching Parenthesesî 20.4 Automatic Display Of Matching Parenthesesî 20.4 Automatic Display Of Matching Parentheses
The EMACS parenthesis-matching feature is designed to show
automatically how parentheses balance in text as it is typed in.
When this feature is enabled, after a close parenthesis or other
close bracket character is inserted the cursor automatically
moves for an instant to the open which balances the newly
inserted character. The cursor stays at the open parenthesis for
a second before returning home, unless you type another command
before the second is up.î 106 EMACS Manual for ITS Users
It is worth emphasizing that the location of point, the place
where your type-in will be inserted, is not affected by the
parenthesis matching feature. It stays after the close
parenthesis, where it ought to be. Only the cursor on the screen
moves away and back. You can type ahead freely as if the
parenthesis display feature did not exist. In fact, if you type
fast enough, you won't see the cursor move. You must pause after
typing a close parenthesis to let the cursor move to the open
parenthesis.
The variable Display Matching Paren controls parenthesis
display. If it is zero, the feature is disabled. If the
variable is nonzero, then its absolute value is the number of
seconds for the cursor to stay at the open parenthesis before
coming back to its real location. The sign of the variable is
also significant: if it is negative, then the open parenthesis is
shown only if it is already on the screen. If the variable is
positive, then EMACS will actually shift text on the screen to
show the open parenthesis. The default setting of the variable
is -1.
An additional parameter is whether EMACS should warn you by
ringing the bell if you type an unmatched close parenthesis. The
default is to warn you if you are editing a language in which
parentheses are paramount, such as Lisp, but not to do so for
languages in which parentheses are not so crucial. This is
controlled by the variable Permit Unmatched Paren. When it is 1,
you are never warned (they are always "permitted"). When it is
0, you are warned, regardless of major mode. When it is -1, you
are warned only in Lisp mode and similar modes (this is the
default). Note that these modes distinguish themselves by
setting the variable locally to 0 if it was -1. Unmatched parens
are always "permitted" in that EMACS will never refuse to insert
them.
While this feature was intended primarily for Lisp, it can be
used just as well for any other language, and it is not dependent
on what major mode you are in. It is expected that you wouldn't
want it in Text mode, so Text mode sets the variable Display
Matching Paren locally to zero. If you do want the feature in
Text mode, you can create a Text Mode Hook variable which sets
the variable back to -1. See the file INFO;CONV, node Hooks, for
more info on Text Mode Hook. The way to control which characters
trigger this feature is with the syntax table. Any character
whose Lisp syntax is ")" causes the matching character with
syntax "(" to be shown. Most major modes automatically set up
the syntax table (See section 22.4 [Syntax], page 139.).
The syntax table also controls what is done with the case ofî 107 EMACS Manual for ITS Users
"mismatched" parens, as in "[ )". The third slot in a close
parenthesis character's syntax table entry should be the proper
matching open parenthesis character, if you want this feature
turned on. If that slot contains a space instead, then any open
parenthesis character is considered a legitimate match. If a
close parenthesis is mismatched, it is inserted as always, but it
rings the bell.
The implementation of this feature uses the TECO flag FS
^R PAREN$. See section 22.5 [FS Flags], page 142.
20.5 Manipulating Commentsî 20.5 Manipulating Commentsî 20.5 Manipulating Comments
The comment commands insert, kill and align comments. There
are also commands for moving through existing code and inserting
comments.
M-; Insert or align comment.
C-; The same.
C-M-; Kill comment.
Return Move past comment terminator and onto new
line.
C-X ; Set comment column.
M-N Move to Next line and insert comment.
M-P Move to Previous line and insert comment.
M-J Continue a comment on a new line.
M-Linefeed The same.
The command that creates a comment is Meta-; or Control-;
(^R Indent for Comment). If there is no comment already on the
line, a new comment is created, aligned at a specific column
_______ ______î called the comment column. The comment is created by inserting
whatever string EMACS thinks should start comments in the current
major mode. Point is left after the comment-starting string. If
the text of the line goes past the comment column, then the
indentation is done to a suitable boundary (usually, a multiple
of 8).
Meta-; can also be used to align an existing comment. If a
line already contains the string that starts comments, then M-;
just moves point after it and re-indents it to the right column.
Exception: comments starting in column 0 are not moved.
Even when an existing comment is properly aligned, M-; is still
useful for moving directly to the start of the comment.î 108 EMACS Manual for ITS Users
Some languages require an explicit comment terminator, which is
not simply the end of the line. Although the language may then
allow comments in the middle of the line, the EMACS comment
commands assume that a comment is the last thing on the line.
When there is a comment terminator, M-; inserts the terminator as
well as the starter, and leaves point between them, so that you
are ready to insert the text of the comment. When you are done,
the Return command given immediately before the comment
terminator acts as if it were at the end of the line already: it
moves down to or creates a following blank line. It does not
break the existing line before the comment terminator as you
would expect.
C-M-; (^R Kill Comment) kills the comment on the current line,
if there is one. The indentation before the start of the comment
is killed as well. If there does not appear to be a comment in
the line, nothing is done. To reinsert the comment on another
line, move to the end of that line, do C-Y, and then do M-; to
realign it.
20.5.1 Multiple Lines of Commentsî 20.5.1 Multiple Lines of Commentsî 20.5.1 Multiple Lines of Comments
If you wish to align a large number of comments, you can give
Meta-; an argument and it indents what comments exist on that
many lines, creating none. Point is left after the last line
processed (unlike the no-argument case).
When adding comments to a long stretch of existing code, the
commands M-N (^R Down Comment Line) and M-P (^R Up Comment Line)
may be useful. They are like C-N and C-P except that they do a
C-; automatically on each line as you move to it, and delete any
empty comment from the line as you leave it. Thus, you can use
M-N to move down through the code, putting text into the comments
when you want to, and allowing the comments that you don't fill
in to be removed because they remained empty.
If you are typing a comment and find that you wish to continue
it on another line, you can use the command Meta-J or
Meta-Linefeed (^R Indent New Comment Line), which terminates the
comment you are typing, creates or gobbles a new blank line, and
begins a new comment indented under the old one. When Auto Fill
mode is on, going past the fill column while typing a comment
causes the comment to be continued in just this fashion. Note
that if the next line is not blank, a blank line is created, and
the continuation goes on that line. By comparison, M-N would
create a continuation comment on the next existing line of code.î 109 EMACS Manual for ITS Users
20.5.2 Double and Triple Semicolons in Lispî 20.5.2 Double and Triple Semicolons in Lispî 20.5.2 Double and Triple Semicolons in Lisp
In Lisp code there are conventions for comments which start
with more than one semicolon. Comments which start with two
semicolons are indented as if they were lines of code, instead of
at the comment column. Comments which start with three
semicolons are supposed to start at the left margin. EMACS
understands these conventions by indenting a double-semicolon
comment using Tab, and by not changing the indentation of a
triple-semicolon comment at all. (Actually, this rule applies
whenever the comment starter is a single character and is
duplicated). Note that the :@ program considers a four-semicolon
comment a subtitle in Lisp code.
20.5.3 Options Controlling Commentsî 20.5.3 Options Controlling Commentsî 20.5.3 Options Controlling Comments
The comment column is stored in the variable Comment Column.
You can set it to a number explicitly. Alternatively, the
command C-X ; (^R Set Comment Column) sets the comment column to
the column point is at. C-U C-X ; sets the comment column to
match the last comment before point in the buffer, and then does
a Meta-; to align the current line's comment under the previous
one.
Many major modes supply default local values for the comment
column. In addition, C-X ; automatically makes the variable
Comment Column local. Otherwise, if you change the variable
itself, it changes globally (for all buffers) unless it has been
made local in the selected one. See section 22.7 [Locals],
page 150.
The string recognized as the start of a comment is stored in
the variable Comment Start, while the string used to start a new
comment is kept in Comment Begin (if that is zero, Comment Start
is used for new comments). This makes it possible for you to
have any ";" recognized as starting a comment but have new
comments begin with ";; ** ".
The string used to end a comment is kept in the variable
Comment End. In many languages no comment end is needed as the
comment extends to the end of the line. Then, this variable is a
null string.
If Comment Multi Line is nonzero, then Meta-Linefeed within a
comment does not close the old comment and start a new comment on
the new line. Instead it allows the original comment to extendî 110 EMACS Manual for ITS Users
through the new line. This is legitimate if the language has
explicit comment terminators. Then it's a matter of taste.
20.6 Lisp Mode and Muddle Modeî 20.6 Lisp Mode and Muddle Modeî 20.6 Lisp Mode and Muddle Mode
Lisp's simple syntax makes it much easier for an editor to
understand; as a result, EMACS can do more for Lisp, and with
less work, than for any other language.
Lisp programs should be edited in Lisp mode. In this mode, Tab
is defined to indent the current line according to the
conventions of Lisp programming style. It does not matter where
in the line Tab is used; the effect on the line is the same. The
function which does the work is called ^R Indent for Lisp.
Linefeed, as usual, does a Return and a Tab, so it moves to the
next line and indents it.
As in most modes where indentation is likely to vary from line
to line, Rubout is redefined to treat a tab as if it were the
equivalent number of space (^R Backward Delete Hacking Tabs).
This makes it possible to rub out indentation one position at a
time without worrying whether it is made up of spaces or tabs.
Control-Rubout does the ordinary type of rubbing out which rubs
out a whole tab at once.
Paragraphs are defined to start only with blank lines so that
the paragraph commands can be useful. Auto Fill indents the new
lines which it creates. Comments start with ";". If Atom Word
mode is in effect, them in Lisp mode the word-motion commands
regard each Lisp atom as one word.
The LEDIT library allows EMACS and Lisp to communicate, telling
Lisp the new definitions of functions which you edit in EMACS.
See the file INFO;LEDIT.
The language Muddle is a variant form of Lisp which shares the
concept of using parentheses (of various sorts) as the main
syntactical construct. It can be edited using Muddle mode, which
is almost the same as Lisp mode and provides the same features,
differing only in the syntax table used.î 111 EMACS Manual for ITS Users
20.6.1 Moving Over and Killing Lists and S-expressionsî 20.6.1 Moving Over and Killing Lists and S-expressionsî 20.6.1 Moving Over and Killing Lists and S-expressions
C-M-F Move Forward over s-expression.
C-M-B Move Backward.
C-M-K Kill s-expression forward.
C-M-Rubout Kill s-expression backward.
C-M-U Move Up and backward in list structure.
C-M-( The same.
C-M-) Move up and forward in list structure.
C-M-D Move Down and forward in list structure.
C-M-N Move forward over a list.
C-M-P Move backward over a list.
C-M-T Transpose s-expressions.
C-M-@ Put mark after s-expression.
M-( Put parentheses around next
s-expression(s).
M-) Move past next close parenthesis and
re-indent.
By convention, EMACS commands that deal with balanced
parentheses are usually Control-Meta- characters. They tend to
be analogous in function to their Control- and Meta- equivalents.
These commands are usually thought of as pertaining to Lisp, but
can be useful with any language in which some sort of parentheses
exist (including English).
To move forward over an s-expression, use C-M-F (^R Forward
Sexp). If the first significant character after point is an "(",
C-M-F moves past the matching ")". If the first character is a
")", C-M-F just moves past it. If the character begins an atom,
C-M-F moves to the end of the atom. C-M-F with an argument
repeats that operation the specified number of times; with a
negative argument, it moves backward instead.
The command C-M-B (^R Backward Sexp) moves backward over an
s-expression; it is like C-M-F with the argument negated. If
there are "'"-like characters in front of the s-expression moved
over, they are moved over as well. Thus, with point after
" 'FOO ", C-M-B leaves point before the "'", not before the "F".
These two commands (and most of the commands in this section)
do not know how to deal with the presence of comments. Although
that would be easy to fix for forward motion, for backward motion
the syntax of Lisp makes it nearly impossible. Comments by
themselves can be dealt with, but handling both comments and
strings is impossible with local backward parsing. In a line î 112 EMACS Manual for ITS Users
((FOO ; " BAR
are the open parentheses inside a string? So C-M-B cannot handle
comments, and C-M-F does not either for simplicity's sake.
For this reason, two other commands which move over lists
instead of s-expressions are often useful. They are C-M-N
(^R Forward List) and C-M-P (^R Backward List). They act like
C-M-F and C-M-B except that they don't stop on atoms; after
moving over an atom, they move over the next expression, stopping
after moving over a list. With this command, you can avoid
stopping after all of the words in a comment.
Killing an s-expression at a time can be done with C-M-K and
C-M-Rubout (^R Forward Kill Sexp and ^R Backward Kill Sexp).
C-M-K kills the characters that C-M-F would move over, and
C-M-Rubout kills what C-M-B would move over.
C-M-F and C-M-B stay at the same level in parentheses, when
__î that's possible. To move up one (or n) levels, use C-M-( or
C-M-) (^R Backward Up List and ^R Forward Up List). C-M-( moves
backward up past one containing "(". C-M-) moves forward up past
one containing ")". Given a positive argument, these commands
move up the specified number of levels of parentheses. C-M-U is
another name for C-M-(, which is easier to type, especially on
non-Meta keyboards. If you use that name, it is useful to know
that a negative argument makes the command move up forwards, like
C-M-).
____î To move down in list structure, use C-M-D (^R Down List). It
is nearly the same as searching for a "(".
A somewhat random-sounding command which is nevertheless easy
to use is C-M-T (^R Transpose Sexps), which drags the previous
s-expression across the next one. An argument serves as a repeat
count, and a negative argument drags backwards (thus canceling
out the effect of C-M-T with a positive argument). An argument
of zero, rather than doing nothing, transposes the s-expressions
at the point and the mark.
To make the region be the next s-expression in the buffer, use
or C-M-@ (^R Mark Sexp) which sets mark at the same place that
C-M-F would move to. C-M-@ takes arguments like C-M-F. In
particular, a negative argument is useful for putting the mark at
the beginning of the previous s-expression.
The commands M-( ("^R Insert ()") and M-) ("^R Move Over )")
are designed for a style of editing which keeps parenthesesî 113 EMACS Manual for ITS Users
balanced at all times. M-( inserts a pair of parentheses, either
together as in "()", or, if given an argument, around the next
several s-expressions, and leaves point after the open
parenthesis. Instead of typing "(FOO)", you can type M-( FOO,
which has the same effect except for leaving the cursor before
the close parenthesis. Then you type M-), which moves past the
close parenthesis, deleting any indentation preceding it (in this
example there is none), and indenting with Linefeed after it.
The library LSPUTL contains two other list commands. Find Pat
searches for lists which contain several strings. ^R Extract
Sublist replaces a list with one of its sublists. See
section 22.2 [Libraries], page 135.
<level>M-X Find Pat$<mainstring>$<string1>$<string2> searches
for a list which contains <mainstring> at a depth of <level>
lists down, and contains <string1> and <string2> at any level.
There can be any number of such additional strings to search for;
there can be none of them.
^R Extract Sublist is meant to be connected to a character.
Given an argument of <level>, it replaces the list <level> levels
up from point with its sublist which starts after point.
The library XLISP contains a functions for making various
transformations on Lisp code:
Lowercase Lisp Buffer changes all the Lisp code in the buffer
to lower case, without changing comments, strings, or slashified
characters. Uppercase Lisp Buffer performs the inverse
transformation. Lowercase Lisp Region and Uppercase Lisp Region
are similar but act only between point and mark.
Change / to \ takes Lisp code written with "/" as the
character-quote character and transforms it to use the new
character-quote character, "\". The meaning of the transformed
code in the new syntax is the same as that of the old code in the
old syntax.
XLISP contains several other commands which transform old
constructs into new ones. They behave like Query Replace in that
they display each occurrence of the old construct and ask you
whether to change it to the new one. A Space means yes, a Rubout
means no. Here is a list of these commands, and what each one
transforms.
Modernize FUNCTION References
(FUNCTION ...) into #'...î 114 EMACS Manual for ITS Users
Modernize QUOTE References
(QUOTE ...) into '...
Modernize LAMBDA References
'(LAMBDA ...) into #'(LAMBDA ...)
Modernize MAP References
(MAPxxx '... ...) into (MAPxxx #'... ...)
Modernize NIL Occurrences
NIL into ()
Modernize LAMBDA Combinations
((LAMBDA (X) Y) ARG) into (LET ((X ARG)) Y)
Modernize Strings
'|...| into "..."
facility for replacing obsolete or old-fashioned Maclisp
constructs with equivalent modern ones.
The list commands' understanding of syntax is completely
controlled by the syntax table. Any character can, for example,
be declared to act like an open parenthesis. See section 22.4
[Syntax], page 139.
20.6.2 Commands for Manipulating Defunsî 20.6.2 Commands for Manipulating Defunsî 20.6.2 Commands for Manipulating Defuns
C-M-[, C-M-A Move to beginning of defun.
C-M-], C-M-E Move to end of defun.
C-M-H Put region around wHole defun.
In EMACS, an expression at the top level in the buffer is
_____î called a defun, regardless of what function is actually called by
the expression, because such expressions usually call defun.
In the remotest past, EMACS found defuns by moving upward a
level of parentheses until there were no more levels to go up.
This required scanning all the way back to the beginning of the
file. To speed up the operation, EMACS now assumes that any "("
(or any character with "(" as its Lisp syntax) in column 0 is the
start of a defun. This heuristic is nearly always right and
avoids the costly scan.
The commands to move to the beginning and end of the currentî 115 EMACS Manual for ITS Users
defun are C-M-[ (^R Beginning of Defun) and C-M-] (^R End of
Defun). Alternate names for these two commands are C-M-A for
C-M-[ and C-M-E for C-M-]. The alternate names are easier to
type on many non-Meta keyboards.
If you wish to operate on the current defun, use C-M-H (^R Mark
Defun) which puts point at the beginning and mark at the end of
the current or next defun.
20.7 Lisp Grindingî 20.7 Lisp Grindingî 20.7 Lisp Grinding
The best way to keep Lisp code properly indented ("ground") is
to use EMACS to re-indent it when it is changed. EMACS has
commands to indent properly either a single line, a specified
number of lines, or all of the lines inside a single
s-expression.
Tab In Lisp mode, re-indents line according to
parenthesis depth.
Linefeed Equivalent to Return followed by Tab.
M-^ Join two lines, leaving one space between
them if appropriate.
C-M-Q Re-indent all the lines within one list.
C-M-G Grind a list, moving code between lines.
The basic indentation function is ^R Indent for Lisp, which
gives the current line the correct indentation as determined from
the previous lines' indentation and parenthesis structure. This
function is normally found on C-M-Tab, but when in Lisp mode it
is placed on Tab as well (Use Meta-Tab or C-Q Tab to insert a
tab). If executed at the beginning of a line, it leaves point
after the indentation; when given inside the text on the line, it
leaves point fixed with respect to the characters around it.
When entering a large amount of new code, use Linefeed
(^R Indent New Line), which is equivalent to a Return followed by
a Tab. In Lisp mode, a Linefeed creates or moves down onto a
blank line, and then gives it the appropriate indentation.
To join two lines together, use the Meta-^ or Control-Meta-^
command (^R Delete Indentation), which is approximately the
opposite of Linefeed. It deletes any spaces and tabs at the
front of the current line, and then deletes the line separator
before the line. A single space is then inserted, if EMACSî 116 EMACS Manual for ITS Users
thinks that one is needed there. Spaces are not needed before a
close parenthesis, or after an open parenthesis.
If you are dissatisfied about where Tab indents the second and
later lines of an s-expression, you can override it. If you
alter the indentation of one of the lines yourself, then Tab will
indent successive lines of the same list to be underneath it.
This is the right thing for functions which Tab indents
unaesthetically.
When you wish to re-indent code which has been altered or moved
to a different level in the list structure, you have several
commands available. You can re-indent a specific number of lines
by giving the ordinary indent command (Tab, in Lisp mode) an
argument. This indents as many lines as you say and moves to the
line following them. Thus, if you underestimate, you can repeat
the process later.
You can re-indent the contents of a single s-expression by
positioning point before the beginning of it and typing
Control-Meta-Q (^R Indent Sexp). The line the s-expression
starts on is not re-indented; thus, only the relative indentation
with in the s-expression, and not its position, is changed. To
correct the position as well, type a Tab before the C-M-Q.
Another way to specify the range to be re-indented is with
point and mark. The command C-M-\ (^R Indent Region) applies Tab
to every line whose first character is between point and mark.
In Lisp mode, this does a Lisp indent.
A more powerful grind command which can move text between lines
is C-M-G (^R Format Code). You might or might not like it. It
knows in different ways about Lisp code and Macsyma code.
20.7.1 Customizing Lisp Indentationî 20.7.1 Customizing Lisp Indentationî 20.7.1 Customizing Lisp Indentation
The indentation pattern for a Lisp expression can depend on the
function called by the expression. For each Lisp function, you
can choose among several predefined patterns of indentation, or
define an arbitrary one with a TECO program.
The standard pattern of indentation is as follows: the second
line of the expression is indented under the first argument, if
that is on the same line as the beginning of the expression;
otherwise, the second line is indented one space more than the
entire expression. Each following line is indented under the
previous line whose nesting depth is the same.î 117 EMACS Manual for ITS Users
Another indentation pattern is used for functions whose names
start with "def". The second line of the expression is indented
two spaces more than the entire expression. The variable Lisp
Special Indent Offset (default 2) controls the increment in
depth. Each following line indents under the previous one.
Again, lines starting at lower depths do not count. Setting the
variable Lisp Indent DEFAnything to zero turns this feature off.
Then the standard pattern applies to def- functions by default.
The indentation pattern for expressions that call the function
FOO is controlled specifically by the variable Lisp FOO Indent.
If this variable does not exist, the standard pattern or the
def- pattern is used. If the variable does exist, its value
should be one of these:
-3 selects the standard or def- indentation pattern,
as if the variable did not exist.
-2 selects the standard indentation pattern. The
def- pattern is not used, even if the function
name starts with "def".
-1 selects the def- indentation pattern, independent
of the function name and the setting of Lisp
Indent DEFAnything.
0 or more selects special form with body indentation. The
value of the variable is the number of special
arguments that precede the body; thus, LET and
LAMBDA have one distinguished argument before the
body (the list of bound variables), PROGN has
none, and DO has two. The distinguished
expressions at the beginning are indented using
the standard pattern, but the first expression of
the body, if it should occur at the beginning of
a line, is indented two spaces deeper than the
entire expression. Following lines indent each
under the previous one as usual. The variable
Lisp Special Indent Offset (default 2) controls
the increment in depth.
a string should be a TECO expression which implements an
indentation pattern. Initially, Lisp PROG Indent
is defined as a string (the definition of &
Standard Lisp PROG Indent) which detects tags and
indents them specially.
The variable Lisp Indent Offset, if nonzero, selects a
different indentation pattern as the standard one. It indents
the second line of each expression that many spaces deeper than
the enclosing expression.î 118 EMACS Manual for ITS Users
Implementing and selecting among the above indentation patterns
is the responsibility of the definition of the variable Lisp
Indentation Hook. This variable must exist and its value must be
a TECO program. By default its value is the definition of &
Standard Lisp Indentation Hook.
Whatever its value, the hook is called with two arguments,
which are the position in the buffer of the most recent unclosed
"(" and the buffer position of the beginning of the line to be
indented. The buffer position of the cursor at the time the tab
was typed is stored as an offset from Z in qZ, so Z-qZ is that
buffer position. The hook should not modify the buffer. If it
returns 0 or no value, the caller will use the horizontal cursor
position of point as the column to indent to. Hence, to indent
under the "O" in PROG, it is sufficient to jump to that character
in the buffer and return. Alternatively, the hook can simply
return the desired indentation column number as a value.
The hook should return a nonzero precomma value if following
lines of the same expression should be indented individually. If
it does not return a nonzero precomma value, the caller may
remember the indentation of this line and indent following lines
the same way.
If Lisp FOO Indent has a TECO expression as its value, the same
interface conventions apply to it.
Different Lisp-like languages can select an entirely different
set of indentation patterns by changing the value of the variable
Lisp Indent Language. Normally the value of this variable is the
string "Lisp". All the variables listed above with names
beginning with "Lisp" actually should have names beginning with
the Lisp Indent Language. Thus, if Lisp Indent Language is
changed to "Muddle", then the indentation commands will look for
variables Muddle Indent Offset, Muddle Indentation Hook, Muddle
PROG Indent, etc.
20.8 Editing Assembly-Language Programsî 20.8 Editing Assembly-Language Programsî 20.8 Editing Assembly-Language Programs
MIDAS mode is designed for editing programs written in the
MIDAS assembler. Major modes for other assemblers, such as PALX,
also exist but differ only in the syntax table and in the name of
the major mode hook that they will invoke. (There is also IBM370
mode, for 370 assembler, which is completely different. Refer to
the self-documentation of the IBM370 library for information on
it).î 119 EMACS Manual for ITS Users
In MIDAS mode, comments start with ";", and "<" and ">" have
the syntax of parentheses. In addition, there are five special
commands which understand the syntax of instructions and labels.
These commands are:
C-M-N Go to Next label.
C-M-P Go to Previous label.
C-M-A Go to Accumulator field of instruction.
C-M-E Go to Effective Address field.
C-M-D Kill next word and its Delimiting character.
Two other commands with slightly different uses are
M-[ Move up to previous blank line.
M-] Move down to next blank line.
Any line which is not indented and is not just a comment is
taken to contain a label. The label is everything up to the
first whitespace (or the end of the line). C-M-N (^R Go to Next
Label) and C-M-P (^R Go to Previous Label) both position the
cursor right at the end of a label; C-M-N moves forward or down
and C-M-P moves backward or up. At the beginning of a line
containing a label, C-M-N moves past it. Past the label on the
same line, C-M-P moves back to the end of it. If you kill a
couple of indented lines and want to insert them right after a
label, these commands put you at just the right place.
C-M-A (^R Go to AC Field) and C-M-E (^R Go to Address Field)
move to the beginning of the accumulator (AC) or effective
address fields of a PDP-10 instruction. They always stay on the
same line, moving either forward or backward as appropriate. If
the instruction contains no AC field, C-M-A positions to the
start of the address field. If the instruction is just an opcode
with no AC field or address field, a space is inserted after the
opcode and the cursor left after the space. In PDP-11 programs,
C-M-A moves to the first operand and C-M-E moves to the second
operand.
Once you've gone to the beginning of the AC field you can often
use C-M-D (^R Kill Terminated Word) to kill the AC name and the
comma which terminates it. You can also use it at the beginning
of a line, to kill a label and its colon, or after a line's
indentation to kill the opcode and the following space. This is
very convenient for moving a label from one line to another. Inî 120 EMACS Manual for ITS Users
general, C-M-D is equivalent to M-D C-D, except that all the
characters are saved on the kill ring, together. C-D, a
"deletion" command, doesn't save on the kill ring if not given an
argument.
The M-[ and M-] commands are not, strictly speaking, redefined
by MIDAS mode. They go up or down to a paragraph boundary, as
usual. However, in MIDAS mode the criterion for a paragraph
boundary is changed by setting the variable Paragraph Delimiter
(See section 11.2 [Paragraphs], page 52.) so that only blank
lines (and pages) delimit paragraphs. So, M-[ moves up to the
previous blank line and M-] moves to the next one.
20.9 Major Modes for Other Languagesî 20.9 Major Modes for Other Languagesî 20.9 Major Modes for Other Languages
MACSYMA mode redefines the syntax of words and s-expressions in
an attempt to make it easier to move over MACSYMA syntactic
units. In addition, the C-M-G "grind" command is told to grind
text as MACSYMA instead of as Lisp. Also, the syntax of MACSYMA
comments is understood.
TECO mode is good for editing EMACS library source files. It
connects Tab to ^R Indent Nested (see its self-documentation).
Comments start with "!* " and end with "!". In addition, the
PURIFY library, which contains many things useful for processing
library sources (including the commands to compile them), is
loaded. M-' and M-" are connected to functions ^R Forward TECO
Conditional and ^R Backward TECO Conditional which move forward
and backward over balanced TECO conditionals. In TECO mode on a
terminal with a Meta key, it may be useful to set the TECO flag
FS CTLMTA$ which causes Control-Meta commands to insert Control
characters. See section 22.5 [FS Flags], page 142.
CLU mode is for editing CLU code. It is similar to LISP mode,
but it treats the statement nesting tokens like the appropriate
sorts of parentheses. It is in the library called CLU. See the
file INFO;ECLU.
PL1 mode is for editing PL1 code, and causes Tab to indent an
amount based on the previous statement type. The body of the
implementation of PL1 mode is in the library PL1, which is loaded
automatically when necessary. See the file INFO;EPL1.
PASCAL mode is similar to PL1 mode, for PASCAL. It is in the
library called PASCAL. See the file INFO;EPASC.î 121 EMACS Manual for ITS Users
FORTRAN mode is implemented by the FORTRAN library. See the
file INFO;EFORTRAN.
There are major modes for many other languages, but
documentation for them except that in the libraries themselves.
Any volunteers to write some? Meanwhile, you can look at the
documentation in the libraries. See section 22.2 [Libraries],
page 135.î 122 EMACS Manual for ITS Users
CHAPTER TWENTY-ONEî CHAPTER TWENTY-ONEî CHAPTER TWENTY-ONE
THE TAGS PACKAGE.î THE TAGS PACKAGE.î THE TAGS PACKAGE.
The TAGS package remembers the locations of the function
definitions in a file and enables you to go directly to the
definition of any function, without searching the whole file.
The functions of several files that make up one program can all
be remembered together if you wish; then the TAGS package will
automatically select the appropriate file as well.
21.1 How to Make a Tag Table for a Programî 21.1 How to Make a Tag Table for a Programî 21.1 How to Make a Tag Table for a Program
To use the TAGS package, you must create a tag table for the
source file or files in your package. Normally, the tag table
does not reside in any of those files, but in a separate tag
table file which contains the names of the text files which it
describes. Tag table files are generated by the :TAGS program.
The same program can be used to update the tag table if it
becomes very far out of date (slight inaccuracies do not matter).
Tag tables for INFO files work differently; the INFO file
contains its own tag table, which describes only that file. See
section 21.8 [INFO tag tables], page 131, for how to deal with
them.
The normal mode of operation of the :TAGS program is to read in
an existing tag table and update it by rescanning the source
files that it describes. The old tag table file itself tells
:TAGS which source files to process. When making a new tag table
you must start by making a skeleton. Then :TAGS is used to turn
the skeleton into an accurate tag table.
A skeleton tag table is like a real one except that it is
empty; there are no tags in it. It contains exactly this much
data, for each source file that it is going to describe:
<filenames>
0,<language>
^î |_
The languages that :TAGS understands now are TECO, LISP, MIDAS,
FAIL, PALX, MUDDLE, MACSYMA, TJ6, and R. MIDAS will do forî 123 EMACS Manual for ITS Users
MACRO-10 files. Any incompletely specified filenames will
default to > and to the directory on which the tag table file
____î itself is stored. The "0," must be present, since :TAGS expects
that there will be a number in that place and will be completely
^ ____î confused if there is not. The CRLF after each |_ also must be
^î present. You can omit both the last |_ and its CRLF together,
however.
Thus, a skeleton tag table for the files EMACS;USRCOM > and
EMACS;TAGS > would look like
EMACS;USRCOM >
0,TECO
^î |_
EMACS;TAGS >
0,TECO
^î |_
If this were written out as EMACS;EMACS TAGS, you could then do
_______ ___ __ ____î :TAGS EMACS;EMACS (default FN2 is TAGS)
which would tell :TAGS to read in the tag table, and write back
an up-to-date tag table for the same set of source files. To
update the tag table because lots of changes have been made, the
same command to the :TAGS program will work. See section 21.6
[Edit], page 129, for info on adding, deleting, or renaming files
in existing tag tables.
The recently developed TAGGEN library is contains the function
Generate Tags File for updating a tag table. This library may
eventually replace the TAGS program, being easier to customize.
In the mean time, you are encouraged to try it out. Refer to its
self-documentation for more information.
21.2 How to Tell EMACS You Want to Use TAGSî 21.2 How to Tell EMACS You Want to Use TAGSî 21.2 How to Tell EMACS You Want to Use TAGS
Before you can use the TAGS package to find a tag, you must
tell EMACS the name of the tag table file you want to use. This
is done with the commandî 124 EMACS Manual for ITS Users
M-X Visit Tag Table$ <filenames> <cr>
The FN2 of "TAGS" need not be mentioned.
EMACS can only know about one tag table file at a time, so
doing a second M-X Visit Tag Table causes the first one to be
forgotten (or written back if you have added definitions to it).
Giving M-X Visit Tag Table a nonzero numeric argument, as in
C-U 1 M-X Visit Tag Table$ <filenames> <cr>
has the additional effect of setting the variable Tags Find File
nonzero, which causes the TAGS package to use Find File rather
than Visit File when it needs to switch files. This causes all
the files to remain resident in the EMACS, in different buffers.
In the default mode, visiting a tag in a different file read it
in on top of the old file, in the same buffer (but it offers to
write out changes if there are any). Warning: you can easily run
out of address space by making too many buffers, this way. See
section 24.2.5 [Storage Exhausted], page 161. .
Visit Tag Table is essentially equivalent to selecting the
buffer *TAGS* and visiting the tag table file in that buffer,
then returning to the previously selected buffer. Afterwards,
M-X List Buffers will show the buffer *TAGS* visiting that file.
The only difference is that Visit Tag Table causes the TAGS
library to be loaded.
21.3 Jumping to a Tagî 21.3 Jumping to a Tagî 21.3 Jumping to a Tag
To jump to the definition of a function, use the command
Meta-Period <tag name> <cr>. You will go straight to the
definition of the tag. If the definition is in a different file
then TAGS visits that file. If it is in the same file, TAGS
leaves the mark behind and prints "^@" in the echo area.
You do not need to type the complete name of the function to be
found; any substring will do. But this implies that sometimes
you won't get the function you intended. When that happens, C-U
Meta-Period will find the "next" function matching what you typed
(next, in the order of listing in the tag table). Thus, if you
want to find the definition of X-SET-TYPE-1 and you specify justî 125 EMACS Manual for ITS Users
TYPE-1, you might find X-READ-TYPE-1 instead. You could then
type C-U Meta-Period until you reach X-SET-TYPE-1.
If you want to make sure you reach a precise function the first
time, you should just include a character of context before and
after its name. Thus, in a Lisp program, put a space before and
after the function name. In a MIDAS program, put a linefeed
before it and a colon after.
If Meta-Period is used before M-X Visit Tag Table has been
done, it asks for the name of a tag table file. After you type
this name and a <cr>, you type the name of the tag as usual. If
the variable Tag Table Filenames exists, it specifies the
defaults for the filename.
Typing an Altmode as the first character of the argument to
Meta-Period allows you to switch to a new tag table. It prompts
for the tag table filenames, then prompts again for the tag.
21.4 Other Operations on Tag Tablesî 21.4 Other Operations on Tag Tablesî 21.4 Other Operations on Tag Tables
21.4.1 Adding a New Function to a Tag Tableî 21.4.1 Adding a New Function to a Tag Tableî 21.4.1 Adding a New Function to a Tag Table
When you define a new function, its location doesn't go in the
tag table automatically. That's because EMACS can't tell that
you have defined a function unless you tell it by invoking the
function ^R Add Tag. Since the operation of adding a tag to a
tag table has proved not to be very necessary, this function no
longer placed on any character, by default. You can invoke with
M-X or connect it to a character if you like. For this section,
let's assume you have placed it on C-X Period.
When you type the command C-X Period, the pointer should be on
the line that introduces the function definition, after the
function name and the punctuation that ends it. Thus, in a Lisp
program, you might type "(DEFUN FOO " (note the space after FOO)
and then type the C-X Period. In a MIDAS program, you might give
the C-X Period after typing "FOO:". In a TECO program in EMACS
format, you might type C-X Period after "!Set New Foo:!".
^R Add Tag modifies only the copy of the tag table loaded into
EMACS. To modify the tag table file itself, you must cause it to
be saved. M-X Save All Files is the easiest way to do this.
Although local modifications to a file do not degrade theî 126 EMACS Manual for ITS Users
efficiency of the TAGS package or require that the tag table be
updated with :TAGS, moving a function a great distance make it
much slower to find that function. In this case, you can "add"
the function to the tag table with C-X Period to give the table
its new location. Or you can just run :TAGS again to update
everything, as is usually done.
21.4.2 How to Process All the Files in a Tag Tableî 21.4.2 How to Process All the Files in a Tag Tableî 21.4.2 How to Process All the Files in a Tag Table
The TAGS package contains a function M-X Next File which
visits, one by one, all the files described by the selected tag
table. This is useful when there is something to be done to all
of the files in the package. To start off the sequence, do C-U 1
M-X Next File, which visits the first file. When you are
finished operating on one file, do M-X Next File (no argument) to
see the next. When all the files have been processed, M-X Next
File gives an error.
The files of the package are visited in the order that they are
mentioned in the tag table, and the current place in the sequence
is remembered by the pointer in the buffer *TAGS* which holds the
tag table. Thus, if you visit a tag in a different file in the
middle of a M-X Next File sequence, you will screw it up unless
you return to the proper file again by visiting a tag (or go into
the buffer *TAGS* and reset the pointer). However, visiting any
other files directly, not using TAGS, does not interfere with the
sequence, and the next M-X Next File will go just where it would
have gone.
Next File is also useful as a subroutine in functions that wish
to perform an automatic transformation (such as a Query Replace)
on each file. Such functions should call Next File with a
precomma argument as in 1,M(M.M Next File$) or 1,1M(M.M Next
File$). The precomma argument tells Next File to return 0
instead of giving an error when there are no more files to
process. Normally, it returns -1.
Here is an example of TECO code to do a Query Replace on all of
the files listed in the visited tag table:
1M(M.M Next File$)
< M(M.M Query Replace$)FOO$BAR$
1,M(M.M Next File$);>
Tags Search and Tags Query Replace (see below) both work using
Next File.î 127 EMACS Manual for ITS Users
21.4.3 Multi-File Searches and Replacementsî 21.4.3 Multi-File Searches and Replacementsî 21.4.3 Multi-File Searches and Replacements
The TAGS package contains a function Tags Search which will
search through all of the files listed in the visited tag table
in the order they are listed. Do
M-X Tags Search$<string><cr>
to find every occurrence of <string>. <string> is a TECO search
^ ^î string in which special TECO search characters such as |O, |X,
^ ^ ^î |N, |B, and |Q are allowed. See section 19.3 [TECO Search
Strings], page 101.
When M-X Tags Search reaches the end of the buffer, it visits
the next file automatically, typing its name in the echo area.
As soon as M-X Tags Search finds one occurrence, it returns. But
it defines the command Control-Period to resume the search from
wherever point is.
M-X Tags Query Replace does a Query Replace over all the files
in a tag table. Like M-X Tags Search, it sets Control-. up to be
a command to continue the Query Replace, in case you wish to
exit, do some editing, and then resume scanning.
With Tags Find File set nonzero, Tags Search or Tags Query
Replace could easily require more buffers than EMACS has room
for. To prevent such a problem, they do not always put each file
in a separate buffer. If Tags Search or Tags Query Replace wants
to search a file which is already visited in some buffer, it uses
the copy in that buffer. But if the file is not present, and
Tags Find File is 1, then instead of visiting it in its own
buffer, they visit it in a buffer named *Tags Search*. So at
most one new buffer is created. If Tags Find File is 2, a new
buffer is created for each file.
The library MQREPL enables you to use Next File to repeat a
sequence of many Query Replace commands over a set of files,
performing all the replacements on one file at a time.
21.4.4 Miscellaneous Applications of Tagsî 21.4.4 Miscellaneous Applications of Tagsî 21.4.4 Miscellaneous Applications of Tags
M-X List Tags$<file><cr> lists all the tags in the specified
file. Actually, all the files in the tag table whose names
contain the string <file> are listed.î 128 EMACS Manual for ITS Users
M-X Tags Apropos$<pat><cr> lists all known tags whose names
contain <pat>.
M-X Tags File List inserts in the buffer a list of the files
known in the visited tag table.
M-X Tags Rescan runs :TAGS over the visited tag table and
revisits it. This is the most convenient way to update the tag
table.
M-X View Arglist$<tag><cr> lets you look briefly at the line on
which a tag is defined, and at the lines of comments which
precede the definition. This is a good way to find out what
arguments a function needs. The file is always loaded into a
separate buffer, when this command is used.
M-X What Tag? tells you which function's definition you are in.
It looks through the tag table for the tag which most nearly
precedes point.
21.5 What Constitutes a Tagî 21.5 What Constitutes a Tagî 21.5 What Constitutes a Tag
In Lisp code, a function definition must start with an "(" at
the beginning of a line, followed immediately with an atom which
starts with "DEF" (and does not start with "DEFP"), or which
starts with "MACRO", or which starts with "ENDF". The next atom
on the line is the name of the tag. If there is no second atom
on the line, there is no tag.
In MIDAS code, a tag is any symbol that occurs at the beginning
of a line and is terminated with a colon or an equal sign. MIDAS
mode is good for MACRO-10 also.
^î FAIL code is like MIDAS code, except that one or two |A's or
"^"'s are allowed before a tag, spaces are allowed between the
tag name and the colon or equal sign, and _ is recognized as
equivalent to =.
PALX code is like MIDAS code, except that spaces are allowed
between a tag and the following colon or equals, and local tags
such as "10$" are ignored.
In TECO code, a tag starts with an "!" and ends with a ":!".
There may be any number of tags on a line, but the first one must
start at the beginning of a line.î 129 EMACS Manual for ITS Users
In MUDDLE code, a tag is identified by a line that starts with
"<DEFINE " or "<DEFMAC ", followed by a symbol.
In MACSYMA code, a function definition is recognized when there
is a symbol at the beginning of a line, terminated with a "(" or
"[", and there is a ":" later on in the line. If the symbol
itself is terminated with a ":", a variable definition is
recognized.
In R text, any line which starts with ".de" or ".am" or ".rtag"
defines a tag. The name of the tag is what follows, up to the
second run of spaces or the end of the line. There is no ".rtag"
in R; define it to be a null macro, if you like, and use it to
put in tags for chapters, or anything else. Any macro whose name
starts with "de" or "am" or "rtag", such as ".define" or
".amplify", also defines a tag.
In TJ6 text, any line which starts with ".C TAG" starts a tag.
The name of the tag is whatever follows the spaces which should
follow the "C TAG", up to the next space or the end of the line.
21.6 Adding or Removing Source Filesî 21.6 Adding or Removing Source Filesî 21.6 Adding or Removing Source Files
A tag table file is a sequence of entries, one per file. Each
entry looks like
<filenames>
<count>,<language>
<data lines>
^î |_
<filenames> are the fully defaulted names of the file,
<language> is one of the languages that TAGS knows how to
process, and <data lines> are the actual tag information
^ ____î (described below). The CRLF after each |_ must be present. You
^î can omit both the last |_ and its CRLF together, however.
A tags table file is for the most part an ordinary ASCII file,
and any changes you make in it, including changes to the source
files' names, will do what they appear to do.
The one exception is that each entry contains a count, in
^î decimal, of the number of characters in it, including the |_ and
CRLF. If you edit the contents of an individual source file'sî 130 EMACS Manual for ITS Users
entry, and change its length, then the tag table is no good for
use in editing until the count is updated. This is usually done
by running :TAGS over it. :TAGS ignores the specified count and
always writes the correct count. If you are sure that the length
is unchanged, or if you change the count manually, then running
:TAGS is not necessary, but you do so at your own risk.
Thus, if you are changing a source file's name, you should
simply change the name where it is present in the tag table, and
run :TAGS over it if necessary.
To add a new source file, simply insert a dummy entry of the
sort used in making a new tag table. Then use :TAGS to update the
tag table. The dummy will turn into a real entry.
You can delete a source file from a tag table by deleting its
entire entry. Since the counts of the remaining entries are
still valid, you need not run :TAGS over the file again. You can
also change the order of the entries without doing any harm. The
order of the entries matters if there are tags which appear in
more than one source file.
You can edit everything else in the tag table too, if you want
to. You might want to change a language name once in a while,
but I doubt you will frequently want to add or remove tags,
especially since that would all be undone by the next use of
:TAGS!
21.7 How a Tag Is Described in the Tag Tableî 21.7 How a Tag Is Described in the Tag Tableî 21.7 How a Tag Is Described in the Tag Table
A tag table file consists of one or more entries in succession.
Each entry lists the tags of one source file, and has the overall
format described in the previous section, containing zero or more
lines describing tags. Here we give the format of each of those
lines.
Starting with the third line of the tag table entry, each line
describes a tag. It starts with a copy of the beginning of the
line that the tag is defined on, up through the tag name and its
terminating punctuation. Then there is a rubout, followed by the
character position in decimal of the place in the line where
copying stopped. For example, if a line in a MIDAS program
starts with "FOO:" and the colon is at position 602 in the file,
then the line describing it in the tag table would beî 131 EMACS Manual for ITS Users
FOO:<rubout>603
One line can describe several tags, if they are defined on the
same line; in fact, in that case, they must be on the same line
in the tag table, since it must contain everything before the tag
name on its definition line. For example,
!Foo:! !Bar:!
in a file of TECO code followed by character number 500 of the
file would turn into
!Foo:! !Bar:!<rubout>500
EMACS will be able to use that line to find either FOO or BAR.
:TAGS knows how to create such things only for TECO files, at the
moment. They aren't necessary in Lisp or MACSYMA files. In
MIDAS files, :TAGS simply ignores all but the first tag on a
line.
21.8 Tag Tables for INFO Structured Documentation Filesî 21.8 Tag Tables for INFO Structured Documentation Filesî 21.8 Tag Tables for INFO Structured Documentation Files
INFO files are divided up into nodes, which the INFO program
must search for. Tag tables for these files are designed to make
the INFO program run faster. Unlike a normal tag table, the tag
table for an INFO file resides in that file and describes only
that file. This is so that INFO, when visiting a file, can
automatically use its tag table if it has one. INFO uses the tag
tables of INFO files itself, without going through the normal
TAGS package, which has no knowledge of INFO file tag tables.
Thus, INFO file tag tables and normal ones resemble each other
only in their appearance and purpose, and that for convenience
the same :TAGS program generates both. In use, they are
unrelated.
To create a tag table in an INFO file, you must first put in a
skeleton. This skeleton must be very close to the end of the
file (at most 8 lines may follow it, or INFO will not notice it),
^ ^ ^î and it must start on the line following a |_ or |_|L which ends a
node. Its format is as follows:î 132 EMACS Manual for ITS Users
^ ^î |_|L
Tag Table:
^î |_
End Tag Table
No nodes may follow the tag table, or :TAGS will not put them
in it. :TAGS is one pass and after writing the tag table into
the file it copies the rest of the input file with no processing.
To turn the skeleton into the real thing, or to update the tag
table, run :TAGS on the file and specify the /I switch, as in
:TAGS INFO;EMACS/I
:TAGS will process the file and replace the old tag table or
skeleton with an up-to-date tag table. The /I identifies the
specified file as an INFO file rather than a tag table file.
Also, it makes the default FN2 ">" rather than the usual "TAGS".
Once the tag table is constructed, INFO will automatically make
use of it. A tag in an INFO file is just a node; whatever
^î follows "Node:" on a line whose predecessor contains a "|_" is
taken to be a tag. The character which terminates the node name,
which may be a comma, tab, or CRLF, is not included in the tag
table. Instead, the rubout comes right after the tag name. This
is to make it easy for INFO to demand an exact match on node
names, rather than the substring match which the TAGS package
normally uses.
Tag tables in INFO files must be kept close to up to date.
INFO will not find the node if its start has moved more than 1000
characters before the position listed in the tag table. For best
results, you should update an INFO file's tag table every time
you modify more than a few characters of it.î 133 EMACS Manual for ITS Users
CHAPTER TWENTY-TWOî CHAPTER TWENTY-TWOî CHAPTER TWENTY-TWO
SIMPLE CUSTOMIZATIONî SIMPLE CUSTOMIZATIONî SIMPLE CUSTOMIZATION
In this chapter we describe the many simple ways of customizing
EMACS without knowing how to write TECO programs.
One form of customization, reconnection of commands to
functions, was discussed above in the explanation of how M-X
commands work. See section 5.2.3 [Reconnecting Commands],
page 26.
22.1 Minor Modesî 22.1 Minor Modesî 22.1 Minor Modes
Minor modes are options which you can use or not. For example,
Auto Fill mode is a minor mode in which Spaces break 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, "Fill" in the
mode line means that Auto Fill mode is on.
Each minor mode is the name of the function that can be used to
turn it on or off. With no argument, the function turns the mode
on if it was off and off if it was on. This is known as
________î toggling. A positive argument always turns the mode on, and an
explicit zero argument or a negative argument always turns it
off. All the minor mode functions are suitable for connecting to
single or double character commands if you want to enter and exit
a minor mode frequently.
Auto Fill mode allows you to type text endlessly without
worrying about the width of your screen. Line separators are be
inserted where needed to prevent lines from becoming too long.
See section 11.4 [Filling], page 56.
Auto Save mode protects you against system crashes by
periodically saving the file you are visiting. Whenever you
visit a file, auto saving is enabled if Auto Save Default is
nonzero; in addition, M-X Auto Save allows you to turn auto
saving on or off in a given buffer at any time. See section 13.3
[Auto Save], page 72.
Atom Word mode causes the word-moving commands, in Lisp mode,
to move over Lisp atoms instead of words. Some people like this,
and others don't. In any case, the s-expression motion commandsî 134 EMACS Manual for ITS Users
can be used to move over atoms. If you like to use segmented
atom names like FOOBAR-READ-IN-NEXT-INPUT-SOURCE-TO-READ, then
you might prefer not to use Atom Word mode, so that you can use
M-F to move over just part of the atom, or C-M-F to move over the
whole atom.
Overwrite mode causes ordinary printing characters to replace
existing text instead of shoving it over. It is good for editing
pictures. For example, if the point is in front of the B in
FOOBAR, then in Overwrite mode typing a G changes it to FOOGAR,
instead of making it FOOGBAR as usual. Also, Rubout is changed
to turn the previous character into a space instead of deleting
it.
SAIL Character mode causes ASCII control characters in text to
display as themselves, with no conversion. This assumes that the
terminal uses codes 200 and above for cursor motion and erasure,
and can display all the ASCII control characters as graphic
^î characters. The command Control-|B runs this command.
^î Control-|B is a character which can generally only be typed on
terminals which can display the ASCII control characters in the
appropriate fashion.
Word Abbrev mode allows you to define abbreviations that
automatically expand as you type them. For example, "wam" might
expand to "word abbrev mode". The abbreviations may depend on
the major (e.g. Lisp, Text, ...) mode you are currently in. To
use this, you must load the WORDAB library. See section 25
[Wordab], page 172.
Indent Tabs mode controls whether indentation commands use tabs
and spaces or just spaces to indent with. Usually they use both,
but you might want to use only spaces in a file to be processed
by a program or system which doesn't ignore tabs, or for a file
to be shipped to a system like Multics on which tab stops are not
every 8 characters.
Most minor modes are actually controlled by variables. The
mode is on if the variable is nonzero. Setting the minor mode
with a command works by changing the variable. This means that
you can turn the modes on or off with Edit Options, or make their
values local to a buffer. See section 22.3 [Variables],
page 137.
You could also put a minor mode in the local modes list of a
file, but that is usually bad practice. This is because usually
the preference for a minor mode is usually a matter of individual
style rather than a property of the file per se. To make this
more concrete, it is a property of a file that it be filled to aî 135 EMACS Manual for ITS Users
certain column, but use of Auto Fill mode to accomplish that is a
matter of taste. So it would be good practice for the file to
specify the value of Fill Column, but bad practice for the file
to specify the value of Auto Fill Mode.
If you find yourself constantly tempted to turn on Auto Fill
mode in local modes lists, what you probably really want is to
have Auto Fill mode on whenever you are in Text mode. This can
be accomplished with the following code in an EVARS file:
Text Mode Hook: 1M.LAuto Fill Mode$
Suffice it to explain that this is TECO code to be executed
whenever Text mode is entered, which makes the variable Auto Fill
Mode local to the buffer with local value 1.
22.2 Libraries of Commandsî 22.2 Libraries of Commandsî 22.2 Libraries of Commands
All EMACS functions, including the ones described in this
document, reside in libraries. A function is not accessible
unless the library that contains it is loaded. Every EMACS
starts out with one library loaded: the EMACS library. This
contains all of the functions described in this document, except
those explicitly stated to be elsewhere. Other libraries are
provided with EMACS, and can be loaded automatically or on
request to make their functions available. See section
[Catalogue], page 234, for a list of them.
To load a library, say M-X Load Library$<libname><cr>. The
library is found, either on your own directory or whichever one
you specify, or on the EMACS directory, and loaded in. All the
functions in the library are then available for use. Whenever
you use M-X, the function name you specify is looked up in each
of the libraries which you have loaded, more recently loaded
libraries first. The first definition found is the one that is
used.
For example, if you load the PICTURE library, you can then use
M-X Edit Picture to run the Edit Picture function which exists in
that library.
In addition to making functions accessible to M-X, the library
may connect some of them to command characters. This is done by
the library's & Setup function (See the file INFO;CONV, nodeî 136 EMACS Manual for ITS Users
Lib.). If you give Load Library an argument, the setup is not
done.
You can also load a library temporarily, just long enough to
use one of the functions in it. This avoids taking up space
permanently with the library. Do this with the function Run
Library, as in M-X Run$<libname>$<function name><cr>. The
library <libname> is loaded in, and <function name> executed.
Then the library is removed from the EMACS job. You can load it
in again later.
M-X List Loaded Libraries types the names and brief
descriptions of all the libraries loaded, last loaded first. The
last one listed is always the EMACS library.
You can get a brief description of all the functions in a
library with M-X List Library$<libname><cr>, whether the library
is loaded or not. This is a good way to begin to find out what
is in a library that has no INFO documentation. Continue by
loading the library and using Help D to inquire further about
whichever functions looked interesting.
The function Kill Libraries can be used to discard libraries
loaded with Load Library. (Libraries used with Run Library are
discarded automatically). However, of all the libraries
presently loaded, only the most recently loaded one can be
discarded. Kill Libraries offers to kill each loaded library,
most recently loaded first. It keeps killing libraries until you
say to keep one library. Then it returns, because the remaining
libraries cannot be deleted if that library is kept.
Libraries are loaded automatically in the course of executing
certain functions. You will not normally notice this. For
example, the TAGS library is automatically loaded in whenever you
use M-. or Visit Tag Table for the first time. This process is
___________î known as autoloading. It is used to make the functions in the
TAGS library available without the user's having to know to load
the library himself, while not taking up space in EMACSes of
people who aren't using them. It works by simply calling Load
Library on the library known to be needed. Another kind of
autoloading loads a library temporarily, the way Run Library
does. This is done when you use the DIRED function, for example,
since the DIRED library is not needed after the DIRED function
returns. (This does not use Run Library; it uses M.A, which is
what Run Library uses).
You can make your own libraries, which you and other people can
then use, if you know how to write TECO code. See the file INFO;
CONV, node Lib, for more details.î 137 EMACS Manual for ITS Users
22.3 Variablesî 22.3 Variablesî 22.3 Variables
A variable is a name which is associated with a value, either a
number or a string. EMACS uses many variables internally, and
has others whose purpose is to be set by the user for
customization. (They may also be set automatically by major
modes.) One example of such a variable is the Fill Column
variable, which specifies the position of the right margin (in
characters from the left margin) to be used by the fill and
justify commands.
The easiest way for the beginner to set a named variable is to
use the function Edit Options. This shows you a list of selected
variables which you are likely to want to change, together with
their values, and lets you edit them with the normal editing
commands in a recursive editing level. Don't make any changes in
the names, though! Just change the values. Digits with maybe a
minus sign stand for a numeric value of the variable, while
string values are enclosed in doublequotes. Each option is
followed by a comment which says what the option is for. Type
the Help character for more information on the format used.
When you are finished, exit Edit Options using C-M-C and the
changes will take effect. If you decide not to make the changes,
C-] gets out without redefining the options. See section 6.3
[Recursive Editing Levels], page 30.
If you give Edit Options a string argument, it shows you only
the options whose names include the string. For example, M-X
Edit Options$Fill<cr> shows only the options that have "Fill" in
their names. This is much more convenient, if you know what you
plan to do.
However, Edit Options can be used only to set a variable which
already exists, and is marked as an option. Some commands refer
to variables which do not exist in the initial environment. Such
commands always use a default value if the variable does not
exist. In these cases you must create the variable yourself if
you wish to use it to alter the behavior of the command. Use M-X
Set Variable for this. You can set the variable to a numeric
value by doing
C-U <number> M-X Set Variable$<varname><cr>
or to a string by doing î 138 EMACS Manual for ITS Users
M-X Set Variable$<varname>$<string><cr>
In fact, you can use Set Variable to set any variable, whether
it exists already or not. For existing variables, it does not
matter whether you use upper case or lower case letters, and you
are allowed to abbreviate the name as long as the abbreviation is
unique. If the variable might not exist yet, you must type the
name in full. While either upper case or lower case will still
work, you are encouraged to capitalize each word of the name for
aesthetic reasons since EMACS stores the name as you give it.
To examine the value of a single variable, do
M-X View Variable$<varname><cr>
To print a complete list of all variables, do M-X List
Variables. List Variables with a string argument shows only the
variables whose names or values contain that string (like the
function Apropos). M-X Describe can be given a variable's name
instead of a function's name; it prints the variable's value and
its documentation, if it has any.
If you want to set a variable a particular way each time you
use EMACS, you can use an init file or an EVARS file. This is
one of the main ways of customizing EMACS for yourself. An init
file is a file of TECO code to be executed when you start EMACS
up. They are very general, but writing one is a black art. You
might be able to get an expert to do it for you, or modify a copy
of someone else's. See the file INFO;CONV, node Init, for
details. An EVARS file is a much simpler thing which you can do
yourself. See section 22.6 [EVARS files], page 143.
You can also set a variable with the TECO command
<value> M.V <varname>$
or
:I*<string>$ M.V <varname>$
This is useful in init files.î 139 EMACS Manual for ITS Users
Any variable can be made local to a specific buffer with the
TECO command M.L<variable name>$. Thus, if you want the comment
column to be column 50 in one buffer, whereas you usually like
40, then in the one buffer do M.LComment Column$ using the
minibuffer. Then, you can do 50U$Comment Column$ in that buffer
and other buffers will not be affected. This is how local modes
lists in files work. M-X List Redefinitions describes the local
variables of the selected buffer in a verbose fashion.
Most local variables are killed if you change major modes.
____î Their global values come back. They are therefore called mode
______ _________î locals. There are also permanent locals which are not killed by
changing modes; use 2,M.L to create one. Permanent locals are
used by things like Auto Save mode to keep internal information
about the buffer, whereas mode locals are used for customizations
intended only for one buffer. See the file INFO;CONV, node
Variables, for information on how local variables work, and
additional related features.
Local values of variables can be specified by the file being
edited. For example, if a certain file ought to have a 50 column
width, it can specify a value of 50 for the variable Fill Column.
Then Fill Column will have the value 50 whenever this file is
edited, by anyone. Editing other files is not affected. See
section 22.7 [Locals], page 150, for how to do this.
22.4 The Syntax Tableî 22.4 The Syntax Tableî 22.4 The Syntax Table
All the EMACS commands which parse words or balance parentheses
______ _____î are controlled by the syntax table. Each ASCII character has a
word syntax and a Lisp syntax. By changing the word syntax, you
can control whether a character is considered a word delimiter or
part of a word. By changing the Lisp syntax, you can control
which characters are parentheses, which ones are parts of
symbols, which ones are prefix operators, and which ones are just
ignored when parsing s-expressions.
The syntax table is actually a string which is 128*5 characters
long. Each group of 5 consecutive characters of the syntax table
describe one ASCII character's syntax; but only the first three
of each group are used. To edit the syntax table, use M-X Edit
Syntax Table. But before we describe this command, let's talk
about the syntax of the syntax table itself.
The first character in each group of five sets the word syntax.
This can be either "A" or a space. "A" signifies an alphabetic
character, whereas a space signifies a separator character.î 140 EMACS Manual for ITS Users
The second character in each group is the Lisp syntax. It has
many possible values:
A an alphabetic character
Space a whitespace or nonsignificant character
( an open parenthesis
) a close parenthesis
; a comment starter
^î |M a comment ender
| a string quote
/ a character quote
' a prefix character
When a character has the syntax of an open parenthesis, that
means that the character is taken to be the beginning of a
parenthesized grouping when expressions are being parsed. Thus,
any number of different expression-starting characters can be
handled.
The syntax of "prefix character" means that the character
becomes part of whatever object follows it, whether symbol or
list, and can also be in the middle of a symbol, but does not
constitute anything by itself if surrounded by whitespace.
A character quote character causes itself and the next
character to be treated as alphabetic.
A string quote is one which matches in pairs. All characters
inside a pair of string quotes are treated as alphabetic except
for the character quote, which retains its significance, and can
be used to force a string quote or character quote into a string.
A comment starter is taken to start a comment, which ends at
the next comment ender, suppressing the normal syntax of all
characters between. Only the indentation commands give special
treatment to these two syntax codes; all other commands consider
them the same as Space (nonsignificant character). The commands
specifically for comments use the variables Comment Start,
Comment Begin, and Comment End to detect comments. This is so
that the comment delimiters can be multi-character strings.
The third character in each group controls automatic
parenthesis matching display. It is defined only for characters
which have the Lisp syntax of close parentheses, and for them it
should contain the appropriate matching open parenthesis
character (or a space). If you insert a close parenthesis
character which is matched by the wrong kind of open parenthesisî 141 EMACS Manual for ITS Users
character, it rings the bell. If the third syntax table
character of a close parenthesis is a space, any open parenthesis
is allowed to match it.
The fourth and fifth characters in each group should always be
spaces, for now. They are not used. The reason they exist is so
that word-wise indexing can be used on the PDP-10 to access the
syntax of a character given in an accumulator.
Edit Syntax Table displays the syntax table broken up into
labeled five-character groups. You can see easily what the
syntax of any character is. You are not editing the table
immediately, however. Instead, you are asked for the character
whose syntax you wish to edit. After typing it, you are
positioned at that character's five-character group. Overwrite
mode is on, so you can simply type the desired syntax entries,
which replace the old ones. You can also do arbitrary editing,
but be careful not to change the position of anything in the
buffer. When you exit the recursive editing level, you are asked
for another character to position to. An Altmode at this point
exits and makes the changes. A C-] at any time aborts the
operation.
Many major modes alter the syntax table. Each such major mode
creates its own syntax table once and reselects the same string
whenever the mode is selected, in any buffer. Thus, all buffers
in Text mode at any time use the same syntax table. This is
important because if you ever change the syntax table of one
buffer that is in Text mode, you change them all. It is possible
to give one buffer a local copy with a TECO program:
MM Make Local Q-Register$..D$W :G..DU..D
The syntax tables belonging to the major modes are not
preinitialized in EMACS; they are created when the major mode is
invoked for the first time, by copying the default one and making
specific changes. Thus, any other changes you have made in the
default (Fundamental mode) syntax table at the beginning
propagate into all modes' syntax tables unless those modes
specifically override them.
After a major mode has created its own syntax table, that table
is stored in the variable <modename> ..D. This makes a different
variable for each major mode, since the mode name is part of the
variable name. Further use of the major mode gets the syntax
table from that variable. If you create the variable yourself
before the first use of the major mode, the value you put there
will be used.î 142 EMACS Manual for ITS Users
TECO programs and init files can most easily change the syntax
table with the function & Alter ..D (look at its documentation).
The syntax table is kept in the q-register named ..D, which
explains that name.
22.5 FS Flagsî 22.5 FS Flagsî 22.5 FS Flags
FS flags are variables defined and implemented by TECO below
the level of EMACS. Some of them are options which control the
behavior of parts of TECO such as the display processor. Some of
them control the execution of TECO programs; you are not likely
to want to change these. Others simply report information from
inside TECO. The list of FS flags is fixed when TECO is
assembled and each one exists for a specific purpose.
FS flags are used mostly by the TECO programmer, but some of
them are of interest to the EMACS user doing minor customization.
For example, FS ECHO LINES$ is the number of lines in the echo
area. By setting this flag you can make the echo area bigger or
smaller. Many FS flags useful for customization are controlled
by EMACS variables; instead of setting the FS flag, you can set
the EMACS variable like any other. Setting the variable
automatically sets the FS flag as well. Here is a list of such
variables which control flags:
Auto Save Interval FS ^R MDLY$
Bottom Display Margin FS %BOTTOM$
Case Search FS BOTHCASE$
Cursor Centering Point FS %CENTER$
Display Mode Line Inverse FS INVMOD$
Display Overprinting FS ^H PRINT$ and FS ^M PRINT$
Echo Area Height FS ECHO LINES$
End of Buffer Display Margin FS %END$
Error Messages in Echo Area FS ECHO ERRORS$
Fill Column FS ADLINE$
Overwrite Mode FS ^R REPLACE$
SAIL Character Mode FS SAIL$
Top Display Margin FS %TOP$
Setting one of these variables causes the flag to be set, but not
vice versa. To avoid confusion, always set these flags using the
associated variables, never directly, unless you are changingî 143 EMACS Manual for ITS Users
them temporarily during one command and the user will not have
the opportunity to notice the confusion.
To get the value of an FS flag, use the TECO command FS
followed by the name of the flag, terminated by an Altmode.
Spaces in the name of the flag are completely ignored, and case
does not matter. Thus, FS Tab Width$= executed in the minibuffer
prints the number of columns between tab stops used for display
of tab characters. See section 23 [Minibuffer], page 156. This
works only for flags with numeric values. The easiest way to
examine a flag's value with EMACS commands is
C-M-X View Variable<cr> (FS Tab Width$)<cr>
This works for both numeric and string values.
To set the flag, give the FS command a numeric argument (which
must be a string pointer, if the intended value is a string).
For example, in the minibuffer or an init file, do
10FS Tab Width$
Be warned that FS always returns a value, so put a CRLF after it
to discard the value if necessary.
It is possible to make an FS flag's value local to a buffer.
See the file INFO;CONV, node Vars.
The documentation of individual FS flags can be found through
Help T. Help T FS Echo Lines<cr> prints the description of FS
ECHO LINES$. Spaces are not significant in Help T either. A
list of just the names of all FS flags is printed by the function
List TECO FS Flags, found in the library PURIFY.
22.6 Init Files and EVARS Filesî 22.6 Init Files and EVARS Filesî 22.6 Init Files and EVARS Files
EMACS is designed to be customizable; each user can rearrange
things to suit his taste. Simple customizations are primarily of
two types: moving functions from one character to another, and
setting variables which functions refer to so as to direct their
actions. Beyond this, extensions can involve redefining existing
functions, or writing entirely new functions and creating
sharable libraries of them.î 144 EMACS Manual for ITS Users
The most general way to customize is to write an init file, a
TECO program which is executed whenever you start EMACS. The
init file is found by looking for a particular filename, <home
directory>;<user name> EMACS. This method is general because the
program can do anything. It can ask you questions and do things,
rather than just setting up commands for later. However, TECO
code is arcane, and only a few people learn how to write it. If
you need an init file and don't feel up to learning to write TECO
code, ask a local expert to do it for you. See the file INFO;
CONV, for more about init files.
However, simple customizations can be done in a simple way with
an EVARS file. Such a file serves the same sort of purpose as an
init file, but instead of TECO code, it contains just a list of
variables and values. Each line of the EVARS file names one
variable or one command character and says how to redefine it.
Empty lines, and lines starting with spaces or tabs, are ignored.
They can be used as comments. Your EVARS file is found by its
filename, as an init file is, but it should be called <home
directory>;<user name> EVARS instead of EMACS. You can have both
an init file and an EVARS file if you want, as long as your init
file calls the default init file, since that is what processes
the EVARS file.
To set a variable, include in the EVARS file a line containing
the name of the variable, a colon, and the value. A numeric
value is represented by the number. A string value is enclosed
^î in double quotes. To include a double quote or a |] character in
^î the value of the string, precede it with a |] to quote it. You
can also simply give the string value, with no quotes, as long as
it is not ambiguous (does not consist of digits or start with a
double quote); however, in this case, any spaces following the
colon become part of the value of the variable. They are not
ignored. Examples:
Comment Column: 70
Comment Start: ";"
MM Foo:FTFOO$
The last line defines a variable named MM Foo, which has the
effect of defining a function named Foo with the specified value
as its definition.
To redefine a command character is a little more complicated.
^î Instead of the name of a variable, give a |R (control-R) followed
by the character. Since the general Control and Meta character
cannot be part of a file, all Control and Meta characters areî 145 EMACS Manual for ITS Users
^î represented in a funny way: after the |R put the residue of the
^î character after removing the Control and Meta, and before the |R
put periods, one for Control, two for Meta, and three for
^î Control-Meta. Thus, C-D is represented by ".|RD" and C-M-; is
^î represented by "...|R;". Lower case characters such as C-a are
usually defined as "execute the definition of the upper case
equivalent". Therefore, by redefining the C-A command you also
^î change C-a; but if you redefine C-a, by saying ".|Ra" instead of
^î ".|RA", you will not change C-A. So be careful about case.
Instead of the value of a variable, for command character
redefinition you must give a TECO expression that returns the
desired definition. This is to make it easy to use any function
whose name you know, because M.MFOO$ is an expression that
returns the definition of the function FOO. Do not enclose the
TECO expression in quotes. Example:
^î .|RK: M.M^R Kill Line$
would give C-K the definition that it normally has. Remember
that in names of functions the "^R" is actually a "^" and an R,
not a control-R. The space before the M.M is part of the
expression, but it is ignored when the expression is executed.
Some non-printing characters are a little tricky to redefine.
For example, you must know that Return, Linefeed, Tab, Backspace
and Altmode are not the same in TECO's command character set as
C-M, C-J, C-I, C-H and C-[, even though in ASCII they are
^ ^î synonymous. By saying .|RJ you will redefine C-J; by saying |R
followed by a Linefeed (which you must insert in the EVARS file
by typing C-Q Linefeed) you can redefine Linefeed. Normally, C-J
is defined as "execute the definition of Linefeed", so you are
better off redefining Linefeed.
You can also redefine a subcommand of a prefix character such
as C-X. For this, you have to know where the character's
dispatch table is stored. For C-X, the location of the dispatch
is called ".X"; you won't have any other prefix characters unless
you define them yourself. See the file INFO;CONV, node Prefix.
Knowing the location, you specify the subcommand by writing
^î :location(|^character). This looks silly, but it is a TECO
expression with the right meaning. For example, redefining C-X
^î C-S, the location is ".X" and the character is |S, so we say
^ ^î :.X(|^|S): M.M^R Save File$î 146 EMACS Manual for ITS Users
This gives C-X C-S the definition that it normally has. The
^î subcommand character (|S in this case) can represent itself in
the EVARS file with no need for dots, because subcommand
characters are just ASCII, with no Meta allowed.
You can include arbitrary TECO code in an EVARS file by writing
a definition for "*". The definition is executed as a TECO
expression but the value is ignored. Thus, to load the library
FOO, do
*: MM Load Library$FOO$
Once the library is loaded, you can connect the functions in it
to commands as described above.
Please refrain from giving newcomers to EMACS a copy of your
own init file before they understand what it does. Everyone
prefers his own customizations, and there is always a tendency to
proselytize, but by the same token your protege's tastes may be
different from yours. If you offer him your customizations at
the time when he is ready to understand what difference they make
and decide for himself what he prefers, then you will help him
get what he wants. Tell him about each individual change you
made, and let him judge them one by one. There is no reason for
him to choose all or nothing.
22.6.1 EVARS File Examplesî 22.6.1 EVARS File Examplesî 22.6.1 EVARS File Examples
Here are some examples of how to do various useful things in an
EVARS file.
This causes new buffers to be created in Lisp mode:
Default Major Mode: "LISP"
This causes new buffers to have Auto Fill mode turned on:
Buffer Creation Hook: "1M.L Auto Fill Mode$"
This causes all Text mode buffers to have Auto Fill mode turned
on: î 147 EMACS Manual for ITS Users
Text Mode Hook: "1M.L Auto Fill Mode$"
This causes C-M-G to be undefined by copying the definition of
C-| (which is undefined):
^ ^î ...|RG: Q.|R|
This redefines C-S to be a single character search command, and
M-S to be a non-incremental string search:
^î .|RS: M.M ^R Character Search$
^î ..|RS: M.M ^R String Search$
This redefines C-X V to run View File:
^î :.X(|^V): M.M View File$
This makes M-M a prefix character and defines M-M W to mark a
word and M-M P to mark a paragraph. It stores the dispatch
vector for the prefix character in the variable M-M Dispatch.
^ ^ ^î ..|RM: MM Make Prefix Character$|]$M-M Dispatch|]$$
Temp: "M-M $M-M Dispatch$
"
Append the line in Temp to Prefix Char List.
^ ^î *: Q$Prefix Char List$[1 Q$Temp$[2 :i$Prefix Char List$|]1|]2$
^î :$M-M Dispatch$(|^W): M.M ^R Mark Word$
^î :$M-M Dispatch$(|^P): M.M ^R Mark Paragraph$
This loads the library LUNAR and defines C-Q to run a useful
function found in that library:
*: MM Load Library$LUNAR$
^î .|RQ: M.M ^R Various Quantities$
This causes Auto Save mode to save under the visited filenames:
î 148 EMACS Manual for ITS Users
Auto Save Visited File: 1
This causes TAGS to bring new files into separate buffers:
TAGS Find File: 1
This prevents the default init file from printing the message
"EMACS version nnn. Type ... for Help".
Inhibit Help Message: 1
This redefines the list syntax of "%" to be ";" for "comment
starter", and that of ";" to be "A" for "alphabetic":
*: 1mm& Alter ..D$%;;A$
22.6.2 Init File Examplesî 22.6.2 Init File Examplesî 22.6.2 Init File Examples
Here are the ways to do exactly the same things in an init
file. Don't put more than one of these TECO expressions on a
line, or the first may leave behind a value which will affect the
operation of the second!
This causes new buffers to be created in Lisp mode:
:I$Default Major Mode$LISP$
This causes new buffers to have Auto Fill mode turned on:
^î :I* 1M.L Auto Fill Mode|]$ $ M.VBuffer Creation Hook$
It is different because the variable does not already exist.
^î Note the |] used for getting the Altmode into the value.
This causes all Text mode buffers to have Auto Fill mode turned
on: î 149 EMACS Manual for ITS Users
^î :I* 1M.L Auto Fill Mode|]$ $ M.VText Mode Hook$
This causes C-M-G to be undefined by copying the definition of
C-| (which is undefined):
^ ^î Q.|R| U...|RG
This redefines C-S to be a single character search command, and
M-S to be a non-incremental string search:
^î M.M ^R Character Search$ U.|RS
^î M.M ^R String Search$ U..|RS
This redefines C-X V to run View File:
^î M.M View File$ U:.X(|^V)
This makes M-M a prefix character and defines M-M W to mark a
word and M-M P to mark a paragraph. It stores the dispatch
vector for the prefix character in the variable M-M Dispatch.
^î MM Make Prefix Character$.Y$U..|RM
Q$Prefix Char List$[1
^ ^ ^î :i$Prefix Char List$|]1M-M |]$M-M Dispatch|]$
$ ]1
^î M.M ^R Mark Word$ U:$M-M Dispatch$(|^W)
^î M.M ^R Mark Paragraph$ U:$M-M Dispatch$(|^P)
This loads the library LUNAR and defines C-Q to run a useful
function found in that library:
MM Load Library$LUNAR$
^î M.M ^R Various Quantities$ U.|RQ
This causes Auto Save mode to save under the visited filenames:
î 150 EMACS Manual for ITS Users
1U$Auto Save Visited File$
Compare this and the next example with the first two, in which
string values are used.
This causes TAGS to bring new files into separate buffers:
1M.VTAGS Find File$
This prevents the default init file from printing the message
"EMACS version nnn. Type ... for Help".
1M.VInhibit Help Message$
This redefines the list syntax of "%" to be ";" for "comment
starter", and that of ";" to be "A" for "alphabetic":
1mm& Alter ..D$%;;A$
22.7 Local Variables in Filesî 22.7 Local Variables in Filesî 22.7 Local Variables in Files
_____ _____î By specifying local modes in a file you can cause certain major
or minor modes to be set, or certain character commands to be
defined, whenever you are visiting it. For example, EMACS can
select Lisp mode for that file, set up a special Comment Column,
or put a special command on the character C-M-Comma. Local modes
can specify the major mode, and the values of any set of named
variables and command characters. Local modes apply only while
the buffer containing the file is selected; they do not extend to
other files loaded into other buffers.
The simplest kind of local mode specification sets only the
major mode. You put the mode's name in between a pair of
"-*-"'s, anywhere on the first nonblank line of the file. For
example, the first line of this file contains -*-Scribe-*-,
implying that this file should be edited in Scribe mode.
_____î To specify more that just the major mode, you must use a local
_____ ____ ____î modes list, which goes in the last page of the file (it is best
to put it on a separate page). The local modes list starts withî 151 EMACS Manual for ITS Users
a line containing the string "Local Modes:", and ends with a line
containing the string "End:". In between come the variable names
and values, just as in an EVARS file. See section 22.6 [EVARS
files], page 143.
The line which starts the local modes list does not have to say
just "Local Modes:". If there is other text before "Local
______î Modes:", that text is called the prefix, and if there is other
______î text after, that is called the suffix. If these are present,
each entry in the local modes list should have the prefix before
it and the suffix after it. This includes the "End:" line. The
prefix and suffix are included to disguise the local modes list
as a comment so that the compiler or text formatter will not be
perplexed by it. If you do not need to disguise the local modes
list as a comment in this way, do not bother with a prefix or a
suffix.
Aside from the "Local Modes:" and the "End:", and the prefix
and suffix if any, a local modes list looks like an EVARS file.
However, comments lines are not allowed, and you cannot redefine
C-X subcommands due to fundamental limitations of the data
structure used to remember local variables. Sorry.
The major mode can be set by specifying a value for the
variable "Mode" (don't try setting the major mode this way except
in a local modes list!). It should be the first thing in the
local modes list, if it appears at all. A function M-X Foo can
be defined locally by putting in a local setting for a variable
named "MM Foo". See section 5.2 [Functions], page 24.
Here is an example of a local modes list:
;;; Local Modes: ***
;;; Mode:Mumble ***
;;; Comment Column:0 ***
;;; Comment Start: ";;; " ***
;;; Comment End:"***" ***
^î ;;; ..|R/: m.m^R My Funny Meta-Slash$ ***
;;; End: ***
Note that the prefix is ";;; " and the suffix is " ***". Note
also that comments in the file begin with ";;; " and end with
"***". Presumably the file contains code in the language Mumble,
in which comments must start and end that way. The prefix and
suffix are used in the local modes list to make the list appear
as comments when the file is read by the Mumble compiler.î 152 EMACS Manual for ITS Users
The last page of the file must be no more than 10000 characters
long or the local modes list will not be recognized. This is
because EMACS finds the local modes list by scanning back only
10000 characters from the end of the file for the last formfeed,
and then looking forward for the "Local Modes:" string. This
accomplishes these goals: a stray "Local Modes:" not in the last
page is not noticed; and visiting a long file that is all one
page and has no local mode list need not take the time to search
the whole file.
22.8 Keyboard Macrosî 22.8 Keyboard Macrosî 22.8 Keyboard Macros
C-X ( Start defining a keyboard macro.
C-X ) End the definition of a keyboard macro.
C-X E Execute the most recent keyboard macro.
C-U C-X ( Re-execute last keyboard macro and append to
its definition.
C-X Q Ask for confirmation when the keyboard macro
is executed.
C-U C-X Q Allow the user to edit for a while, each time
the keyboard macro is executed.
M-X Name Kbd Macro
Make the most recent keyboard macro into the
permanent definition of a command.
M-X Write Kbd Macro
Save a keyboard macro in a file.
________ _____î A keyboard macro is a command defined by the user to abbreviate
a sequence of other commands. If you discover that you are about
to type C-N C-D forty times, you can define a keyboard macro to
do C-N C-D and call it with a repeat count of forty.
Keyboard macros differ from ordinary EMACS commands, in that
they are written in the EMACS command language rather than in
TECO. 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, TECO must be used.
EMACS functions were formerly known as macros (which is part of
the explanation of the name EMACS), because they were macros
within the context of TECO as an editor. We decided to change
the terminology because, when thinking of EMACS, we consider TECO
a programming language rather than an editor. The only "macros"
in EMACS now are keyboard macros.î 153 EMACS Manual for ITS Users
You define a keyboard macro while executing the commands which
are the definition. Put differently, as you are defining 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.
22.8.1 Basic Useî 22.8.1 Basic Useî 22.8.1 Basic Use
To start defining a keyboard macro, type the C-X ( command
(^R Start Kbd Macro). From then on, your commands continue to be
executed, but also become part of the definition of the macro.
"Def" appears in the mode line to remind you of what is going on.
When you are finished, the C-X ) command (^R End Kbd Macro)
terminates the definition (without becoming part of it!).
The macro thus defined can be invoked again with the C-X E
command (^R Execute Kbd Macro), which may be given a repeat count
as a numeric argument to execute the macro many times. 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). So, giving C-X ) an argument of 2
executes the macro immediately one additional time. An argument
of zero to C-X E or C-X ) means repeat the macro indefinitely
(until it gets an error).
If you want to perform an operation on each line, then either
you should start by positioning point on the line above the first
one to be processed and then begin the macro definition with a
C-N, or you should start on the proper line and end with a C-N.
Either way, 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 C-U C-X (.
This is equivalent to plain C-X ( followed by retyping the whole
definition so far. As a consequence it re-executes the macro as
previously defined.
If you wish to save a keyboard macro for longer than until you
define the next one, you must give it a name. If you do M-X Name
Kbd Macro$FOO<cr>, the last keyboard macro defined (the one which
C-X E would invoke) is turned into a function and given the name
FOO. M-X FOO will from then on invoke that particular macro.
Name Kbd Macro also reads a character from the keyboard andî 154 EMACS Manual for ITS Users
redefines that character command to invoke the macro. You can
use a bit prefix character in specifying the command; you can
also type a C-X command to be redefined. When you have finished
typing the command characters, Name Kbd Macro asks you whether it
should go ahead and redefine the character.
To save a keyboard macro permanently, do M-X Write Kbd Macro.
Supply the function name of the keyboard macro as a string
argument, or else it will ask you to type the character which
invokes the keyboard macro. The keyboard macro is saved as a
library which, when loaded, automatically redefines the keyboard
macro. The filename is read from the terminal. Its second name
should be :EJ, like other libraries; that is the default.
To examine the definition of a keyboard macro, use the function
View Kbd Macro. Either supply the name of the function which
runs the macro, as a string argument, or type the command which
invokes the macro when View Kbd Macro asks for it.
22.8.2 Executing Macros with Variationsî 22.8.2 Executing Macros with Variationsî 22.8.2 Executing Macros with Variations
If you want to be allowed to do arbitrary editing at a certain
point each time around the macro (different each time, and not
remembered as part of the macro), you can use the C-U C-X Q
command (^R Kbd Macro Query). When you are defining the macro,
___î this lets you do some editing, which does not become part of the
macro. When you are done, exit with C-M-C to return to defining
the macro. When you execute the macro, at that same point, you
will again be allowed to do some editing. When you exit this
time with C-M-C, the execution of the macro will resume. If you
abort the recursive editing level with C-], you will abort the
macro definition or execution.
You can get the effect of Query Replace, where the macro asks
you each time around whether to make a change, by using the
command C-X Q with no argument in your keyboard macro. When you
are defining the macro, the C-X Q does nothing, but when the
macro is invoked the C-X Q reads a character from the terminal to
decide whether to continue. The special answers are Space,
Rubout, Altmode, C-L, C-R. A Space means to continue. A Rubout
means to skip the remainder of this repetition of the macro,
starting again from the beginning in the next repetition. An
Altmode ends all repetitions of the macro, but only the innermost
macro (in case it was called from another macro). C-L clears the
screen and asks you again for a character to say what to do. C-R
enters a recursive editing level; when you exit, you are asked
again (if you type a Space, the macro will continue from whereverî 155 EMACS Manual for ITS Users
you left things when you exited the C-R). Anything else exits
all levels of keyboard macros and is reread as a command.î 156 EMACS Manual for ITS Users
CHAPTER TWENTY-THREEî CHAPTER TWENTY-THREEî CHAPTER TWENTY-THREE
THE MINIBUFFERî THE MINIBUFFERî THE MINIBUFFER
__________î The minibuffer is a facility by means of which EMACS commands
can read input from the terminal, allowing you to use EMACS
commands to edit the input while you are typing it. Usually it
is used to read a TECO program to be executed.
M-Altmode Invokes an empty minibuffer.
M-% Invokes a minibuffer initialized with a Query
Replace.
C-X Altmode Re-execute a recent minibuffer command.
C-X ^ Add more lines to the minibuffer.
C-\ Meta-prefix for use in the minibuffer.
C-C C-Y Rotate ring of recent minibuffer commands.
The primary use of the minibuffer is for editing and executing
simple TECO programs such as
MM Query Replace$FOO
$BAR
$
(which could not be done with M-X Query Replace because when M-X
is used Return terminates the arguments).
You can always tell when you are in a minibuffer, because the
mode line contains something in parentheses, such as
"(Minibuffer)" or "(Query Replace)". There is also a line of
dashes across the screen a few lines from the top. Strictly
speaking, the minibuffer is actually the region of screen above
the line of dashes, for that is where you edit the input that the
minibuffer is asking you for. Editing has been limited to a few
lines so that most of the screen can continue to show the file
you are visiting.
If you want to type in a TECO command, use the minibuffer with
the command Meta-Altmode, (^R Execute Minibuffer). An empty
minibuffer will appear, into which you should type the TECO
command string. Exit with Altmode Altmode, and remember that
neither of the two Altmodes is inserted into your TECO command
although the first one may appear to be. When the TECO command
is executed, "the buffer" will be the text you were editing
before you invoked the minibuffer.î 157 EMACS Manual for ITS Users
Often, a minibuffer starts out with some text in it. This
means that you are supposed to add to that text, or, sometimes,
to delete some of it so as to choose among several alternatives.
For example, Meta-% (^R Query Replace) provides you with a
minibuffer initially containing the string "MM Query Replace$".
The cursor comes at the end. You are then supposed to add in the
arguments to the Query Replace.
In a minibuffer, you can edit your input until you are
satisfied with it. Then you tell EMACS you are finished by
typing two Altmodes. An Altmode not followed by another Altmode
is simply inserted in the buffer. This is because it is common
to want to put Altmodes into the minibuffer, which usually
contains a string of TECO commands. For example, in Meta-%
(^R Query Replace) each argument must be ended by an Altmode.
However, when you type two Altmodes in a row, neither one remains
in the buffer. The two Altmodes do nothing to the text in the
minibuffer, they just exit.
Since Altmode is self-inserting, typing Meta characters can be
a problem. You can do it by using C-\ instead of Altmode as the
Meta-prefix. If you type a Control-Meta character on your
keyboard, the corresponding ASCII control character is inserted
in the minibuffer. This is because the Lisp commands are rarely
useful when editing TECO code, but insertion of control
characters is frequent. If you really want to use a Control-Meta
EMACS command, you must use C-C to type it. You cannot use C-\
C-A to type C-M-A, because C-\ (unlike Altmode) ignores the
Control bit of the following character, so you must use C-C C-A.
The motivation for this quirk of C-\ is that C-\ C-B (to obtain
M-B) is easier to type than C-\ B, especially if it is typed
several times in a row.
You can cancel your input in a minibuffer and start all over
again by typing C-G. That kills all the text in the minibuffer.
A C-G typed when the minibuffer is already empty exits from the
minibuffer. Usually, this aborts whatever command was using the
minibuffer, so it will return without doing anything more. For
example, if you type two C-G's at Meta-%'s minibuffer, you will
return to top level and no Query Replace will be done. Typing a
single C-G at a preinitialized minibuffer to empty the buffer is
not very useful, since you would have to retype all the initial
text.
The last five distinct minibuffer commands or M-X commands you
have issued are remembered in a ring buffer in q-register .M.
The C-X Altmode command (^R Re-execute Minibuffer) re-executes
the last command in the ring. With an argument <n>, it
re-executes the <n>'th previous command. The command is printedî 158 EMACS Manual for ITS Users
out (only the first 40 characters or so) and you are asked to
confirm with "Y" or "N".
You can also get your previous minibuffer and M-X commands back
into the minibuffer to be edited and re-executed with changes.
Giving M-Altmode an argument, as in C-U M-Altmode, causes the
minibuffer to be loaded up with the last command in the ring, as
if you had typed it in again from scratch. You can then edit it,
execute it by typing two Altmodes, or cancel it with C-G. To get
an earlier command string instead of the most recent one, use the
command C-C C-Y once you are in the minibuffer. This command
"rotates" the ring of saved commands much as M-Y rotates the ring
of killed text. Each C-C C-Y reveals an earlier command string,
until the ring has rotated all the way around and the most recent
one reappears. C-C C-Y is actually a way of saying C-M-Y, but in
the minibuffer that's the only way to type it, since Altmode
inserts itself and Control-Meta characters insert control
characters.
If you exit from Meta-Altmode with a C-G, nothing is executed
and the previous minibuffered command string is still remembered
as the last one.
While in a minibuffer, if you decide you want the minibuffer to
use more lines on the screen, you can use C-X ^ (^R Grow Window)
to get more. It gets one more line, or as many lines as its
argument says.î 159 EMACS Manual for ITS Users
CHAPTER TWENTY-FOURî CHAPTER TWENTY-FOURî CHAPTER TWENTY-FOUR
CORRECTING MISTAKES AND EMACS PROBLEMSî CORRECTING MISTAKES AND EMACS PROBLEMSî CORRECTING MISTAKES AND EMACS PROBLEMS
If you type an EMACS command you did not intend, the results
are often mysterious. This chapter tells what you can do to
cancel your mistake or recover from a mysterious situation.
EMACS bugs and system crashes are also considered.
24.1 Quitting and Abortingî 24.1 Quitting and Abortingî 24.1 Quitting and Aborting
C-G Quit. Cancel running or partially typed command.
C-] Abort recursive editing level and cancel the
command which invoked it.
M-X Top Level
Abort all recursive editing levels and subsystems
which are currently executing.
There are three ways of cancelling commands which are not
________ ________î finished executing: quitting with C-G, and aborting with C-] or
M-X Top Level. Quitting is cancelling a partially typed command
or one which is already running. Aborting is cancelling a
command which has entered a recursive editing level or subsystem.
Quitting with C-G is used for getting rid of a partially typed
command, or a numeric argument that you don't want. It also
stops a running command in the middle in a relatively safe way,
so you can use it if you accidentally give a command which takes
a long time. In particular, it is safe to quit out of killing;
___ ___î either your text will all still be there, or it will all be in
the kill ring (or maybe both). Quitting an incremental search
does special things documented under searching; in general, it
may take two successive C-G's to get out of a search. C-G can
interrupt EMACS at any time, so it is not an ordinary command.
Aborting with C-] (Abort Recursive Edit) is used to get out of
a recursive editing level and cancel the command which invoked
it. Quitting with C-G cannot be used for this, because it is
used to cancel a partially typed command within the recursive
editing level. Both operations are useful. For example, if you
are editing a message to be sent, C-G can be used to cancel the
commands you use to edit the message, and C-] cancels sending the
message. C-] either tells you how to resume the aborted command
or queries for confirmation before aborting.î 160 EMACS Manual for ITS Users
When you are in a position to use M-X, you can use M-X Top
Level. This is equivalent to "enough" C-] commands to get you
out of all the levels of subsystems and recursive edits that you
are in. C-] gets you out one level at a time, but M-X Top Level
goes out all levels at once. Both C-] and M-X Top Level are like
all other commands, and unlike C-G, in that they are effective
only when EMACS is listening.
24.2 Dealing with Common Forms of EMACS Lossageî 24.2 Dealing with Common Forms of EMACS Lossageî 24.2 Dealing with Common Forms of EMACS Lossage
This section describes various conditions which can cause EMACS
not to work, or cause it to display strange things, and how you
can correct them.
24.2.1 Error Messageî 24.2.1 Error Messageî 24.2.1 Error Message
When EMACS prints an error message, it occupies the top line of
the screen, ends with a "?", and is accompanied by the ringing of
the bell. Space causes the error message to disappear and be
replaced by the first line of text again. Any other command is
executed normally as if there had been no error message (the
error message disappears during the redisplay after the command).
However, "?" enters the error handler, which can be used to
inspect the function call stack. Most users will not be
interested in doing this. Type Help inside the error handler to
get its documentation, or C-] to exit it.
If you prefer to have echo messages printed in the echo area,
set the variable Error Messages in Echo Area nonzero.
24.2.2 Subsystems and Recursive Editing Levelsî 24.2.2 Subsystems and Recursive Editing Levelsî 24.2.2 Subsystems and Recursive Editing Levels
Subsystems and recursive editing levels are important and
useful features of EMACS, but they can seem like malfunctions to
the user who does not understand them.
If the mode line starts with a bracket "[" or a parenthesis
"(", or does not start with the word "EMACS", then you have
entered a subsystem (See section 6.1 [Subsystems], page 28.) or a
recursive editing level (See section 6.3 [Recursive Editing
Levels], page 30.).î 161 EMACS Manual for ITS Users
In such a situation, first try typing C-]. This will get out
of any recursive editing level and most subsystems. The usual
mode line and text display will reappear. If C-] does not seem
to have worked, type the Help character. Instead of printing
"Doc (Type ? for Help)" in the echo area, it will print a list of
the subsystem's commands. One of these should be a command to
exit or abort.
If the above techniques fail, try restarting (see section
24.2.7).
24.2.3 Garbage on the Screenî 24.2.3 Garbage on the Screenî 24.2.3 Garbage on the Screen
If the data on the screen looks wrong, it could be due to line
noise on input or output, a bug in the terminal, a bug in EMACS
redisplay, or a bug in an EMACS command. To find out whether
there is really anything wrong with your text, the first thing to
do is type C-L. This is a command to clear the screen and
redisplay it. Often this will display the text you expected.
Think of it as getting an opinion from another doctor.
24.2.4 Garbage Displayed Persistentlyî 24.2.4 Garbage Displayed Persistentlyî 24.2.4 Garbage Displayed Persistently
If EMACS persistently displays garbage on the screen, or if it
outputs the right things but scattered around all the wrong
places on the screen, it may be that EMACS has the wrong idea of
your terminal type. The first thing to do in this case is to
exit from EMACS and restart it. Each time EMACS is restarted it
asks the system what terminal type you are using. Whenever you
detach and move to a terminal of a different type you should
restart EMACS as a matter of course. If you stopped EMACS with
the exit command, or by interrupting it when it was awaiting a
command, then this is sure to be safe.
The system itself may not know what type of terminal you have.
You should try telling the system with the :TCTYP command.
24.2.5 URK Error (Address Space Exhausted)î 24.2.5 URK Error (Address Space Exhausted)î 24.2.5 URK Error (Address Space Exhausted)
If attempting to visit a file or load a library causes an "URK"
error, it means you have filled up the address space; there is no
room inside EMACS for any more files or libraries. In this
situation EMACS will try to run the function Make Space for you.î 162 EMACS Manual for ITS Users
If EMACS is unable to do it for you, you may still be able to do
M-X Make Space yourself. This command compacts the data inside
EMACS to free up some space. It also offers to discard data that
may be occupying a lot of space, such as the kill ring (See
section 9.1 [Killing], page 39.), the undo memory (See
section 24.3 [Undo], page 163.), and buffers created by RMAIL,
TAGS and INFO. Another way of freeing space is to kill buffers
with M-X Kill Some Buffers (See section 14 [Buffers], page 83.)
or unload libraries with M-X Kill Libraries (See section 22.2
[Libraries], page 135.).
Use the command M-X What Available Space to find out how close
you are to running out of space. It tells you how many K of
space you have available for additional files or libraries.
Visiting a file causes an URK error if the file does not fit in
the available virtual memory space, together with the other
buffers and the libraries loaded. A big enough file causes an
URK error all by itself. For editing such large files, use the
command Split File (in the SPLIT library) to break it into
subfiles. These will be fairly large files still, but not too
large to edit. After editing one or more of the subfiles, use
the command Unsplit File (also in SPLIT) to put them back
together again.
24.2.6 All Type-in Echoes and Nothing Else Happensî 24.2.6 All Type-in Echoes and Nothing Else Happensî 24.2.6 All Type-in Echoes and Nothing Else Happens
If you find that EMACS is not responding to your commands
except for echoing them all at the bottom of the screen,
including the Return character, and that Rubout causes erased
characters to be retyped instead of erased, then you have managed
to exit from EMACS back to TECO. Often this follows an "Error in
error handler" message which indicates that a condition arose in
which the error handler could not function. You can get back
into EMACS by typing :M..L$$, or by restarting (see below). If
you ever want to exit back to TECO, you can do M-X Top Level with
an argument greater than zero. Before using :M..L$$, get rid of
any other characters you have typed by mistake by typing a C-G.
24.2.7 EMACS Hung and Not Respondingî 24.2.7 EMACS Hung and Not Respondingî 24.2.7 EMACS Hung and Not Responding
Sometimes EMACS gets hung and C-G does not work. The more
drastic procedure of restarting EMACS may work at such times.
C-G can fail to work because it only takes effect between the
TECO commands which make up an EMACS program, never in the middleî 163 EMACS Manual for ITS Users
of one (only a few TECO commands allow quitting at any time), so
as to prevent TECO's internal data structures from becoming
inconsistent. If EMACS is hung inside a TECO command, C-G is not
noticed, but restarting can still be tried.
To restart EMACS, type CALL or C-Z to stop EMACS, then $G to
restart it. While restarting TECO in this way is usually safe
(especially at times when TECO is doing I/O), there are certain
times at which it will cause the TECO data structures to be
inconsistent, so do not try it unless other measures have failed.
Your ultimate safeguard against a wedged EMACS is to save your
work frequently.
24.3 Undoing Changes to the Bufferî 24.3 Undoing Changes to the Bufferî 24.3 Undoing Changes to the Buffer
If you mistakenly issue commands that make a great change to
the buffer, you can often undo the change without having to know
precisely how it came about. This is done by using M-X Undo.
Type M-X Undo<cr> and the change is undone. It does not matter
if you have moved the cursor since you made the change; it is
undone where it was originally done.
The first thing Undo does is tell you what kind of change it
plans to undo (kill, fill, undo, case-convert, etc). Then it
asks whether to go ahead. If you say "Y", the change is actually
undone.
Not all changes to the buffer can be undone: deletion (as
opposed to killing) can't be, and changes in indentation can't
be, nor can many forms of insertion (but they aren't as important
since they don't destroy information). Also, a Replace String or
Query Replace can't be undone, which is a shame. The reason is
that actually they make many small changes, and Undo only knows
how to remember one contiguous change. Perhaps someday I will be
able to fix this.
As a result, when you say Undo, it may undo something other
than the latest change if the latest change was not undoable.
This might seem to pile one disaster on another, but it doesn't,
______î because you can always Undo the Undo if it didn't help. But you
can avoid even having to do that, if you look at what type of
change Undo says it will undo.
If you want to undo a considerable amount of editing, not just
the last change, the Undo command can't help you, but M-X Revertî 164 EMACS Manual for ITS Users
File (See section 13.2 [Revert], page 72.) might be able to. If
you have been writing a journal file (See section 24.4
[Journals], page 164.), you can replay the journal after deleting
the part that you don't want.
24.4 Journal Filesî 24.4 Journal Filesî 24.4 Journal Files
A journal file is a record of all the commands you type during
an editing session. If you lose editing because of a system
crash, an EMACS bug, or a mistake on your part, and you have made
a journal file, you can replay the journal or part of it to
recover what you lost. Journal files offer an alternative to
auto saving, using less time and disk space if there is no crash,
but requiring more time when you recover from a crash. See
section 13.3 [Auto Save], page 72.
24.4.1 Writing Journal Filesî 24.4.1 Writing Journal Filesî 24.4.1 Writing Journal Files
In order to make a journal file, you must load the JOURNAL
library and then execute M-X Start Journal File$<filename><cr>.
Immediately, most of the current status of EMACS is recorded in
the journal file, and all subsequent commands are recorded as
they are typed. This happens invisibly and silently. The
journal file is made fully up to date on the disk after every
50th character, so the last 50 characters of type in is the most
you can lose.
The default filenames for the journal file are <home
directory>;<user name> JRNL. There is rarely a reason to use any
other name, because you only need one journal file unless you are
running two EMACSes at the same time.
24.4.2 Replaying Journal Filesî 24.4.2 Replaying Journal Filesî 24.4.2 Replaying Journal Files
To replay the journal file, get a fresh EMACS, load JOURNAL,
and do M-X Replay Journal File$<filename><cr>. The filename can
usually be omitted since normally you will have used the defaults
when creating the journal.
After a delay while the files, buffers and libraries are loaded
as they were when the journal file was written, EMACS will begin
replaying the commands in the journal before your very eyes.î 165 EMACS Manual for ITS Users
Unlike keyboard macros, which execute invisibly until they are
finished, journal files display as they are executed. This
allows you to see how far the replay has gone. You can stop the
process at any time by typing C-G. Aside from that, you should
not type anything on the keyboard while the replay is going on.
If the need for a replay is the result of a system crash or
EMACS crash, then you probably want to replay the whole file.
This is what happens naturally. If you are replaying because you
made a great mistake, you probably want to stop the replay before
the mistake. This is when it becomes useful to type C-G to stop
the replay. Alternatively, you can edit the journal file, and
delete everything from the point of the mistake to the end,
before you replay it.
Once the replay is complete, save all your files immediately.
Don't tempt fate!
If you quit with C-G in the middle of a command while writing a
journal file, there is no way to record in the journal file how
much of the command has already been completed. So, when the
journal is replayed, EMACS has to ask you to fill in for it. The
command which was interrupted will be replayed to completion;
then, you are given a recursive editing level in which to restore
the file to the desired state. This happens only if the C-G
originally interrupted an executing command. C-G typed to
discard an argument or partial command while EMACS is waiting for
input can be and is replayed correctly without asking you for
help.
24.4.3 Journal File Formatî 24.4.3 Journal File Formatî 24.4.3 Journal File Format
To edit a journal file, you must know the format. It is
designed to be mostly transparent.
The primary problem which the journal file format has to solve
is how to represent 9-bit command characters in a file which can
contain only 7-bit ASCII characters. (We could have filled the
journal file with 9-bit characters, but then you would not be
able to print it out or edit it). The solution we have used is
to represent each command by two characters in the file.
So, a Control character is represented by a caret ("^")
followed by the basic character, as in "^E" for Control-E. This
was chosen to be mnemonically significant. A Meta character is
represented by "+" followed by the basic character, so that
Meta-[ is represented by "+[". A Control-Meta character isî 166 EMACS Manual for ITS Users
represented by "*" followed by the basic character, as in "*X"
for C-M-X.
A command which is not Control or Meta is represented as a
space followed by the command itself, except that Return is
represented by a CRLF rather than a space and a carriage return.
This prevents the journal file from being one huge line, and
makes insertion of text very recognizable: the text inserted
appears in the journal file alternating with spaces.
The Help character, which is not covered by the scheme as
described so far, is represented by "??".
An asynchronous quit, which is a problem for replaying, is
^î represented by a single character, a |G, while a synchronous
^î quit, which can be replayed reliably, is represented by ":|G".
^î EMACS considers a quit synchronous, and uses ":|G" to record it,
if EMACS was waiting for terminal input when the C-G was typed.
Your commands themselves are not the only information in the
journal file. EMACS records other information which is necessary
in replaying the journal properly. The colon character ":"
indicates a block of such information. Usually the extent of the
block is easily recognizable because its contents do not resemble
the representations of commands described above. A large block
of information starting with a colon appears at the beginning of
every journal file.
Colons are also used to record the precise effects of certain
commands such as C-V whose actions depend on how the text was
displayed on the screen. Since the effects of such commands are
not completely determined by the text, replaying the command
could produce different results, especially if done on a terminal
with a different screen size. The extra information recorded in
the journal makes it possible to replay these commands with
fidelity.
A semicolon in the journal file begins a comment, placed there
for the benefit of a human looking at the journal. The comment
ends at the beginning of the following line.
24.4.4 Warningsî 24.4.4 Warningsî 24.4.4 Warnings
Proper replaying of a journal file requires that all the
surrounding circumstances be unchanged.
In particular, replaying begins by visiting all the files thatî 167 EMACS Manual for ITS Users
were visited when the writing of the journal file began; not the
latest versions of these files, but the versions which were the
latest at the earlier time. If those versions, which may no
longer be the latest, have been deleted, then replaying is
impossible.
If your init file has been changed, the commands when replayed
may not do what they did before.
These are the only things that can interfere with replaying, as
long as you start writing the journal file immediately after
starting EMACS. But as an editing session becomes longer and
files are saved, the journal file contains increasing amounts of
waste in the form of commands whose effects are already safe in
the newer versions of the edited files. Replaying the journal
will replay all these commands wastefully to generate files
identical to those already saved, before coming to the last part
of the session which provides the reason for replaying.
Therefore it becomes very desirable to start a new journal file.
However, many more precautions must be taken to insure proper
replaying of a journal file which is started after EMACS has been
used for a while. These precautions are described here. If you
cannot follow them, you must make a journal checkpoint (see
below).
If any buffer contains text which is not saved in a file at the
time the journal file is started, it is impossible to replay the
journal correctly. This problem cannot possibly be overcome. To
avoid it, M-X Start Journal File offers to save all buffers
before actually starting the journal.
Another problem comes from the kill ring and the other ways in
which EMACS remembers information from previous commands. If any
such information which originated before starting the journal
file is used after starting it, the journal file cannot be
replayed. For example, suppose you fill a paragraph, start a
journal file, and then do M-X Undo? When the journal is
replayed, it will start by doing M-X Undo, but it won't know what
to undo. It is up to you not to do anything that would cause
such a problem. It should not be hard. It would be possible to
eliminate this problem by clearing out all such data structures
when a journal file is started, if users would prefer that.
A more difficult problem comes from customization. If you
change an option or redefine a command, then start a journal
file, the journal file will have no record of the change. It
will not replay correctly unless you remember to make the same
change beforehand. Customizations made in an init file do not
cause a problem because the init file has also been run when theî 168 EMACS Manual for ITS Users
journal file is replayed. Customizations made directly by the
user while the journal file is being written are also no problem
because replaying will make the same changes at the right times.
However, a customization made while a journal file is being
written will be a problem if a new journal file is started.
24.4.5 Journal Checkpointsî 24.4.5 Journal Checkpointsî 24.4.5 Journal Checkpoints
The only cure for the problems of starting a journal in
mid-session is to record the complete state of EMACS at the time
the journal is begun. This is not done normally because it is
slow; however, you can do this if you wish by giving M-X Start
Journal File a numeric argument. This writes the complete state
of EMACS into the file <home directory>;TS ESAVE. To replay the
journal, run ESAVE, the saved checkpoint, instead of EMACS; then
load JOURNAL and do M-X Replay Journal File as described above.
Be sure to delete the checkpoint if you are finished with it,
since it tends to be large. Delete them also when you log out;
it may be possible to have a command file which deletes them
automatically when you log out. Checkpoint files more than a day
old may be deleted by others without notice; but don't leave it
up to them.
24.5 Reporting Bugsî 24.5 Reporting Bugsî 24.5 Reporting Bugs
Sometimes you will encounter a bug in EMACS. To get it fixed,
you must report it. It is your duty to do so; but you must know
when to do so and how if it is to be constructive.
24.5.1 When Is There a Bugî 24.5.1 When Is There a Bugî 24.5.1 When Is There a Bug
If EMACS executes an illegal instruction, or dies with an
operating system error message that indicates a problem in the
program (as opposed to "disk full"), then it is certainly a bug.
If EMACS updates the display in a way that does not correspond
to what is in the buffer, then it is certainly a bug. If a
command seems to do the wrong thing but the problem is gone if
you type C-L, then it is a case of incorrect display updating.
Taking forever to complete a command can be a bug, but you must
make certain that it was really EMACS's fault. Some commandsî 169 EMACS Manual for ITS Users
simply take a long time. Quit or restart EMACS and type Help L
to see whether the keyboard or line noise garbled the input; if
____î the input was such that you know it should have been processed
quickly, report a bug. If you don't know, try to find someone
who does know.
If a command you are familiar with causes an EMACS error
message in a case where its usual definition ought to be
reasonable, it is probably a bug.
If a command does the wrong thing, that is a bug. But be sure
you know for certain what it ought to have done. If you aren't
familiar with the command, or don't know for certain how the
command is supposed to work, then it might actually be working
right. Rather than jumping to conclusions, show the problem to
someone who knows for certain.
Finally, a command's intended definition may not be best for
editing with. This is a very important sort of problem, but it
is also a matter of judgement. Also, it is easy to come to such
a conclusion out of ignorance of some of the existing features.
It is probably best not to complain about such a problem until
you have checked the documentation in the usual ways (INFO and
Help), feel confident that you understand it, and know for
certain that what you want is not available. If you feel
confused about the documentation instead, then you don't have
grounds for an opinion about whether the command's definition is
optimal. Make sure you read it through and check the index or
the menus for all references to subjects you don't fully
understand. If you have done this diligently and are still
confused, or if you finally understand but think you could have
said it better, then you have a constructive complaint to make
about the documentation. It is just as important to report
documentation bugs as program bugs.
24.5.2 How to Report a Bugî 24.5.2 How to Report a Bugî 24.5.2 How to Report a Bug
When you decide that there is a bug, it is important to report
it and to report it in a way which is useful. What is most
useful is an exact description of what commands you type,
starting with a fresh EMACS just loaded, until the problem
happens. Send the bug report to BUG-EMACS@MIT-AI.
The most important principle in reporting a bug is to report
_____î facts, not hypotheses or conditions. It is always easier to
report the facts, but people seem to prefer to strain to think up
explanations and report them instead. If the explanations areî 170 EMACS Manual for ITS Users
based on guesses about how EMACS is implemented, they will be
useless; we will have to try to figure out what the facts must
have been to lead to such speculations. Sometimes this is
impossible. But in any case, it is unnecessary work for us.
For example, suppose that you type C-X C-V GLORP;BAZ UGH<cr>,
visiting a file which (you know) happens to be rather large, and
EMACS prints out "I feel pretty today". The best way to report
the bug is with a sentence like the preceding one, because it
gives all the facts and nothing but the facts.
Do not assume that the problem is due to the size of the file
and say "When I visit a large file, EMACS prints out 'I feel
pretty today'". This is what we mean by "guessing explanations".
The problem is just as likely to be due to the fact that there is
a "Z" in the filename. If this is so, then when we got your
report, we would try out the problem with some "big file",
probably with no "Z" in its name, and not find anything wrong.
There is no way in the world that we could guess that we should
try visiting a file with a "Z" in its name.
Alternatively, the problem might be due to the fact that the
file starts with exactly 25 spaces. For this reason, you should
make sure that you don't change the file until we have looked at
it. Suppose the problem only occurs when you have typed the C-X
C-A command previously? This is why we ask you to give the exact
sequence of characters you typed since loading the EMACS.
You should not even say "visit the file ..." instead of "C-X
C-V" unless you know that it makes no difference which visiting
command is used. Similarly, rather than saying "if I have three
characters on the line", say "after I type <cr> A B C <cr> C-P",
if that is the way you entered the text. A journal file
containing the commands you typed to reproduce the bug is a very
good form of report.
If you are not in Fundamental mode when the problem occurs, you
should say what mode you are in.
Be sure to say what version of EMACS and TECO are running. If
you don't know, type Meta-Altmode Q$EMACS Version$= FS Version$=
$$ and EMACS will print them out. (This is a use of the
minibuffer. See section 23 [Minibuffer], page 156.)
If the bug occurred in a customized EMACS, or with several
optional libraries loaded, it is helpful to try to reproduce the
bug in a more standard EMACS with fewer libraries loaded. It is
best if you can make the problem happen in a completely standard
___î EMACS with no optional libraries. If the problem does not occurî 171 EMACS Manual for ITS Users
in a standard EMACS, it is very important to report that fact,
because otherwise we will try to debug it in a standard EMACS,
not find the problem, and give up. If the problem does depend on
an init file, then you should make sure it is not a bug in the
init file by complaining to the person who wrote the file, first.
He should check over his code, and verify the definitions of the
TECO commands he is using by looking in INFO;TECORD >. Then if
he verifies that the bug is in EMACS he should report it. We
cannot be responsible for maintaining users' init files; we might
not even be able to tell what they are supposed to do.
If you can tell us a way to cause the problem without reading
in any files, please do so. This makes it much easier to debug.
If you do need files, make sure you arrange for us to see their
exact contents. For example, it can often matter whether there
are spaces at the ends of lines, or a line separator after the
last line in the buffer (nothing ought to care whether the last
line is terminated, but tell that to the bugs).
If EMACS gets an operating system error message, such as for an
illegal instruction, then you can probably recover by restarting
it. But before doing so, you should make a dump file. If you
restart or continue the EMACS before making the dump, the trail
will be covered and it will probably be too late to find out what
happened. Use the DDT command
:PDUMP CRASH;EMACS <yourname>
(or use any other suitable filename) to do this. Your bug report
should contain the filename you used for the dump, and the error
message printed when the EMACS stopped, as well as the events
leading up to the bug. The first number in the error message is
the PC, which is not recorded by :PDUMP, so it must be copied
precisely. Also type .JPC/ and include DDT's response in your
report.
A dump is also useful if EMACS gets into a wedged state in
which commands that usually work do strange things.î 172 EMACS Manual for ITS Users
CHAPTER TWENTY-FIVEî CHAPTER TWENTY-FIVEî CHAPTER TWENTY-FIVE
WORD ABBREVIATION INPUTî WORD ABBREVIATION INPUTî WORD ABBREVIATION INPUT
Word Abbrev mode allows you to abbreviate text with a single
"word", with EMACS expanding the abbreviation automatically as
soon as you have finished the abbreviation.
Abbrevs are also useful for correcting commonly misspelled or
mistyped words ("thier" could expand to "their"), and for
uppercasing words like "EMACS" (abbrev "emacs" could expand to
"EMACS").
To use this mode, just do M-X Word Abbrev Mode<cr>. (Another
M-X Word Abbrev Mode<cr> will turn the mode off; it toggles.)
For example, in writing this documentation we could have
defined "wam" to be an abbreviation for "word abbrev mode".
After typing just the letters "wam", we see just that, "wam", but
if we then finish the word by typing space or period or any other
punctuation, the "wam" is replaced by (and redisplays as) "word
abbrev mode". If we capitalize the abbrev, "Wam", the expansion
is capitalized: "Word abbrev mode". If we capitalize the whole
abbrev, WAM", each word in the expansion is capitalized: "Word
Abbrev Mode". In this particular example, though, we would
define "wam" to expand to "Word Abbrev mode" since it is always
to be capitalized that way.
Thus, typing "I am in wam now" produces "I am in Word Abbrev
mode now".
Word Abbrev mode does not interfere with the use of major
modes, such as Text, Lisp, TECO, PL1, or minor modes, such as
Auto Fill. Those modes (or the user) may redefine what functions
are connected to characters; this does not hamper Word Abbrev
mode.
There are two kinds of word abbreviations: mode and global. A
mode word abbrev applies only in one major mode (for instance
only in Text mode), while a global word abbrev applies regardless
of major mode. If some abbrev is defined both as a mode word
abbrev for the current mode and as a global word abbrev, the mode
word abbrev expansion takes precedence.
For instance, you might want an abbrev "foo" for "find outer
otter" in Text mode, an abbrev "foo" for
"FINAGLE-OPPOSING-OPINIONS" in Lisp, and an abbrev "foo" for
"meta-syntactic variable" in any other mode (the global word
abbrev).î 173 EMACS Manual for ITS Users
Word abbrevs can be defined one at a time (adding them as you
think of them), or many at a time (from a definition list). You
can save them in a file and read them back later. If you turn
off Word Abbrev mode, abbrevs stop expanding automatically, but
their definitions are remembered in case you turn Word Abbrev
mode back on.
25.1 Basic Usageî 25.1 Basic Usageî 25.1 Basic Usage
C-X C-A Define a mode abbrev for some text before
point.
C-X + Define a global abbrev for some text before
point.
C-X C-H Define expansion for mode abbrev before
point.
C-X - Define expansion for global abbrev before
point.
C-M-Space Expand abbrev without inserting anything.
M-' Mark a prefix to be glued to an abbrev
following.
C-X U Unexpand the last abbrev, or undo a C-X U.
M-X List Word Abbrevs<cr>
Shows definitions of all abbrevs.
M-X Edit Word Abbrevs<cr>
Lets you edit the definition list directly.
M-X Read Word Abbrev File$<filename><cr>
Defines word abbrevs from a definition file.
M-X Write Word Abbrev File$<filename><cr>
Makes a definition file from current abbrev
definitions.
Readable Word Abbrev Files
Option variable to control abbrev file format.
This section describes the most common use of Word Abbrev mode.
If you don't read any more than this, you can still use Word
Abbrev mode quite effectively.
Note that each of the above commands will also work when Word
Abbrev mode is turned off, unlike the automatic expanders (suchî 174 EMACS Manual for ITS Users
as Space or Period), allowing you to manually define and expand
abbrevs. (If you want to do this, you might also see the M-X
Expand Word Abbrevs in Region command's self-documentation.)
25.1.1 Adding Word Abbrevsî 25.1.1 Adding Word Abbrevsî 25.1.1 Adding Word Abbrevs
C-X C-A (^R Add Mode Word Abbrev) defines a mode abbrev for the
word before point (this does not include any punctuation between
that word and point, though). It prints the word before point in
the echo area and asks you for that word's abbreviation. Type
the abbrev (which you may edit with Rubout and C-U) followed by a
Return. The abbrev must be a "word": it must contain only
letters and digits; the case of the letters is irrelevant. If
you'd rather define a global abbrev, use C-X + (^R Add Global
Word Abbrev), which works similarly.
You can redefine an abbrev with C-X C-A or C-X +. If the
abbrev already has a definition, it tells you what that was, and
asks for confirmation.
To define an abbrev for more than one word of text, give C-X
C-A or C-X + a numeric argument: an argument greater than 0
means the expansion is that many words before point; an argument
of 0 means to use the region (between point and mark). (By using
the region specification you can make an abbrev for any text, not
just a sequence of words.) The message in the echo area provides
you with confirmation of just what the expansion will be; you
might see:
Text Abbrev for "this is the expansion":
Sometimes you may think you already had an abbrev for some
text, use it, and see that it didn't expand. In this case, the
C-X C-H (^R Inverse Add Mode Word Abbrev) or C-X - (^R Inverse
Add Global Word Abbrev) commands are helpful: they ask you to
_________î type in an expansion rather than an abbrev. In addition to
defining the abbrev, they also expand it. If you give them a
numeric argument, n, they use the nth word before point as the
abbrev.
You can kill abbrevs (cause them to no longer expand) by giving
a negative numeric argument to C-X C-A or C-X +. For instance,
to kill the global abbrev "foo" type C-U - C-X + foo<cr>.î 175 EMACS Manual for ITS Users
25.1.2 Controlling Abbrev Expansionî 25.1.2 Controlling Abbrev Expansionî 25.1.2 Controlling Abbrev Expansion
When an abbrev expands, the capitalization of the expansion is
determined by the capitalization of the abbrev: If the abbrev is
all lowercase, the expansion is as defined. If the abbrev's
first letter is uppercase, the expansion's first letter is too.
If the abbrev is all uppercase, there are two possibilities: if
the expansion is a single word, it is all-uppercased; otherwise,
each of its words has its first letter uppercased (such as for
use in a title). (If you don't like this distinction between
single-word and multi-word expansions, set the variable WORDAB
All Caps to 1. Then an all-uppercase abbrev will always result
in an all-uppercase expansion.)
Abbrevs normally expand when you type some punctuation
character; the abbrev expands and the punctuation character is
inserted. There are other ways of expanding abbrevs: C-M-Space
(^R Abbrev Expand Only) causes the abbrev just before point to be
expanded without inserting any other character. C-M-Space will
expand abbrevs even if Word Abbrev mode is currently off; this
can be useful if the system is slow, and you just want to
manually expand a few abbrevs. M-' (^R Word Abbrev Prefix Mark)
allows you to "glue" an abbrev onto any prefix: suppose you have
the abbrev "comm" for "committee", and wish to insert
"intercommittee "; type "inter", M-' (you will now see "inter-"),
and then "comm "; "inter-comm " becomes "intercommittee ". M-X
Expand Word Abbrevs in Region checks each word in the region and
offers to expand each word abbrev found; for more details see its
self-documentation. (It is similar to the M-X Query Replace
command.)
25.1.3 Unexpanding Abbrevsî 25.1.3 Unexpanding Abbrevsî 25.1.3 Unexpanding Abbrevs
C-X U (^R Unexpand Last Word) "unexpands" the last abbrev's
expansion, replacing the last expansion with the abbrev that
caused it. If any auto-filling was done because of the expansion
(you had Auto Fill mode on), that too is undone. If you type
another C-X U, the first one is "undone" and the abbrev is
expanded again. Only the last expansion can be undone.
Sometimes you may find that C-X U unexpands an abbrev later than
the one you're looking at. In this case, do another C-X U and go
back and manually correct the earlier expansion.
If you know beforehand that a word will expand, and want to
prevent it, you can simply "quote" the punctuation character with
C-Q. For example, typing "comm", a C-Q, and then "." gives
"comm." without expanding.î 176 EMACS Manual for ITS Users
25.1.4 Listing Abbrevsî 25.1.4 Listing Abbrevsî 25.1.4 Listing Abbrevs
M-X List Word Abbrevs<cr> shows all currently defined abbrevs.
An abbrev "foo" that expands to "this is an abbrev" in Text mode
and has been expanded 3 times, is listed as:
foo: (Text) 3 "this is an abbrev"
An abbrev "gfoo" which expands to "this is a global abbrev" in
all modes, expanded 11 times, is listed as:
gfoo: 11 "this is a global abbrev"
Note that any use of the double-quote character (") inside an
expansion is doubled, to distinguish the use of " from the "s
that surround the whole expansion. Thus if the global abbrev
'helpc' expands to 'the "Help" character', it is listed as:
helpc: 3 "the ""Help"" character"
25.1.5 Editing the Definition Listî 25.1.5 Editing the Definition Listî 25.1.5 Editing the Definition List
M-X Edit Word Abbrevs places you in a recursive editing level,
editing the current word abbrev definition list. The abbrevs
appear in the same format used by M-X List Word Abbrevs. When
you exit (via C-M-C), the current word abbrevs are redefined from
the edited definition list: any abbrevs that have been deleted
from the list are killed, new ones added to the list are defined,
and old ones changed are modified. In effect, after exiting the
Edit Word Abbrev editing level, all previously-defined word
abbrevs are killed, and the edited list is used to define new
abbrevs. Typing C-] (Abort Recursive Edit) aborts Edit Word
Abbrevs, without killing or redefining any abbrevs.
25.1.6 Saving Abbrev Definitionsî 25.1.6 Saving Abbrev Definitionsî 25.1.6 Saving Abbrev Definitions
M-X Write Word Abbrev File$<filename><cr> writes an "abbrev
definition file" which contains the definitions of all the
abbrevs in your EMACS now. M-X Read Word Abbrevî 177 EMACS Manual for ITS Users
File$<filename><cr> reads in such a file and defines the abbrevs.
(Other abbrevs already defined are not affected unless the file
redefines them.) If you don't supply a filename, the last file
you used in either of these commands is used again, originally
defaulting to WORDAB DEFNS. With these two commands, you can
save the abbrevs you defined in one EMACS and restore them in
another EMACS another day. If you want abbrevs to be
automatically saved when you exit EMACS (with C-X C-C (^R Return
to Superior)), set the option variable Save Word Abbrevs to 1.
(They are saved only if the definitions have changed.)
The format of the definition file is designed for fast loading,
not ease of human readability. (But if you have to, you can
figure it out enough to read or even edit it.) If you want M-X
Write Word Abbrev File to write a human-readable version instead,
set the option Readable Word Abbrev Files to 1. (M-X Read Word
Abbrev File will be able to read this format, but not as fast.)
If you have an EVARS file, you might want to put the following
lines into it in order to turn on Word Abbrev mode, have your
abbrev definition file automatically read when EMACS starts up,
and enable automatic exit-saving:
*: 1 MM Word Abbrev Mode$
*: MM Read Word Abbrev File$WORDAB DEFNS$
Save Word Abbrevs:1
Or if you have an init file, use the following Teco code:
1 MM Word Abbrev Mode$
MM Read Word Abbrev File$WORDAB DEFNS$
1u$Save Word Abbrevs$
25.2 Advanced Usageî 25.2 Advanced Usageî 25.2 Advanced Usage
The use of Word Abbrev mode as discussed in the previous
section suffices for most users. However, some users who use
Word Abbrev mode a lot or have highly tailored environments may
desire more flexibility or need more power to handle extreme
situations than the basic commands provide.î 178 EMACS Manual for ITS Users
25.2.1 Alternatives and Customizationsî 25.2.1 Alternatives and Customizationsî 25.2.1 Alternatives and Customizations
M-X Make Word Abbrev$<abbrev>$<expansion>$<mode><cr>
M-X Kill All Word Abbrevs<cr>
M-X Make These Characters Expand$<characters><cr>
M-X Attach Word Abbrev Keyboard Macro
^R Kill Mode Word Abbrev
^R Kill Global Word Abbrev
Only Global Abbrevs
Set this option if you only use globals.
Additional Abbrev Expanders
Variable for adding a few more expanders.
WORDAB Ins Chars
Variable for replacing entire set of expanders.
The basic commands for defining a new mode abbrev, C-X C-A (^R
Add Mode Word Abbrev) and C-X C-H (^R Inverse Add Mode Word
Abbrev), work only in the current mode. A more general command
is M-X Make Word Abbrev which takes three string arguments: the
first is the abbrev, the second is the expansion, and the third
is the mode (such as "Text"). This command can also define
global abbrevs, by providing "*" as the mode name.
M-X Kill All Word Abbrevs<cr> is a very quick way of killing
every abbrev currently defined. After this command, no abbrev
will expand. (A slower but more careful way is with M-X Edit
Word Abbrevs.)
The functions ^R Kill Mode Word Abbrev and ^R Kill Global Word
Abbrev exist, but are not connected to any commands by default.
If you find having to specify negative arguments to C-X C-A
(^R Add Mode Word Abbrev) and C-X + (^R Add Global Word Abbrev)
inconvenient, you should connect these functions to commands.
(See section 5.2 [Set Key], page 24. Or See section 22.6 [Init],
page 143.)
If you prefer to use only global abbrevs then you should set
the option variable Only Global Abbrevs to 1. You can do this
after or before turning on Word Abbrev mode; it makes noî 179 EMACS Manual for ITS Users
difference. This causes the global abbrev definers which would
otherwise be on C-X + (^R Add Global Word Abbrev) and C-X -
(^R Inverse Add Global Word Abbrev) to be on the easier to type
characters C-X C-A and C-X C-H. In addition, the checking done
whenever you type an expander character (a punctuation character)
is about three times faster for the no-expansion case, which is
what happens most of the time.
Normally, the following characters cause expansion (followed by
whatever they would normally do were Word Abbrev mode off; such
as, insert themselves): !~@#;$%^&*-_=+[]()\|:`"{},<.>'/? and
Space, Return, Linefeed, and Tab. You can, however, specify
additional characters to cause expansion (digits, for instance,
or greek letters on keyboards with Top-keys). M-X Make These
Characters Expand$<characters><cr> adds the characters in the
string argument to the list of expanders. Alternatively, you can
set the variable Additional Abbrev Expanders to contain the
string of characters. (This is particularly useful in an init or
EVARS file.) If you wish to completely replace the set of
characters that cause expansion, set the variable WORDAB Ins
Chars in your init file. See section 22.6 [init], page 143, for
details on setting variables in init and EVARS files.
25.2.2 Manipulating Definition Listsî 25.2.2 Manipulating Definition Listsî 25.2.2 Manipulating Definition Lists
One reason you might want to manipulate the definition lists is
to provide more structure to the definition environment than just
the mode vs. global structure provided normally, such as to group
together in a file those abbrevs pertaining to one topic.
M-X Insert Word Abbrevs<cr> inserts into the buffer a list of
the current word abbrev definitions, in the format that M-X List
Word Abbrevs uses. M-X Insert Word Abbrevs$<string><cr> inserts
some of the abbrevs' definitions; See section 25.2.3 [Many
Abbrevs], page 180, for details.
M-X Define Word Abbrevs<cr> defines a set of word abbrevs from
a definition list in the buffer. There should be nothing else
besides the definition list in the buffer; or, if there is, you
must narrow the buffer to just the definition list. See
section 17 [Narrowing], page 93.î 180 EMACS Manual for ITS Users
25.2.3 Dealing with Many Abbrevsî 25.2.3 Dealing with Many Abbrevsî 25.2.3 Dealing with Many Abbrevs
Some users build up a very large number of abbrevs. This
causes a couple of problems: First, defining all those abbrevs
when EMACS starts up can become too slow; this problem is
discussed in the next section. Second, the commands that deal
with the entire definition list become unwieldy.
M-X List Word Abbrevs$<string><cr> shows you the definitions of
just the abbrev definitions containing <string> (in the abbrev,
in the mode, or in the expansion). The argument is actually a
TECO search string (See section 19.3 [TECO search strings],
page 101.). If you want to see the abbrevs which contain either
^î <string1> or <string2>, separate the strings with a |O; to see
abbrev definitions containing either "defn" or "wab", do M-X List
^î Word Abbrevs$defn|Owab<cr>.
You can provide M-X List Word Abbrevs with an argument to
control whether the filtering string applies to just the abbrev
(C-U 1), just the expansion (C-U 2), just the mode (C-U 4), or
any combination (the sum). C-U 3 M-X List Word Abbrevs$lisp<cr>
will match "lisp" against abbrevs and expansions, but not modes.
M-X Insert Word Abbrevs$<string><cr> works similarly, but
inserts the list into the buffer instead of typing it out.
25.2.4 Dumped EMACS Environmentsî 25.2.4 Dumped EMACS Environmentsî 25.2.4 Dumped EMACS Environments
M-X Write Word Abbrev File$<filename><cr>
Writes a file of all abbrev definitions, before
dumping.
M-X Read Word Abbrev File$<filename><cr>
Reads file of abbrev definitions at init-time.
M-X Write Incremental Word Abbrev File$<filename><cr>
Writes a file of abbrev definitions changed since
dumping.
M-X Read Incremental Word Abbrev File$<filename><cr>
Reads file of changed abbrev definitions at
startup-time.
Some users with highly customized EMACS environments (their
init files take a long time to run) "dump out" theirî 181 EMACS Manual for ITS Users
environments, in effect creating another EMACS-like program (the
"dump") which starts up much faster. (For instance, 1.7 cpu
seconds instead of 70.5 cpu seconds. See the file INFO;MKDUMP,
for details about a simple method of dumping environments. See
the file INFO;CONV, for details about more general environment
dumping.) Since the dumped environment contains word abbrev
definitions, a dumped environment with hundreds of abbrevs can
start just as quickly as if it had none. (But reading all these
abbrevs with M-X Read Word Abbrev File in the init file
originally took a long time.) For these users it is important,
at dump-startup time, to read in only those abbrevs which were
_____î changed or defined since the environment was dumped out. A file
which contains only these new abbrev's definitions is called an
___________ ____ ______ ____î incremental word abbrev file. (It also can specify that certain
abbrevs are to be killed if they were defined when the
environment was dumped out, but subsequently killed.)
The startup for the dump should use the Read Incremental Word
Abbrev File function instead of Read Word Abbrev File. It takes
the filename as a string argument, which defaults to INCABS >.
The command M-X Write Incremental Word Abbrev File$<filename><cr>
writes such a file, writing out those abbrevs more recent than
the dump (ones read by Read Incremental Word Abbrev File and ones
defined in the current editing session).
Setting Save Word Abbrevs to -1 will cause an incremental
abbrev file to be automatically written, if necessary, when EMACS
is exited.
When you want to dump out a new EMACS, first create a new,
complete word abbrev definition file using M-X Write Word Abbrev
___î File. This file now has all abbrevs in it, and you can thus
delete any incremental definition files you have. Then start up
the new EMACS from scratch, using the init file, and dump it.
(The init file in general should call Read Word Abbrev File and
then also call Read Incremental Word Abbrev File, just in case
there are both kinds of files around. The startup calls only
Read Incremental Word Abbrev File.) Note that these functions
will return without error if their files don't exist, as a
convenience.
25.3 Teco Details for Extension Writersî 25.3 Teco Details for Extension Writersî 25.3 Teco Details for Extension Writers
This section documents some details that users programming
extensions may need to know, in order to interact properly with
Word Abbrev mode operation or to build upon it.î 182 EMACS Manual for ITS Users
The variable WORDAB Setup Hook, if non-0, is executed when the
WORDAB library is loaded and sets itself up. (M-X Word Abbrev
Mode<cr> in the default EMACS environment auto-loads the WORDAB
library.) If there is no hook, the normal key connections (C-X
C-A, C-X U, etc.) are made; if there is a hook, it must do the
connections.
The variable Word Abbrevs Modified is non-0 when abbrev
definitions have changed. This is used to signal the
abbrev-saving mechanism.
The abbrev definers, such as C-X C-A (^R Add Mode Word Abbrev),
check to see if the volatile TECO mark, FS ^R Mark$, is set; if
it is, then the region between point and FS ^R Mark$ is used as
the expansion. The intention is to provide a mechanism for
simple but safe expansion marking. See section 22.5 [FS Flags],
page 142.
Finally, the general way that Word Abbrev mode works is this:
at certain times, when characters are likely to have been
reconnected, a Word Abbrev mode subroutine looks at each of the
expander characters to see if they are running an expander or
have been reconnected. If they don't have expanders, they are
connected to an expander function (which first checks for
expansion and then calls the "old" function, what the character
was connected to before). The problem is that it is not really
possible to efficiently catch all the times that characters of
interest are reconnected. So, as a good guess, Word Abbrev mode
looks at these characters when the & Set Mode Line function is
called. This happens when major or minor modes change, when
buffer switching happens, and when Set Key is used. These are
the standard times that connections are changed. However, the
extension writer must be careful about reconnecting expander
characters. If an extension might do this, it should do 1FS Mode
Change$ to cause expansions to be redefined.î 183 EMACS Manual for ITS Users
CHAPTER TWENTY-SIXî CHAPTER TWENTY-SIXî CHAPTER TWENTY-SIX
THE PICTURE SUBSYSTEM, AN EDITOR FOR TEXT PICTURESî THE PICTURE SUBSYSTEM, AN EDITOR FOR TEXT PICTURESî THE PICTURE SUBSYSTEM, AN EDITOR FOR TEXT PICTURES
If you want to create a picture made out of text characters
(for example, a picture of the division of a register into
fields, as a comment in a program), the PICTURE package can make
it easier.
Do M-X Load Lib$PICTURE<cr>, and then M-X Edit Picture is
available. Do M-X Edit Picture with point and mark surrounding
the picture to be edited. Edit Picture enters a recursive
editing level (which you exit with C-M-C, as usual) in which
certain commands are redefined to make picture editing more
convenient.
While you are inside Edit Picture, all the lines of the picture
are padded out to the margin with spaces. This makes
two-dimensional motion very convenient; C-B and C-F move
horizontally, and C-N and C-P move vertically without the
inaccuracy of a ragged right margin. When you exit from Edit
Picture, spaces at the ends of lines are removed. Nothing stops
you from moving outside the bounds of the picture, but if you
make any changes there slightly random things may happen.
Edit Picture makes alteration of the picture convenient by
redefining the way printing characters and Rubout work. Printing
characters are defined to replace (overwrite) rather than
inserting themselves. Rubout is defined to undo a printing
character: it replaces the previous character with a space, and
moves back to it.
Return is defined to move to the beginning of the next line.
This makes it usable for moving to the next apparently blank (but
actually filled with nothing but spaces) line, just as you use
Return normally with lines that are really empty. C-O creates
new blank lines after point, but they are created full of spaces.
Tab is redefined to indent (by moving over spaces, not
inserting them) to under the first non-space on the previous
line. Linefeed is as usual equivalent to Return followed by Tab.
Four movement-control commands exist to aid in drawing vertical
or horizontal lines: If you give the command M-X Up Picture
Movement, each character you type thereafter will cause the
cursor to move up instead of to the right. Thus if you want to
draw a line of dashes up to some point, you can give the command
Up Picture Movement, type enough dashes to make the line, andî 184 EMACS Manual for ITS Users
then give the command Right Picture Movement to put things back
to normal. Similarly, there are functions to cause downward and
leftward movement: Down Picture Movement and Left Picture
Movement. These commands remain in effect only until you exit
the Edit Picture function, (One final note: you can use these
cursor movement commands outside of Edit Picture too, even when
not in Overwrite mode. You have to be somewhat careful though.)
Possible future extensions include alteration of the kill and
un-kill commands to replace instead of deleting and inserting,
and to handle rectangles if two corners are specified using point
and the mark.
The DRAW library is a user-contributed library containing other
commands useful for editing pictures.î 185 EMACS Manual for ITS Users
CHAPTER TWENTY-SEVENî CHAPTER TWENTY-SEVENî CHAPTER TWENTY-SEVEN
SORTING FUNCTIONSî SORTING FUNCTIONSî SORTING FUNCTIONS
The SORT library contains functions called Sort Lines, Sort
Paragraphs and Sort Pages, to sort the region alphabetically line
by line, paragraph by paragraph or page by page. For example,
Sort Lines rearranges the lines in the region so that they are in
alphabetical order.
Paragraphs are defined in the same way as for the
paragraph-motion functions (See section 11.2 [Paragraphs],
page 52.) and pages are defined as for the page motion commands
(See section 18 [Pages], page 94.). All of these functions can
be undone by the Undo command (See section 24.3 [Undo],
page 163.). A numeric argument tells them to sort into reverse
alphabetical order.
You can rearrange pages to any way you like using the functions
Make Page Permutation Table and Permute Pages From Table. Make
Page Permutation Table starts you editing a table containing the
first line of each page. This table is kept in a buffer named
*Permutation Table*. You specify the new ordering for the pages
by rearranging the first lines into the desired order. You can
also omit or duplicate pages by omitting or duplicating the
lines.
When you are finished rearranging the lines, use Permute Pages
From Table to rearrange the entire original file the same way.
Reselect the original buffer first. The permuted version is
constructed in a buffer named *Permuted File*. The original
buffer is not changed. You can use Insert Buffer to copy the
data into the original buffer.î 186 EMACS Manual for ITS Users
APPENDIX Iî APPENDIX Iî APPENDIX I
PARTICULAR TYPES OF TERMINALSî PARTICULAR TYPES OF TERMINALSî PARTICULAR TYPES OF TERMINALS
I.1 Ideal Keyboardsî I.1 Ideal Keyboardsî I.1 Ideal Keyboards
An ideal EMACS keyboard can be recognized because it has a
Control key and a Meta key on each side, with another key labeled
Top above them.
On an ideal keyboard, to type any character in the 9-bit
character set, hold down Control or Meta as appropriate while
typing the key for the rest of the character. To type C-M-K,
type K while holding down Control and Meta.
You will notice that there is a key labeled "Escape" and a key
labeled "Alt". The Altmode character is the one labeled "Alt".
"Escape" has other functions entirely; it is handled by ITS and
has nothing to do with EMACS. While we are talking about keys
handled by ITS, on Meta keyboards the way to interrupt a program
is CALL, rather than Control-Z, and entering communicate mode
^î uses the BACK-NEXT key rather than Control-_. CALL echoes as |Z,
but if you type C-Z it is just an ordinary character which
happens to be an EMACS command to return to the superior.
^ ^î Similarly, BACK-NEXT echoes as |_ but if you type |_ it is just
an EMACS command which happens not to be defined.
The key labeled "Top" is an extra shift key. It is used to
produce the peculiar "SAIL" graphics characters which appear on
the same keys as the letters. The "Shift" key gets you
upper-case letters, but "Top" gets you the SAIL characters. As
EMACS commands, these characters are normally self-inserting,
like all printing characters. But once inserted, SAIL characters
are really the same as ASCII control characters, and since
characters in files are just 7 bits there is no way to tell them
apart. EMACS can display them either as ASCII control
characters, using an uparrow or caret to indicate them, or it can
display them as SAIL characters, whichever you like. The command
Control-Alpha (SAIL Character Mode) toggles the choice. Alpha is
a SAIL character and you can only type it on a terminal with a
Top key, but only those terminals can display the SAIL characters
anyway. SAIL characters are displayed if the variable SAIL
Character Mode is nonzero.
One other thing you can do with the Top key is type the Help
character, which is Top-H on these keyboards. BACK-NEXT H also
works, though.î 187 EMACS Manual for ITS Users
For inserting an Altmode, on an ideal keyboard you can type
C-M-Altmode. C-Altmode is a synonym for C-M-C (^R Exit).
The "bit prefix" characters that you must use on other
terminals are also available on terminals with Meta keys, in case
you find them more convenient or get into habits on those other
terminals.
To type numeric arguments on these keyboards, type the digits
or minus sign while holding down either Control or Meta.
I.2 Keyboards with an "Edit" keyî I.2 Keyboards with an "Edit" keyî I.2 Keyboards with an "Edit" key
Keyboards with Edit keys probably belong to Datamedia or
Teleray terminals. The Edit and Control keys are a pair of shift
keys. Use the Control key to type Control characters and the
Edit key to type Meta characters. Thus, the 9-bit EMACS
character C-M-Q is typed by striking the "Q" key while holding
down "Edit" and "Control".
While the Edit key is a true independent bit which can be
combined with anything else you can type, the Control key really
means "ASCII control". Thus, the only Control characters you can
type are those which exist in ASCII. This includes C-A through
C-Y, C-], C-@, C-\, and C-^. C-Z and C-_ can be typed on the
terminal but they are intercepted by the operating system and
therefore unavailable as EMACS commands. C-[ is not available
because its spot in ASCII is pre-empted by Altmode. The
corresponding Control-Meta commands are also hard to type. If
you can't type C-; directly, then you also can't type C-M-;
directly.
Though you can't type C-; directly, you can use the bit prefix
character C-^ and type C-^ ;. Similarly, while you can't type
C-M-;, you can use the Control-Meta prefix C-C and type C-C ;.
Because C-^ is itself awkward, we have designed the EMACS command
set so that the hard-to-type Control (non-Meta) characters are
rarely needed.
In order to type the Help character you must actually type two
characters, C-_ and H. C-_ is an escape character for ITS
itself, and C-_ followed by H causes ITS to give the Help
character as input to EMACS.
To type numeric arguments, it is best to type the digits or
minus sign while holding down the Edit key.î 188 EMACS Manual for ITS Users
I.3 ASCII Keyboardsî I.3 ASCII Keyboardsî I.3 ASCII Keyboards
An ASCII keyboard allows you to type in one keystroke only the
command characters with equivalents in ASCII. No Meta characters
are possible, and not all Control characters are possible either.
The Control characters which you can type directly are
C-A through C-Y, C-], C-@, C-\, and C-^. C-Z and C-_ can be
typed on the terminal but they are intercepted by the operating
system and therefore unavailable as EMACS commands. C-[ is not
available because its spot in ASCII is pre-empted by Altmode.
Those characters which you can't type directly can be typed as
two character sequences using the bit prefix characters Altmode,
C-C and C-^. Altmode turns on the Meta bit of the character that
follows it. Thus, M-A can be typed as Altmode A, and C-M-A as
Altmode C-A. Altmode can be used to get almost all of the
characters that can't be typed directly. C-C can be used to type
any Control-Meta character, including a few that Altmode can't be
used for because the corresponding non-Meta character isn't on
the keyboard. Thus, while you can't type C-M-; as Altmode
Control-;, since there is no Control-; in ASCII, you can type
C-M-; as C-C ;. The Control (non-Meta) characters which can't be
typed directly require the use of C-^, as in C-^ < to get the
effect of C-<. Because C-^ by itself is hard to type, the EMACS
command set is arranged so that most of these non-ASCII Control
characters are not very important. Usually they have synonyms
which are easier to type. In fact, in this manual only the
easier-to-type forms are usually mentioned.
In order to type the Help character you must actually type two
characters, C-_ and H. C-_ is an escape character for ITS
itself, and C-_ followed by H causes ITS to give the Help
character as input to EMACS.
On ASCII keyboards, you can type a numeric argument by typing
an Altmode followed by the minus sign and/or digits. Then comes
the command for which the argument is intended. For example,
type Altmode 5 C-N to move down five lines. If the command is a
Meta command, it must have an Altmode of its own, as in Altmode 5
Altmode F to move forward five words.
Note to customizers: this effect requires redefining the
Meta-digit commands, since the Altmode and the first digit amount
to a Meta-digit character. The new definition is ^R Autoarg, and
the redefinition is done by the default init file.
If you use numeric arguments very often, and you dislike having
to start one with an Altmode, you might enjoy using Autoarg mode,î 189 EMACS Manual for ITS Users
in which you can specify a numeric argument by just typing the
digits. See section 4 [Arguments], page 19, for details.
I.4 Upper-case-only Terminalsî I.4 Upper-case-only Terminalsî I.4 Upper-case-only Terminals
On terminals lacking the ability to display or enter lower case
characters, a special input and output case-flagging convention
has been defined for editing files which contain lower case
characters.
The customary escape convention is that a slash prefixes any
upper case letter; all unprefixed letters are lower case (but see
below for the "lower case punctuation characters"). This
convention is chosen because lower case is usually more frequent
in files containing any lower case at all. Upper case letters
are displayed with a slash ("/") in front. Typing a slash
followed by a letter is a good way to insert an upper case
letter. Typing a letter without a slash inserts a lower case
letter. For the most part, the buffer will appear as if the
slashes had simply been inserted (type /A and it inserts an upper
case A, which displays as /A), but cursor-motion commands will
reveal that the slash and the A are really just one character.
Another way to insert an upper-case letter is to quote it with
C-Q.
Note that this escape convention applies only to display of the
buffer and insertion in the buffer. It does not apply to
arguments of commands (it is hardly ever useful for them, since
case is ignored in command names and most commands' arguments).
Case conversion is performed when you type commands into the
minibuffer, but not when the commands are actually executed.
The ASCII character set includes several punctuation characters
whose codes fall in the lower case range and which cannot be
typed or displayed on terminals that cannot handle lower case
letters. These are the curly braces ("{" and "}"), the vertical
bar ("|"), the tilde ("~"), and the accent grave ("`"). Their
upper case equivalents are, respectively, the square brackets
("[" and "]"), the backslash ("\"), the caret ("^"), and the
atsign ("@"). For these punctuation characters, EMACS uses the
opposite convention of that used for letters: the ordinary, upper
case punctuations display as and are entered as themselves, while
the lower case forms are prefixed by slashes. This is because
the "lower case" punctuations are much less frequently used. So,
to insert an accent grave, type "/@".î 190 EMACS Manual for ITS Users
When the slash escape convention is in effect, a slash is
displayed and entered as two slashes.
This slash-escape convention is not normally in effect. To
turn it on, the TECO command -1$ (minus one dollar sign, not
Altmode!) must be executed. The easiest way to do this is to use
the minibuffer: Altmode Altmode -1$ Altmode Altmode. To turn
off the escape convention (for editing a file of all upper case),
the command is 0$ (zero dollar sign), or Altmode Altmode 0$
Altmode Altmode. If you use such a bad terminal frequently, you
can define yourself an EMACS extension, a command to turn
slash-escape on and off.
The lower case editing feature is actually more flexible than
described here. Refer to the TECO commands F$ (dollar sign) and
FS CASE$, using M-X TECDOC, for full details. See section 22.5
[FS Flags], page 142.
I.5 The SLOWLY Package for Slow Terminalsî I.5 The SLOWLY Package for Slow Terminalsî I.5 The SLOWLY Package for Slow Terminals
The SLOWLY library is intended as an aid for people using
display terminals at slow speeds. It provides means of limiting
redisplay to smaller parts of the screen, and for turning off
redisplay for a time while you edit.
To use SLOWLY, do M-X Load Library$SLOWLY<cr>, and if your
terminal is a display operating at 1200 baud or less (or if its
speed is unknown) SLOWLY will set up the commands described here.
Comments, bugs, and suggestions via Arpanet mail to RWK@MIT-MC,
or by US mail or phone to the author of this manual.
I.5.1. Brief Descriptionî I.5.1. Brief Descriptionî I.5.1. Brief Description
SLOWLY provides an alternate version of the incremental
searching commands on C-S and C-R, ^R Edit Quietly on C-X Q, a
way to shrink the screen at either the top or the bottom on M-O,
and more flexibility in where minibuffers get displayed. If
SLOWLY is loaded, it redefines these commands only if the
terminal speed is 1200 baud or less.î 191 EMACS Manual for ITS Users
I.5.2. SLOWLY Commandsî I.5.2. SLOWLY Commandsî I.5.2. SLOWLY Commands
The commands provided are:
M-O (^R Set Screen Size)
This function reduces the amount of the screen
used for displaying your text, down to a few
lines at the top or the bottom. If called
without an argument, it will use the same size as
last time (or 3 if it hasn't been called before).
If given a positive argument, that is taken to be
the number of lines to use at the top of the
screen. If given a negative argument, it is
taken to be the number of lines at the bottom of
the screen. If given an argument of 0, it
returns to the use of the entire screen. The
section of the screen that is in use is
(defaultly) delimited by a line of 6 dashes.
This command sets the variable Short Display
Size.
C-S (^R Slow Display I-Search)
This function is just like the usual incremental
search, except if the search would run off the
screen and cause a redisplay, it narrows the
screen to use only a few lines at the top or
bottom of the screen to do the redisplay in.
When the search is exited, use of the full screen
resumes. The size of the window used for the
search is the value of the variable Slow Search
Lines. If it is positive, it is the number of
lines at top of screen; if negative, it is the
number of lines at bottom of screen. The default
is 1. The variable Slow Search Separator
contains the string used to show the end of the
search window. By default it is six dashes. See
section 10 [Search], page 46.
C-R (^R Slow Reverse Display I-Search)
This searches in backwards in the style of ^R
Slow Display I-Search.
C-X Q (^R Edit Quietly)
This function enters a recursive editing level
with redisplay inhibited. This means that your
commands are carried out but the screen does not
change. C-L with no argument redisplays. So youî 192 EMACS Manual for ITS Users
can update the screen when you want to. Two
C-L's in a row clear the screen and redisplay.
C-L with an argument repositions the window, as
usual (See section 15 [C-L], page 87.). To exit
and resume continuous redisplay, use C-M-C.
I.5.3. Minibuffersî I.5.3. Minibuffersî I.5.3. Minibuffers
SLOWLY provides control over how minibuffers display on your
screen. The variable Minibuffer Size specifies how many lines it
takes up. If this is made negative, the minibuffer will appear
at the bottom of the screen instead of the top. Thus one mode of
operation which some people like is to use ^R Set Screen Size to
set up to not use the bottom 3 lines of the screen, and set
Minibuffer Size to -3. This will permanently reserve 3 lines at
the bottom of the screen for the minibuffer. See section 23
[Minibuffer], page 156.
The variable Minibuffer Separator holds the string used to
separate the minibuffer area from the rest of the screen. By
default, this is six dashes.
SLOWLY installs its minibuffer by defining the variable MM &
Minibuffer.
I.5.4. SLOWLY Optionsî I.5.4. SLOWLY Optionsî I.5.4. SLOWLY Options
The simplest way to run SLOWLY is to simply load it, and use
the default key assignments, etc. SLOWLY sets up those key
assignments only if your terminal is no faster than 1200 baud.
If you want SLOWLY to not set up these things unless your
terminal is running at 300 baud or slower (ugh!), set the
variable SLOWLY Maximum Speed to the highest speed at which
SLOWLY is desired. Put the following in your EMACS init file:
300 M.VSLOWLY Maximum Speed$
If you don't like the command assignments set up by SLOWLY, you
can override them by defining the variable SLOWLY Setup Hook
before loading SLOWLY. The value should be TECO commands to
define the command assignments you wish.î 193 EMACS Manual for ITS Users
SLOWLY normally uses lines of six dashes to separate areas of
the screen. You can tell it to use something else instead.
Minibuffers use the value of Minibuffer Separator, searches use
the value of Slow Search Separator. If one of these is
unspecified (the variable does not exist), the value of Default
Separator is used. The separator for small screen mode is always
the value of Default Separator. If the value specified is the
null string, a blank line is used. If the value specified is
zero, nothing (not even a blank line) is used. This is useful
for searches, since you aren't going to be doing any editing in
the search window.
Even though SLOWLY does not redefine the commands on a fast
terminal, you might wish to load it only on slow terminals to
save address space the rest of the time. This can be done in an
init file with
fsospeed$-1200:"g m(m.mLoad Library$)SLOWLY$'î 194 EMACS Manual for ITS Users
APPENDIX IIî APPENDIX IIî APPENDIX II
USE OF EMACS FROM PRINTING TERMINALSî USE OF EMACS FROM PRINTING TERMINALSî USE OF EMACS FROM PRINTING TERMINALS
While EMACS was designed to be used from a display terminal,
you can use it effectively from a printing terminal. You cannot,
however, learn EMACS using one.
All EMACS commands have the same editing effect from a printing
terminal as they do from a display. All that is different is how
they try to show what they have done. EMACS attempts to make the
same commands that you would use on a display terminal act like
an interactive line-editor. It does not do as good a job as
editors designed originally for that purpose, but it succeeds
well enough to keep you informed of what your commands are
accomplishing, provided you know what they are supposed to do and
know how they would look on a display.
The usual buffer display convention for EMACS on a printing
terminal is that the part of the current line before the cursor
is printed out, with the cursor following (at the right position
in the line). What follows the cursor on the line is not
immediately visible, but normally you will have a printout of the
original contents of the line a little ways back up the paper.
For example, if the current line contains the word "FOOBAR", and
the cursor is after the "FOO", just "FOO" would appear on the
paper, with the cursor following it. Typing the C-F command to
move over the "B" would cause "B" to be printed, so that you
would now see "FOOB" with the cursor following it. All
forward-motion commands that move reasonably short distances
print out what they move over.
Backward motion is handled in a complicated way. As you move
back, the terminal backspaces to the correct place. When you
stop moving back and do something else, a linefeed is printed
first thing so that the printing done to reflect subsequent
commands does not overwrite the text you moved back over and
become garbled by it. The Rubout command acts like backward
motion, but also prints a slash over the character rubbed out.
Other backwards deletion commands act like backward motion; they
do not print slashes (it would be an improvement if they did).
One command is different on a printing terminal: C-L, which
normally means "clear the screen and redisplay". With no
argument, it retypes the entire current line. An argument tells
it to retype the specified number of lines around the current
line.î 195 EMACS Manual for ITS Users
On printing terminals, C-S (^R Incremental Search) does not
print out the context automatically. To see what you have found
at any stage, type C-L. This types out the current line but does
not exit the search. All the normal facilities of incremental
searching are available for finding something else if you had not
found the right place initially.
Unfortunately, EMACS cannot perfectly attain its goal of making
the text printed on the current line reflect the current line in
the buffer, and keeping the horizontal position of the cursor
correct. One reason is that it is necessary for complicated
commands to echo, but echoing them screws up the "display". The
only solution is to type a C-L whenever you have trouble
following things in your mind. The need to keep a mental model
of the text being edited is, of course, the fundamental defect of
all printing terminal editors.
Note: it is possible to make a specific command print on a
printing terminal in whatever way is desired, if that is worth
while. For example, Linefeed knows explicitly how to display
itself, since the general TECO redisplay mechanism isn't able to
handle it. Suggestions for how individual commands can display
themselves are welcome, as long as they are algorithmic rather
than simply of the form "please do the right thing".î 196 EMACS Manual for ITS Users
GLOSSARYî GLOSSARYî GLOSSARY
Aborting Aborting a recursive editing level (q.v.) means
canceling the command which invoked the recursive
editing. For example, if you abort editing a
message to be sent, the message is not sent.
Aborting is done with the command C-]. See
section 24.1 [Aborting], page 159.
Altmode Altmode is a character, labelled Escape on some
keyboards. It is the bit prefix character (q.v.)
used to enter Meta-characters when the keyboard
does not have a Meta (q.v.) key. See section 2
[Characters], page 10. Also, it delimits string
arguments to extended commands. See section 5
[Extended Commands], page 21.
Balance Parentheses
EMACS can balance parentheses manually or
automatically. You can ask to move from one
parenthesis to the matching one. See
section 20.6.1 [Lists], page 111. When you
insert a close parenthesis, EMACS can show the
matching open. See section 20.4 [Matching],
page 105.
Bit Prefix Character
A bit prefix character is a command which
combines with the next character typed to make
one character. They are used for effectively
typing commands which the keyboard being used is
not able to send. For example, to use a
Meta-character when there is no Meta key on the
keyboard, the bit prefix character Altmode (q.v.)
is needed. See section 2 [Characters], page 10.
Buffer The buffer is the basic editing unit; one buffer
corresponds to one piece of text being edited.
You can have several buffers, but at any time you
are editing only one, the "selected" buffer,
though two can be visible when you are using two
windows. See section 14 [Buffers], page 83.
C- C is an abbreviation for Control, in the name of
a character. See section 2 [Characters],
page 10.î 197 EMACS Manual for ITS Users
C-M- C-M- is an abbreviation for Control-Meta, in the
name of a character. See section 2 [Characters],
page 10.
Comment A comment is text in a program which is intended
only for humans reading the program, and is
marked specially so that the compiler will ignore
it. EMACS offers special commands for creating
and killing comments. See section 20.5
[Comments], page 107.
Command A command is a character or sequence of
characters which, when typed by the user, fully
specifies one action to be performed by EMACS.
For example, "X" and "Control-F" and "Meta-X Text
Mode<cr>" are commands. See section 2
[Characters], page 10. Sometimes the first
character of a multi-character command is also
considered a command: M-X Text Mode<cr> is a
command (an extended command), and M-X is also a
command (a command to read a function name and
invoke the function). See section 5 [Extended
Commands], page 21.
Completion Completion is what EMACS does when it
automatically fills out the beginning of an
extended command name into the full name, or as
much of it as can be deduced for certain.
Completion occurs when Altmode, Space or Return
is typed. See section 5 [Extended Commands],
page 21.
Connected A character command in EMACS works by calling a
function which it is "connected" to.
Customization often involves connecting a
character to a different function. See "Dispatch
table". See section 2 [Characters], page 10.
Continuation Line
When a line of text is longer than the width of
the screen, it is displayed on more than one line
of screen. We say that the line is continued,
and that all screen lines used but the first are
called continuation lines. See section 3 [Basic
Editing], page 15.
Control Control is the name of a bit which each command
character does or does not contain. A
character's name includes the word Control if theî 198 EMACS Manual for ITS Users
Control bit is part of that character. Ideally,
this means that the character is typed using the
Control key: Control-A is typed by typing "A"
while holding down Control. On most keyboards
the Control key works in only some cases; the
rest of the time, a bit prefix character (q.v.)
must be used. See section 2 [Characters],
page 10.
Control-Character
A Control character is a character which includes
the Control bit.
Control-X Command
A Control-X command is a two-character command
whose first character is the prefix character
Control-X. See section 2 [Characters], page 10.
<cr> <cr> stands for the carriage return character, in
contexts where the word "Return" might be
confusing. See section 2 [Characters], page 10.
CRLF CRLF stands for the sequence of two characters,
carriage return followed by linefeed, which is
used to separate lines in files and in text being
edited in EMACS. See section 2 [Characters],
page 10.
Cursor The cursor is the object on the screen which
indicates the position called point (q.v.) at
which insertion and deletion takes place. The
cursor is part of the terminal, and often blinks
or underlines the character where it is located.
See section 1 [Screen], page 5.
Customization Customization is making minor changes in the way
EMACS works. It is often done by setting
variables (See section 22.3 [Variables],
page 137.) or by reconnecting commands (See
section 5.2 [Functions], page 24.).
Defun A defun is a list at the top level of list
structure in a Lisp program. It is so named
because most such lists are calls to the Lisp
function defun. See section 20.6.2 [Defuns],
page 114.
Delete This is the label used on some keyboards for the
Rubout character.î 199 EMACS Manual for ITS Users
Deletion Deletion means erasing text without saving it.
EMACS deletes text only when it is expected not
to be worth saving (all whitespace, or only one
character). The alternative is killing (q.v.).
See section 9.1 [Killing], page 39.
Dispatch Table The dispatch table is what records the
connections (q.v.) from command characters to
functions. Think of a telephone switchboard
connecting incoming lines (commands) to
telephones (functions). A standard EMACS has one
set of connections; a customized EMACS may have
different connections. See section 5.2
[Functions], page 24.
Echo Area The echo area is the bottom three lines of the
screen, used for echoing the arguments to
commands, for asking questions, and printing
brief messages. See section 1 [Screen], page 5.
Echoing Echoing is acknowledging the receipt of commands
by displaying them (in the echo area). Most
programs other than EMACS echo all their
commands. EMACS never echoes single-character
commands; longer commands echo only if you pause
while typing them.
Error Messages Error messages are single lines of output printed
by EMACS when the user or a TECO program asks for
something impossible. They appear at the top of
the screen and end with a question mark.
Escape Escape is the label used on some keyboards for
the Altmode character.
Exiting Exiting EMACS means returning to EMACS's
superior, normally HACTRN. See section 6.4
[Exiting], page 31. Exiting a recursive editing
level (q.v.) means allowing the command which
invoked the recursive editing to complete
normally. For example, if you are editing a
message to be sent, and you exit, the message is
sent.
Extended Command
An extended command is a command which consists
of the character Meta-X followed by the command
name (really, the name of a function (q.v.)). An
extended command requires several characters ofî 200 EMACS Manual for ITS Users
input, but its name is made up of English words,
so it is easy to remember. See section 5
[Extended Commands], page 21.
Extension Extension means making changes to EMACS which go
beyond the bounds of mere customization. If
customization is moving the furniture around in a
room, extension is building new furniture. See
the file INFO;CONV.
Filling Filling text means moving text from line to line
so that all the lines are approximately the same
length. See section 11.4 [Filling], page 56.
Function A function is a named subroutine of EMACS. When
you type a command, EMACS executes a function
which corresponds to the command, and the
function does the work. Character commands are
connected to functions through the dispatch table
(q.v.). Extended commands contain the name of
the function to be called; this allows you to
call any function. See section 5 [Extended
Commands], page 21.
Global The global value of a variable or of a command
character definition applies to all buffers and
all files (except those which have their own
local values of the variable or definition). See
section 22.3 [Variables], page 137.
Grinding Grinding means reformatting a program so that it
is indented according to its structure. See
section 20.7 [Grinding], page 115.
Help You can type the Help character at any time to
ask what options you have, or to ask what any
command does. See section 7 [Help], page 33.
Home Directory Your home directory is the one on which your mail
and your init files are stored.
INFO INFO is the subsystem for perusing
tree-structured documentation files. The
documentation in INFO includes a version of the
EMACS manual.
ITS ITS is the Incompatible Timesharing System
written at the MIT Artificial Intelligence Lab.
EMACS was first developed on this system. Justî 201 EMACS Manual for ITS Users
what it is incompatible with has changed from
year to year.
Kill Ring The kill ring is where killed text is saved. It
holds the last nine or so blocks of killed text.
It is called a ring because you can bring any of
the saved blocks to the front by rotating the
ring. See section 9.2 [Un-Killing], page 41.
Killing Killing means erasing text and saving it inside
EMACS to be recovered later if desired. Most
EMACS commands to erase text do killing, as
opposed to deletion (q.v.). See section 9.1
[Killing], page 39.
List A list is, approximately, a text string beginning
with an open parenthesis and ending with the
matching close parenthesis. See section 20.6.1
[Lists], page 111. Actually there are a few
complications to the syntax, which is controlled
by the syntax table (See section 22.4 [Syntax],
page 139.).
Local A local value of a variable or of a command
character definition applies to only one buffer
or file. See section 22.7 [Locals], page 150.
Local Modes List
A local modes list appears in a file to specify
local values for variables or command character
definitions, to be in effect while visiting that
file.
M- M- in the name of a character is an abbreviation
for Meta.
M-X M-X is the character which begins an extended
command (q.v.). Extended commands have come to
be known also as "M-X commands", and an
individual extended command is often referred to
as "M-X such-and such". See section 5 [M-X],
page 21.
Major Mode The major modes are a mutually exclusive set of
options which configure EMACS for editing a
certain sort of text. Ideally, each programming
language has its own major mode. See
section 20.1 [Major Modes], page 102.î 202 EMACS Manual for ITS Users
Mark The mark points, invisibly, to a position in the
text. Many commands operate on the text between
point and the mark (known as the region, q.v.).
See section 8 [Mark], page 36.
Meta Meta refers to the Meta key. A character's name
includes the word Meta if the Meta key must be
held down in order to type the character. If
there is no Meta key, then the Altmode character
is used as a prefix instead. See section 2
[Characters], page 10.
Meta Character A Meta character is one whose character code
includes the Meta bit. These characters can be
typed only by means of a Meta key or by means of
the metizer command (q.v.).
Metizer The metizer is another term for the bit prefix
character for the Meta bit; namely, Altmode
(q.v.).
Minibuffer The minibuffer is a facility for editing and then
executing a TECO program. See section 23
[Minibuffer], page 156.
Minor mode A minor mode is an optional feature of EMACS
which can be switched on or off independently of
all other features. Each minor mode is both the
name of an option (q.v.) and the name of an
extended command to set the option. See
section 22.1 [Minor Modes], page 133.
MM-command This is an obsolete synonym for "extended
command".
Mode line The mode line is a line just above the echo area
(q.v.), used for status information. See
section 1.1 [Mode Line], page 6.
Narrowing Narrowing means limiting editing to only a part
of the text in the buffer. Text outside that
part is inaccessible to the user until the
boundaries are widened again, but it is still
there, and saving the file saves it all. See
section 17 [Narrowing], page 93.
Node The node is the unit of structure of INFO (q.v.)
files. When referring to documentation contained
only in INFO files, we sometimes refer to a nodeî 203 EMACS Manual for ITS Users
of a specific name, in a specific file, as in
"See the file INFO;CONV, node Hooks".
Numeric Argument
A numeric argument is a number specified before a
command to change the effect of the command.
Often the numeric argument serves as a repeat
count. See section 4 [Numeric Arguments],
page 19.
Option An option is a variable which exists to be set by
the user to change the behavior of EMACS
commands. This is an important method of
customization. See section 22.3 [Variables],
page 137.
Parse We say that EMACS parses words or expressions in
the text being edited. Really, all it knows how
to do is find the other end of a word or
expression. See section 22.4 [Syntax], page 139.
Point Point is the place in the buffer at which
insertion and deletion occur. Point is
considered to be between two characters, not at
one character. The terminal's cursor (q.v.)
indicates the location of point. See section 3
[Basic], page 15.
Prefix Character
A prefix character is a command whose sole
function is to introduce a set of multi-character
commands. Control-X (q.v.) is a prefix
character. The bit prefix characters (q.v.) are
other examples.
Prompt A prompt is text printed in the echo area to ask
the user for input. Printing a prompt is called
"prompting". EMACS can prompt when a command
requires an argument, or when only part of a
command has been typed. However, the prompt will
not appear unless you pause in your typing. See
section 5 [Extended Commands], page 21.
Q-Registers Q-registers are internal TECO variables which can
be used by EMACS or by the user to store text or
numbers. See section 9.3.2 [Q-Registers],
page 45.
Quitting Quitting means interrupting a command which isî 204 EMACS Manual for ITS Users
partially typed in or already executing. It is
done with Control-G. See section 24.1
[Quitting], page 159.
Quoting Quoting means depriving a character of its usual
special significance. It is usually done with
Control-Q. What constitutes special significance
depends on the context and on convention. For
example, an "ordinary" character as an EMACS
command inserts itself; so you can insert any
other character, such as Rubout, by quoting it as
in Control-Q Rubout. Not all contexts allow
quoting. See section 3 [Basic Editing], page 15.
Recursive Editing Level
A recursive editing level is a state in which
part of the execution of a command involves
asking the user to edit some text. This text may
or may not be the same as the text to which the
command was applied. The mode line indicates
recursive editing levels with square brackets
("[" and "]"). See section 6.3 [Recursive
Editing Level], page 30.
Redisplay Redisplay is the process of correcting the image
on the screen to correspond to changes that have
been made in the text being edited. See
section 1 [Screen], page 5.
Region The region is the text between point (q.v.) and
the mark (q.v.). The terminal's cursor indicates
the location of point, but the mark is invisible.
Many commands operate on the text of the region.
See section 8 [Mark], page 36.
Return Return is the carriage return character, used as
input to EMACS. Return is used as a command in
itself to insert a line separator. It also
terminates arguments for most commands. See
section 2 [Characters], page 10.
Rubout Rubout is a character, sometimes labelled
"Delete". It is used as a command to delete one
character of text. It also deletes one character
when an EMACS command is reading an argument.
S-expression An s-expression is the basic syntactic unit of
Lisp: either a list, or a symbol containing no
parentheses (actually, there are a few exceptionsî 205 EMACS Manual for ITS Users
to the rule, based on the syntax of Lisp). See
section 20.6.1 [Lists], page 111.
Selecting Selecting a buffer (q.v.) means making editing
commands apply to that buffer as opposed to any
other. At all times one buffer is selected and
editing takes place in that buffer. See
section 14 [Buffers], page 83.
Self-documentation
Self-documentation is the feature of EMACS which
can tell you what any command does, or give you a
list of all commands related to a topic you
specify. You ask for self-documentation with the
Help character. See section 7 [Help], page 33.
String Argument
A string argument is an argument which follows
the command name in an extended command. In "M-X
Apropos$word<cr>", "Word" is a string argument to
the Apropos command. See section 5 [Extended
Commands], page 21.
Subsystem A subsystem of EMACS is an EMACS command which,
itself, reads commands and displays the results.
Examples are INFO, which is for perusing
documentation; DIRED, which is for editing
directories; RMAIL and BABYL, which are for
reading and editing mail. The word "subsystem"
implies that it offers many independent commands
which can be used freely. If an EMACS function
asks specific questions, we do not call it a
subsystem.
Usually the subsystem continues in operation
until a specific command to exit (usually "Q") is
typed. The commands for a subsystem do not
usually resemble ordinary EMACS commands, since
editing text is not their purpose. The Help
character should elicit the subsystem's
documentation. See section 6.1 [Subsystems],
page 28.
Syntax Table The syntax table tells EMACS which characters are
part of a word, which characters balance each
other like parentheses, etc. See section 22.4
[Syntax], page 139.
Tailoring This is a synonym for customization (q.v.).î 206 EMACS Manual for ITS Users
TECO Search String
A TECO search string is a sort of pattern used by
the TECO search command, and also by various
EMACS commands which use the TECO search command.
See section 19.3 [TECO search strings], page 101.
Top Level Top level is the normal state of EMACS, in which
you are editing the text of the file you have
visited. You are at top level whenever you are
not in a recursive editing level or a subsystem
(q.v.).
Twenex Twenex is the operating system which DEC likes to
call "TOPS-20". However, a person should not be
forced to call a system "tops" unless he really
thinks so. Come now, DEC, don't you think people
will praise your products voluntarily? The name
"Twenex" is also more appropriate because Twenex
was developed from the Tenex system, and has no
relationship to "TOPS-10". What's more, it's
very euphonious.
Typeout Typeout is a message, printed by an EMACS
command, which overwrites the area normally used
for displaying the text being edited, but which
does not become part of the text. Typeout is
used for messages which might be too long to fit
in the echo area (q.v.). See section 1 [Screen],
page 5.
Undo Undo is a command which undoes the effect on the
buffer of a previous command. Only some commands
are undoable and only the most recent undoable
command can be undone. See section 24.3 [Undo],
page 163.
Un-killing Un-killing means reinserting text previously
killed. It can be used to undo a mistaken kill,
or for copying or moving text. See section 9.2
[Un-killing], page 41.
User Name Your user name is the name you use to log in. It
identifies you as opposed to all the other users.
It may be the same as your home directory's name.
Variable A variable is a name with which EMACS associates
a value, which can be a number or a string. See
section 22.3 [Variables], page 137. Some
variables ("options") are intended to be used orî 207 EMACS Manual for ITS Users
set by the user; others are for purely internal
purposes.
Virtual Boundaries
The virtual boundaries delimit the accessible
part of the buffer, when narrowing (q.v.) is in
effect. See section 17 [Narrowing], page 93.
Visiting Visiting a file means loading its contents into a
buffer (q.v.) where they can be edited. See
section 13.1 [Visiting], page 69.
Wall Chart The wall chart is a very brief EMACS reference
sheet giving one line of information about each
short command.
Whitespace Whitespace is any run of consecutive formatting
characters (space, tab, carriage return,
linefeed, and backspace).
Widening Widening is the operation which undoes narrowing
(q.v.). See section 17 [Narrowing], page 93.
Window A window is a region of the screen in which text
being edited is displayed. EMACS can divide the
screen into two windows. See section 16
[Windows], page 90. "The window" also means the
position in the buffer which is at the top of the
screen. See section 15 [Display], page 87.
Working Directory
This is the directory which you have told the
system you wish to operate on primarily at the
moment. This is usually the same as your home
directory (q.v.). It is specified with the DDT
command :CWD <directory>.
Yanking This is a synonym for un-killing (q.v.).
^R The string "^R" is the beginning of many function
names. See section 5.2 [Functions], page 24.
^R Mode ^R mode is the real time editing mode of TECO.
EMACS always operates in this mode.î 208 EMACS Manual for ITS Users
COMMAND SUMMARYî COMMAND SUMMARYî COMMAND SUMMARY
This summary contains brief descriptions with cross references
for all commands, grouped by topic. Within each topic, they are
in alphabetical order. Our version of alphabetical order places
non-control non-meta characters first, then control characters,
then meta characters, then control-meta characters. Control-X
and Meta-X commands come last. Not all Meta-X commands are
included.
Prefix Charactersî Prefix Charactersî Prefix Characters
Altmode (^R Prefix Meta)
Altmode is a bit prefix character which turns on
the Meta bit in the next character. Thus,
Altmode F is equivalent to the single character
Meta-F, which is useful if your keyboard has no
Meta key. See section 2 [Characters], page 10.
Control-^ (^R Prefix Control)
Control-^ is a bit prefix character which turns
on the Control bit in the following character.
Thus, Control-^ < is equivalent to the single
character Control-<. See section 2 [Characters],
page 10.
Control-C (^R Prefix Control-Meta)
Control-C is a bit prefix character which turns
on the Control bit and the Meta bit in the
following character. Thus, Control-C ; is
equivalent to the single character Control-Meta-;
. See section 2 [Characters], page 10.
Control-Q (^R Quoted Insert)
Control-Q inserts the following character. This
is a way of inserting control characters. See
section 3 [Basic Editing], page 15.
Control-U (^R Universal Argument)
Control-U is a prefix for numeric arguments which
works the same on all terminals. See section 4
[Arguments], page 19.
Control-X î 209 EMACS Manual for ITS Users
Control-X is a prefix character which begins a
two-character command. Each combination of
Control-X and another character is a "Control-X
command". Individual Control-X commands appear
in this summary according to their uses.
Meta-X (^R Extended Command)
Meta-X is a prefix character which introduces an
extended command name. See section 5 [Meta-X],
page 21.
Control-Meta-X (^R Instant Extended Command)
Control-Meta-X is another way of invoking an
extended command. Instead of putting the
arguments in the same line as the command name,
the command reads the arguments itself. See
section 5 [Meta-X], page 21.
Control-digits, Meta-digits, Control-Meta-digits
These all specify a numeric argument for the next
command. See section 4 [Arguments], page 19.
Control-Minus, Meta-Minus, Control-Meta-Minus
These all begin a negative numeric argument for
the next command. See section 4 [Arguments],
page 19.
Simple Cursor Motionî Simple Cursor Motionî Simple Cursor Motion
Control-A (^R Beginning of Line, built-in function)
Control-A moves to the beginning of the line.
See section 3 [Basic Editing], page 15.
Control-B (^R Backward Character, built-in function)
Control-B moves backward one character. See
section 3 [Basic Editing], page 15.
Control-E (^R End of Line, built-in function)
Control-E moves to the end of the line. See
section 3 [Basic Editing], page 15.
Control-F (^R Forward Character, built-in function)
Control-F moves forward one character. See
section 3 [Basic Editing], page 15.
Control-H (^R Backward Character, built-in function) î 210 EMACS Manual for ITS Users
Control-H moves backward one character. See
section 3 [Basic Editing], page 15.
Control-N (^R Down Real Line)
Control-N moves vertically straight down. See
section 3 [Basic Editing], page 15.
Control-P (^R Up Real Line)
Control-P moves vertically straight up. See
section 3 [Basic Editing], page 15.
Control-R (^R Reverse Search)
Control-R is like Control-S but searches
backward. See section 10 [Search], page 46.
Control-S (^R Incremental Search)
Control-S searches for a string, terminated by
Altmode. It searches as you type. See
section 10 [Search], page 46.
Meta-< (^R Goto Beginning)
Meta-< moves to the beginning of the buffer. See
section 3 [Basic Editing], page 15.
Meta-> (^R Goto End)
Meta-> moves to the end of the buffer. See
section 3 [Basic Editing], page 15.
Control-X Control-N (^R Set Goal Column)
Control-X Control-N sets a horizontal goal for
the Control-N and Control-P commands. When there
is a goal, those commands try to move to the goal
column instead of straight up or down.
Linesî Linesî Lines
Return (^R CRLF)
Return inserts a line separator, or advances onto
a following blank line. See section 3 [Basic
Editing], page 15.
Control-O (^R Open Line, built-in function)
Control-O inserts a line separator, but point
stays before it. See section 3 [Basic Editing],
page 15.î 211 EMACS Manual for ITS Users
Meta-= (^R Count Lines Region)
Meta-= prints the number of lines between point
and mark. See section 8 [Mark], page 36.
Control-X Control-O (^R Delete Blank Lines)
Control-X Control-O deletes all but one of the
blank lines around point. If the current line is
not blank, all blank lines following it are
deleted. See section 3 [Basic Editing], page 15.
Control-X Control-T (^R Transpose Lines)
Control-X Control-T transposes the contents of
two lines. See section 12 [Fixing Typos],
page 65.
Killing and Un-killingî Killing and Un-killingî Killing and Un-killing
Rubout (^R Backward Delete Character, built-in function)
Rubout deletes the previous character. See
section 3 [Basic Editing], page 15.
Control-Rubout (^R Backward Delete Hacking Tabs, built-in
function)
Control-Rubout deletes the previous character,
but converts a tab character into several spaces.
See section 20.6 [Lisp], page 110.
Control-D (^R Delete Character, built-in function)
Control-D deletes the next character. See
section 3 [Basic Editing], page 15.
Control-K (^R Kill Line)
Control-K kills to the end of the line, or, at
the end of a line, kills the line separator. See
section 9.1 [Killing], page 39.
Control-W (^R Kill Region)
Control-W kills the region, the text between
point and the mark. See section 9.1 [Killing],
page 39. See section 8 [Region], page 36.
Control-Y (^R Un-kill)
Control-Y reinserts the last saved block of
killed text. See section 9.2 [Un-Killing],
page 41.î 212 EMACS Manual for ITS Users
Meta-W (^R Copy Region)
Meta-W saves the region as if it were killed
without removing it from the buffer. See
section 9.2 [Un-Killing], page 41.
Meta-Y (^R Un-kill Pop)
Meta-Y rolls the kill ring to reinsert saved
killed text older than the most recent kill. See
section 9.2 [Un-Killing], page 41.
Control-Meta-W (^R Append Next Kill)
Control-Meta-W causes an immediately following
kill command to append its text to the last saved
block of killed text. See section 9.2
[Un-Killing], page 41.
Control-X G (^R Get Q-reg)
Control-X G inserts in the buffer the contents of
a q-register. See section 9.3.2 [Q-registers],
page 45.
Control-X T (^R Transpose Regions)
Control-X T transposes two arbitrary regions
defined by point and the last three marks. See
section 12 [Fixing Typos], page 65.
Control-X X (^R Put Q-reg)
Control-X X inserts in the buffer the contents of
a q-register. See section 9.3.2 [Q-registers],
page 45.
M-X Overwrite Mode
M-X Overwrite Mode turns Overwrite mode on or
off. In Overwrite mode, printing characters
overwrite existing text instead of pushing it to
the right. See section 22.1 [Minor Modes],
page 133.
Scrolling and Display Controlî Scrolling and Display Controlî Scrolling and Display Control
Control-Alpha (SAIL Character Mode)
Control-Alpha toggles SAIL Character mode. When
this mode is on, control characters in the buffer
are displayed as themselves. See section 1
[Screen], page 5.î 213 EMACS Manual for ITS Users
Control-L (^R New Window)
Control-L clears the screen and centers point in
it. With an argument, it can put point on a
specific line of the screen. See section 15
[Display], page 87.
Control-V (^R Next Screen)
Control-V scrolls the text upward by a screenful
or several lines. See section 15 [Display],
page 87.
Meta-R (^R Move to Screen Edge)
Meta-R moves point to beginning of the text on a
specified line of the screen. See section 15
[Display], page 87.
Meta-V (^R Previous Screen)
Meta-V scrolls downward by a screenful or several
lines. See section 15 [Display], page 87.
Control-Meta-R (^R Reposition Window)
Control-Meta-R tries to center on the screen the
function or paragraph you are looking at. See
section 15 [Display], page 87.
Control-Meta-V (^R Scroll Other Window)
Control-Meta-V scrolls the other window up or
down, when you are in two window mode. See
section 16 [Windows], page 90.
M-X View Buffer
M-X View Buffer skips through a buffer by
screenfuls. See section 15 [Display], page 87.
M-X View File
M-X View File lets you move through a file
sequentially by screenfuls forward and back. See
section 13.7 [View File], page 79.
The Mark and the Regionî The Mark and the Regionî The Mark and the Region
Control-Space (^R Set/Pop Mark)
Control-Space sets the mark or moves to the
location of the mark. See section 8 [Mark],
page 36.î 214 EMACS Manual for ITS Users
Control-< (^R Mark Beginning)
Control-< sets the mark at the beginning of the
buffer. See section 8 [Mark], page 36.
Control-> (^R Mark End)
Control-> sets the mark at the end of the buffer.
See section 8 [Mark], page 36.
Control-@ (^R Set/Pop Mark)
Control-@ sets the mark or moves to the location
of the mark. See section 8 [Mark], page 36.
Meta-@ (^R Mark Word)
Meta-@ puts the mark at the end of the next word.
See section 11.1 [Words], page 50.
Meta-H (^R Mark Paragraph)
Meta-H puts point at the beginning of the
paragraph and the mark at the end. See
section 11.2 [Sentences], page 52.
Control-Meta-@ (^R Mark Sexp)
Control-Meta-@ puts the mark at the end of the
next s-expression. See section 20.6.1 [Lists],
page 111.
Control-Meta-H (^R Mark Defun)
Control-Meta-H puts point at the beginning of the
current Defun and the mark at the end. See
section 20.6.2 [Defuns], page 114.
Control-X H (^R Mark Whole Buffer)
Control-X H puts point at the beginning of the
buffer and the mark at the end. See section 8
[Mark], page 36.
Control-X Control-P (^R Mark Page)
Control-X Control-P puts point at the beginning
of the current page and the mark at the end. See
section 18 [Pages], page 94.
Control-X Control-X (^R Exchange Point and Mark)
Control-X Control-X sets point where the mark was
and the mark where point was. See section 8
[Mark], page 36.î 215 EMACS Manual for ITS Users
Whitespace and Indentationî Whitespace and Indentationî Whitespace and Indentation
Tab (^R Indent According to Mode)
Tab either adjusts the indentation of the current
line or inserts some indentation, in a way that
depends on the major mode. See section 20.3
[Indenting Programs], page 104. See section 11.3
[Indenting Text], page 54.
Linefeed (^R Indent New Line)
Linefeed is equivalent to Return followed by Tab.
It moves to a new line and indents that line. If
done in the middle of a line, it breaks the line
and indents the new second line. See
section 11.3 [Indenting Text], page 54.
Meta-Tab (^R Tab to Tab Stop)
Meta-Tab indents to the next EMACS-defined tab
stop. See section 11.3 [Indenting Text],
page 54.
Meta-M (^R Back to Indentation)
Meta-M positions the cursor on the current line
after any indentation. See section 11.3
[Indenting Text], page 54.
Meta-\ (^R Delete Horizontal Space)
Meta-\ deletes all spaces and tab characters
around point. See section 11.3 [Indenting Text],
page 54.
Meta-^ (^R Delete Indentation)
Meta-^ joins two lines, replacing the indentation
of the second line with zero or one space,
according to the context. See section 11.3
[Indenting Text], page 54.
Control-Meta-O (^R Split Line)
Control-Meta-O breaks a line, preserving the
horizontal position of the second half by
indenting it to its old starting position. See
section 11.3 [Indenting Text], page 54.
Control-Meta-\ (^R Indent Region)
Control-Meta-\ indents each line in the region,
either by applying Tab to each line, or by giving
each the same specified amount of indentation.
See section 11.3 [Indenting Text], page 54.î 216 EMACS Manual for ITS Users
Control-X Tab (^R Indent Rigidly)
Control-X Tab shifts all the lines in the region
right or left the same number of columns. See
section 11.3 [Indenting Text], page 54.
M-X Edit Indented Text
M-X Edit Indented Text enters a recursive editing
level designed for editing text in which each
line is indented. See section 11.4 [Filling],
page 56.
M-X Edit Tab Stops
M-X Edit Tab Stops lets you edit the tab stops
used by ^R Tab to Tab Stop. See section 11.3
[Indenting Text], page 54.
M-X Edit Tabular Text
M-X Edit Tabular Text enters a recursive editing
level designed for editing text arranged in a
table. See section 11.4 [Filling], page 56.
M-X Indent Tabs Mode
M-X Indent Tabs Mode turns Indent Tabs mode on or
off. When Indent Tabs mode is on, the
indentation commands use tab characters for
indentation whenever possible. Otherwise they
use only spaces. See section 22.1 [Minor Modes],
page 133.
M-X Tabify
M-X Tabify converts spaces after point to tabs
when that can be done without changing the
appearance. See section 11.3 [Indenting Text],
page 54.
M-X Untabify
M-X Untabify converts all tabs after point to
spaces. A numeric argument says how far apart
the tab stops are, which is good for converting
files brought from systems with tab stops at
intervals other than 8. See section 11.3
[Indenting Text], page 54.î 217 EMACS Manual for ITS Users
Words, Sentences and Paragraphsî Words, Sentences and Paragraphsî Words, Sentences and Paragraphs
Meta-A (^R Backward Sentence)
Meta-A moves to the beginning of the sentence.
See section 11.2 [Sentences], page 52.
Meta-B (^R Backward Word)
Meta-B moves backward one word. See section 11.1
[Words], page 50.
Meta-D (^R Kill Word)
Meta-D kills one word forward. See section 11.1
[Words], page 50.
Meta-E (^R Forward Sentence)
Meta-E moves to the end of the sentence. See
section 11.2 [Sentences], page 52.
Meta-F (^R Forward Word)
Meta-F moves forward one word. See section 11.1
[Words], page 50.
Meta-H (^R Mark Paragraph)
Meta-H puts point at the front of the current
paragraph and the mark at the end. See
section 11.2 [Sentences], page 52.
Meta-K (^R Kill Sentence)
Meta-K kills to the end of the sentence. See
section 11.2 [Sentences], page 52.
Meta-T (^R Transpose Words)
Meta-T transposes two consecutive words. See
section 11.1 [Words], page 50.
Meta-[ (^R Backward Paragraph)
Meta-[ moves to the beginning of the paragraph.
See section 11.2 [Sentences], page 52.
Meta-] (^R Forward Paragraph)
Meta-] moves to the end of the paragraph. See
section 11.2 [Sentences], page 52.
Meta-Rubout (^R Backward Kill Word)
Meta-Rubout kills the previous word. See
section 11.1 [Words], page 50.
Control-X Rubout (^R Backward Kill Sentence) î 218 EMACS Manual for ITS Users
Control-X Rubout kills back to the beginning of
the sentence. See section 11.2 [Sentences],
page 52.
M-X Atom Word Mode
M-X Atom Word Mode turns Atom Word mode on or
off. In Atom Word mode, the word commands
consider an entire Lisp atom as one word. See
section 22.1 [Minor Modes], page 133.
M-X Edit Syntax Table
M-X Edit Syntax Table allows you to edit the
syntax table for word and list delimiters. See
section 22.4 [Syntax Table], page 139.
Filling Textî Filling Textî Filling Text
Meta-G (^R Fill Region)
Meta-G fills the region, treating it (usually) as
one paragraph. See section 11.4 [Filling],
page 56.
Meta-Q (^R Fill Paragraph)
Meta-Q fills the current or next paragraph. See
section 11.4 [Filling], page 56.
Meta-S (^R Center Line)
Meta-S centers the current line. See
section 11.4 [Filling], page 56.
Control-X . (^R Set Fill Prefix)
Control-X . specifies the fill prefix, which is
used for filling indented text. See section 11.4
[Filling], page 56.
Control-X F (^R Set Fill Column)
Control-X F sets the variable Fill Column which
controls the margin for filling and centering.
See section 11.4 [Filling], page 56.
M-X Auto Fill Mode
M-X Auto Fill Mode turns Auto Fill mode on or
off. In Auto Fill mode, long lines are broken
between words automatically. See section 11.4
[Filling], page 56.î 219 EMACS Manual for ITS Users
Exiting, Quittingî Exiting, Quittingî Exiting, Quitting
Control-G
Control-G quits, interrupting a running command,
or discarding any partially typed command. See
section 24.1 [Quitting], page 159.
Control-] (Abort Recursive Edit)
Control-] aborts a recursive editing level; that
is to say, exits it without allowing the command
which invoked it to finish. See section 24.1
[Quitting], page 159.
Control-Meta-C (^R Exit, built-in function)
Control-Meta-C exits from a recursive editing
level and allows the command which invoked the
recursive editing level to finish. At top level,
it exits from EMACS to its superior job. See
section 6.4 [Exiting], page 31.
Control-X Control-C (^R Return to Superior)
Control-X Control-C returns from EMACS to its
superior job, even if EMACS is currently inside a
recursive editing level. In that case,
re-entering EMACS will find it still within the
recursive editing level. See section 6.4
[Exiting], page 31.
M-X Compile
M-X Compile recompiles the file you are visiting,
in a manner that depends on the major mode. See
section 20.2 [Compile], page 103.
M-X Top Level
M-X Top Level returns to the top level EMACS
command loop or to TECO. See section 24.1
[Quitting], page 159.
M-X Undo
M-X Undo retracts the last undoable change to the
buffer. See section 24.2 [Lossage], page 160.î 220 EMACS Manual for ITS Users
Pagesî Pagesî Pages
Control-X L (^R Count Lines Page)
Control-X L prints the number of lines on the
current page, and how many come before point and
how many come after. See section 18 [Pages],
page 94.
Control-X P (^R Narrow Bounds to Page)
Control-X P narrows the virtual boundaries to the
current page. See section 17 [Narrowing],
page 93.
Control-X [ (^R Previous Page)
Control-X [ moves backward to the previous page
boundary. See section 18 [Pages], page 94.
Control-X ] (^R Next Page)
Control-X ] moves forward to the next page
boundary. See section 18 [Pages], page 94.
Control-X Control-P (^R Mark Page)
Control-X Control-P puts point at the beginning
and the mark at the end of the current page. See
section 18 [Pages], page 94.
M-X View Page Directory (in PAGE)
M-X View Page Directory prints a directory of the
pages of the file. See section 18.1 [PAGE],
page 96.
M-X What Page
M-X What Page prints the current page and line
number in the file. See section 18 [Pages],
page 94.
Lispî Lispî Lisp
Meta-( (^R Make ())
Meta-( places a pair of parentheses around the
next several s-expressions. See section 20.6.1
[Lists], page 111.
Meta-) (^R Move Over ))
Meta-) moves past the next close parenthesis andî 221 EMACS Manual for ITS Users
adjusts the indentation of the following line.
See section 20.6.1 [Lists], page 111.
Control-Meta-Tab (^R Indent for Lisp)
Control-Meta-Tab adjusts the indentation of the
current line for proper Lisp style. See
section 20.3 [Indenting], page 104.
Control-Meta-( (^R Backward Up List)
Control-Meta-( moves backward up one level of
list structure. See section 20.6.1 [Lists],
page 111.
Control-Meta-) (^R Up List)
Control-Meta-) moves forward up one level of list
structure. See section 20.6.1 [Lists], page 111.
Control-Meta-@ (^R Mark Sexp)
Control-Meta-@ puts the mark at the end of the
next s-expression. See section 8 [Mark],
page 36.
Control-Meta-A (^R Beginning of Defun)
Control-Meta-A moves to the beginning of the
current Defun. See section 20.6.2 [Defuns],
page 114.
Control-Meta-B (^R Backward Sexp)
Control-Meta-B moves backward over one
s-expression. See section 20.6.1 [Lists],
page 111.
Control-Meta-D (^R Down List)
Control-Meta-D moves forward and down a level in
list structure. See section 20.6.1 [Lists],
page 111.
Control-Meta-E (^R End of Defun)
Control-Meta-E moves to the end of the current
Defun. See section 20.6.2 [Defuns], page 114.
Control-Meta-F (^R Forward Sexp)
Control-Meta-F moves forward over one
s-expression. See section 20.6.1 [Lists],
page 111.
Control-Meta-G (^R Format Code)
Control-Meta-G grinds the s-expression after
point. See section 20.7 [Grinding], page 115.î 222 EMACS Manual for ITS Users
Control-Meta-H (^R Mark Defun)
Control-Meta-H puts point before and the mark
after the current or next Defun. See
section 20.6.2 [Defuns], page 114.
Control-Meta-K (^R Kill Sexp)
Control-Meta-K kills the following s-expression.
See section 20.6.1 [Lists], page 111.
Control-Meta-N (^R Next List)
Control-Meta-N moves forward over one list,
ignoring atoms before the first open parenthesis.
See section 20.6.1 [Lists], page 111.
Control-Meta-P (^R Previous List)
Control-Meta-P moves backward over one list,
ignoring atoms reached before the first close
parenthesis. See section 20.6.1 [Lists],
page 111.
Control-Meta-Q (^R Indent Sexp)
Control-Meta-Q adjusts the indentation of each of
the lines in the following s-expression, but not
the current line. See section 20.3 [Indenting],
page 104.
Control-Meta-T (^R Transpose Sexps)
Control-Meta-T transposes two consecutive
s-expressions. See section 20.6.1 [Lists],
page 111.
Control-Meta-U (^R Backward Up List)
Control-Meta-U moves backward up one level of
list structure. See section 20.6.1 [Lists],
page 111.
Filesî Filesî Files
Meta-. (^R Find Tag)
Meta-. moves to the definition of a specific
function, switching files if necessary. See
section 21 [TAGS], page 122.
Meta-~ (^R Buffer Not Modified)
Meta-~ clears the flag which says that the buffer
contains changes that have not been saved. See
section 13.1 [Visiting], page 69.î 223 EMACS Manual for ITS Users
Control-X Control-F (Find File)
Control-X Control-F visits a file in its own
buffer. See section 14 [Buffers], page 83.
Control-X Control-Q (^R Set File Read Only)
Control-X Control-Q makes the visited fie read
only, or no longer read only. See section 13.1
[Visiting], page 69.
Control-X Control-S (^R Save File)
Control-X Control-S saves the visited file. See
section 13.1 [Visiting], page 69.
Control-X Control-V (^R Visit File)
Control-X Control-V visits a file. See
section 13.1 [Visiting], page 69.
Control-X Control-W (Write File)
Control-X Control-W saves the file, asking for
names to save it under. See section 13.7
[Advanced File Commands], page 79.
M-X Append to File
M-X Append to File appends the contents of the
region to the end of a specified file. See
section 13.7 [Advanced File Commands], page 79.
M-X Auto Save Mode
M-X Auto Save Mode turns Auto Save mode on or
off. See section 13.3 [Auto Save], page 72.
M-X Copy File
M-X Copy File copies a file to a new name. See
section 13.7 [Advanced File Commands], page 79.
M-X Delete File
M-X Delete File deletes a file. See section 13.7
[Advanced File Commands], page 79.
M-X Insert File
M-X Insert File inserts the contents of a file
into the buffer (within the existing text). See
section 13.7 [Advanced File Commands], page 79.
M-X Prepend to File
M-X Prepend to File appends the contents of the
region to the start of a specified file. See
section 13.7 [Advanced File Commands], page 79.î 224 EMACS Manual for ITS Users
M-X Rename File
M-X Rename File changes the name of a file. See
section 13.7 [Advanced File Commands], page 79.
M-X Revert File
M-X Revert File undoes changes to a file by
reading in the previous version. See
section 13.2 [Revert File], page 72.
M-X Save All Files
M-X Save All Files offers to write back buffers
which may need it. See section 14 [Buffers],
page 83.
M-X Set Visited Filename
M-X Set Visited Filename changes the visited
filename, without writing a file. See
section 13.7 [Advanced File Commands], page 79.
M-X Write Region
M-X Write Region writes the contents of the
region into a file. See section 13.7 [Advanced
File Commands], page 79.
File Directoriesî File Directoriesî File Directories
Control-X D (^R DIRED)
Control-X D invokes the directory editor DIRED,
useful for deleting many files. See section 13.6
[DIRED], page 76.
Control-X Control-D (^R Directory Display)
Control-X Control-D displays a subset of a
directory. See section 13.4 [Directories],
page 75.
M-X Clean Directory
M-X Clean Directory deletes all but the most
recent versions of every file in a directory.
See section 13.5 [Cleaning Directories], page 75.
M-X Compare Directories
M-X Compare Directories compare two directories
with the same name on different machines. See
section 13.8 [Compare Directories], page 81.î 225 EMACS Manual for ITS Users
M-X List Directories
M-X List Directories list the names of all disk
directories. See section 13.4 [Directories],
page 75.
M-X List Files
M-X List Files prints a very brief listing of a
directory, listing only the filenames, several
files per line. See section 13.4 [Directories],
page 75.
M-X Reap File
M-X Reap File deletes all but the most recent
versions of a file. See section 13.5 [Cleaning
Directories], page 75.
M-X View Directory
M-X View Directory prints a file directory. See
section 13.4 [Directories], page 75.
Buffersî Buffersî Buffers
Control-X Control-B (List Buffers)
Control-X Control-B prints a list of all buffers,
their major modes and the files they are
visiting. See section 14 [Buffers], page 83.
Control-X A (^R Append to Buffer)
Control-X A adds the text of region into another
buffer. See section 9.3 [Copying], page 44.
Control-X B (Select Buffer)
Control-X B is the command for switching to
another buffer. See section 14 [Buffers],
page 83.
Control-X K (Kill Buffer)
Control-X K kills a buffer. See section 14
[Buffers], page 83.
M-X Insert Buffer
M-X Insert Buffer inserts the contents of another
buffer into the existing text of this buffer.
See section 14 [Buffers], page 83.
M-X Kill Some Buffers î 226 EMACS Manual for ITS Users
M-X Kill Some Buffers offers to kill each buffer.
See section 14 [Buffers], page 83.
M-X Make Space
M-X Make Space tries to free up space inside
EMACS for more libraries or buffers. See
section 24.2.5 [Storage Exhausted], page 161.
M-X Rename Buffer
M-X Rename Buffer changes the name of the current
buffer. See section 14 [Buffers], page 83.
M-X What Available Space
M-X What Available Space prints the amount of
space left inside EMACS for more libraries or
buffers. See section 24.2.5 [Storage Exhausted],
page 161.
Commentsî Commentsî Comments
Meta-Linefeed (^R Indent New Comment Line)
Meta-Linefeed moves to a new line and indents it.
If point had been within a comment on the old
line, a new comment is started on the new line
and indented under the old one. See section 20.5
[Comments], page 107.
Meta-; (^R Indent for Comment)
Meta-; inserts a properly indented comment at the
end of the current line, or adjusts the
indentation of an existing comment. See
section 20.5 [Comments], page 107.
Meta-N (^R Down Comment Line)
Meta-N moves down a line and starts a comment.
See section 20.5 [Comments], page 107.
Meta-P (^R Up Comment Line)
Meta-P moves down a line and starts a comment.
See section 20.5 [Comments], page 107.
Control-Meta-; (^R Kill Comment)
Control-Meta-; kills any comment on the current
line. See section 20.5 [Comments], page 107.
Control-X ; (^R Set Comment Column) î 227 EMACS Manual for ITS Users
Control-X ; sets the column at which comments are
indented, from an argument, the current column,
or the previous comment. See section 20.5
[Comments], page 107.
Case Conversionî Case Conversionî Case Conversion
Meta-C (^R Uppercase Initial)
Meta-C makes the next word lower case with a
capital initial. It moves over the word. See
section 11.5 [Case], page 58.
Meta-L (^R Lowercase Word)
Meta-L moves over a word converting it to lower
case. See section 11.5 [Case], page 58.
Meta-U (^R Uppercase Word)
Meta-U moves over a word converting it to upper
case. See section 11.5 [Case], page 58.
Control-X Control-L (^R Lowercase Region)
Control-X Control-L converts the text of the
region to lower case. See section 11.5 [Case],
page 58.
Control-X Control-U (^R Uppercase Region)
Control-X Control-U converts the text of the
region to upper case. See section 11.5 [Case],
page 58.
Minor Correctionsî Minor Correctionsî Minor Corrections
Meta-# (^R Change Font Region)
Meta-# inserts a font-change command good for
certain text justifiers around a word. See
section 11.6 [Fonts], page 59.
Meta-$ (^R Correct Word Spelling)
Meta-$ (Dollar sign, not Altmode) passes the word
before point to the SPELL program. If it is not
a correct spelling, you have the option of
replacing it with a corrected spelling. See
section 12 [Fixing Typos], page 65.î 228 EMACS Manual for ITS Users
Meta-' (^R Upcase Digit)
Meta-' converts a digit before point on the same
or previous line to a punctuation character,
assuming that you failed to type the shift key
and thus typed the digit by mistake. See
section 12 [Fixing Typos], page 65.
Meta-_ (^R Underline Word)
Meta-_ inserts underlining commands good for
certain text justifiers around a word. See
section 11.7 [Underlining], page 60.
Control-X # (^R Change Font Region)
Control-X # inserts font change commands good for
certain text justifiers around the region. See
section 11.6 [Fonts], page 59.
Control-X _ (^R Underline Region)
Control-X _ inserts underlining commands good for
certain text justifiers around the region. See
section 11.7 [Underlining], page 60.
Windowsî Windowsî Windows
Control-Meta-V (^R Scroll Other Window)
Control-Meta-V scrolls the other window up or
down. See section 15 [Display], page 87.
Control-X 1 (^R One Window)
Control-X 1 returns to one-window mode. See
section 16 [Windows], page 90.
Control-X 2 (^R Two Windows)
Control-X 2 splits the screen into two windows.
See section 16 [Windows], page 90.
Control-X 3 (^R View Two Windows)
Control-X 3 splits the screen into two windows
but stays in window one. See section 16
[Windows], page 90.
Control-X 4 (^R Visit in Other Window)
Control-X 4 displays two windows and selects a
buffer or visits a file in the other window. See
section 16 [Windows], page 90.î 229 EMACS Manual for ITS Users
Control-X O (^R Other Window)
Control-X O switches from one window to the
other. See section 16 [Windows], page 90.
Control-X ^ (^R Grow Window)
Control-X ^ changes the allocation of screen
space to the two windows. See section 16
[Windows], page 90.
M-X Compare Windows
M-X Compare Windows compares the text in window
one after point with that in window two after
point. It advances point in both windows to the
first non-matching text. See section 16
[Windows], page 90.
Narrowingî Narrowingî Narrowing
Control-X N (^R Narrow Bounds to Region)
Control-X N narrows the virtual boundaries to the
region. See section 17 [Narrowing], page 93.
Control-X P (^R Narrow Bounds to Page)
Control-X P narrows the virtual boundaries to the
current page. See section 18 [Pages], page 94.
Control-X W (^R Widen Bounds)
Control-X W widens the virtual boundaries back to
the entire buffer. See section 17 [Narrowing],
page 93.
Status Informationî Status Informationî Status Information
Control-X = (What Cursor Position)
Control-X = prints information on the screen
position and character position of the cursor,
the size of the file, and the character after the
cursor. See section 11.4 [Filling], page 56.
Control-X L (^R Count Lines Page)
Control-X L prints the number of lines in the
current page, and how many come before or after
point. See section 18 [Pages], page 94.î 230 EMACS Manual for ITS Users
M-X List Loaded Libraries
M-X List Loaded Libraries lists the names of all
loaded libraries. See section 22.2 [Libraries],
page 135.
M-X List Variables
M-X List Variables lists the names and values of
all variables, or of those whose names contain a
specified string. See section 22.3 [Variables],
page 137.
M-X List Redefinitions
M-X List Redefinitions describes all the ways
which the major mode and local modes of the
selected buffer modify the standard EMACS. See
section 20.1 [Major Modes], page 102.
M-X What Page
M-X What Page prints the page and line number of
point. See section 18 [Pages], page 94.
Keyboard Macrosî Keyboard Macrosî Keyboard Macros
Control-X ( (^R Start Kbd Macro)
Control-X ( begins defining a keyboard macro.
See section 22.8 [KBDMAC], page 152.
Control-X ) (^R End Kbd Macro)
Control-X ) terminates the definition of a
keyboard macro. See section 22.8 [KBDMAC],
page 152.
Control-X E (^R Call Last Kbd Macro)
Control-X E executes the most recently defined
keyboard macro. See section 22.8 [KBDMAC],
page 152.
Control-X Q (^R Kbd Macro Query)
Control-X Q in a keyboard macro can ask the user
whether to continue or allow him to do some
editing before continuing with the keyboard
macro. See section 22.8 [KBDMAC], page 152.
M-X Name Kbd Macro
M-X Name Kbd Macro gives a permanent name to the
last keyboard macro defined. See section 22.8
[KBDMAC], page 152.î 231 EMACS Manual for ITS Users
M-X View Kbd Macro
M-X View Kbd Macro prints the definition of a
keyboard macro. See section 22.8 [KBDMAC],
page 152.
Librariesî Librariesî Libraries
M-X Kill Libraries
M-X Kill Libraries discards one or more libraries
from core. See section 22.2 [Libraries],
page 135.
M-X List Library
M-X List Library describes briefly all the
functions in a library. See section 22.2
[Libraries], page 135.
M-X Load Library
M-X Load Library loads one library, permanently.
See section 22.2 [Libraries], page 135.
M-X Run Library
M-X Run Library loads a library temporarily,
invokes a function in it, and then discards the
library. See section 22.2 [Libraries], page 135.
Variablesî Variablesî Variables
M-X Edit Options
M-X Edit Options lets you edit, in a recursive
editing level, the values of many variables. See
section 22.3 [Variables], page 137.
M-X Kill Local Q-register
M-X Kill Local Q-register makes a q-register or
command character definition no longer local to
the selected buffer. See the file INFO;CONV,
node Vars.
M-X Kill Local Variable M-X Kill Local Variable makes a variable
value no longer local to the selected buffer.
See the file INFO;CONV, node Vars.î 232 EMACS Manual for ITS Users
M-X Kill Variable
M-X Kill Variable eliminates a particular
variable. See section 22.3 [Variables],
page 137.
M-X Make Local Q-register M-X Make Local Q-register makes a
q-register or command character definition local
to the selected buffer. See the file INFO;CONV,
node Vars.
M-X Make Local Variable M-X Make Local Variable makes a variable
value local to the selected buffer. See the file
INFO;CONV, node Vars.
M-X Set Key
M-X Set Key connects a function to a command
character. See section 5.2 [M-X Commands],
page 24.
M-X Set Variable
M-X Set Variable sets the value of a variable.
See section 22.3 [Variables], page 137.
M-X View Variable
M-X View Variable displays the value and comment
of a variable. See section 22.3 [Variables],
page 137.
Mailî Mailî Mail
Control-X M (Send Mail)
Control-X M allows you to edit and send a message
using your favorite mail-reading program. The
default is RMAIL. See section 6.2 [Mail],
page 29.
Control-X R (Read Mail)
Control-X R runs your choice of mail-reading
program to read and edit your mail. The default
is RMAIL. See section 6.2 [Mail], page 29.
M-X View Mail
M-X View Mail displays your own or another user's
mail file using View File. See section 6.2
[Mail], page 29.î 233 EMACS Manual for ITS Users
Minibufferî Minibufferî Minibuffer
Control-% (^R Replace String)
Control-% invokes a minibuffer containing a call
to Replace String. You fill in the arguments.
See section 19 [Replace], page 98.
Meta-Altmode (^R Execute Minibuffer)
Meta-Altmode invokes an empty minibuffer which
you can fill in with a TECO program to be
executed. See section 23 [Minibuffer], page 156.
Meta-% (^R Query Replace)
Meta-% invokes a minibuffer containing a call to
Query Replace. You fill in the arguments. See
section 19 [Replace], page 98.
Control-X Altmode (^R Re-execute Minibuffer)
Control-X Altmode re-executes a TECO program
previously executed in the minibuffer. It can
also re-execute an extended command. See
section 23 [Minibuffer], page 156.î 234 EMACS Manual for ITS Users
CATALOG OF LIBRARIESî CATALOG OF LIBRARIESî CATALOG OF LIBRARIES
Libraries Used Explicitlyî Libraries Used Explicitlyî Libraries Used Explicitly
These are libraries which you must load with M-X Load
Library$<libname><cr> to use. If no cross-reference is given,
the only documentation for the library is the self-documentation
contained in it. Use M-X List Library$<libname><cr> to print a
brief description of each function in the library. For more
detailed information, load the library and use M-X Describe on
individual functions.
ABSTR contains commands for making documentation files:
wall charts, and abstracts of libraries. See the
file INFO;CONV.
BABYL is a subsystem for reading, sending and editing
mail. See the file INFO;BABYL.
BSHACK has functions for operating on lines containing
overprinting.
BUGHUNT contains commands for putting your name into each
comment you edit. This is to record who changed
what.
CACHE implements a cache for speeding up EMACS
subroutine calls.
CHESS implements commands for editing pictures of chess
boards.
CLU implements CLU mode. See the file INFO;ECLU.
COLUMNS implements commands for converting single-column
text into double-column text and vice versa.
COMPLT provides completion for buffer names and variable
names.
DELIM implements commands for moving over balanced
groupings of various kinds of parentheses. There
are a pair of commands for square brackets, a
pair for angle brackets, etc.î 235 EMACS Manual for ITS Users
DOCLSP prints documentation from the MacLisp manual on a
specified Lisp function.
DOCIX constructs indexes of Lisp manual files for
DOCLSP.
DOCOND is a macro processor and conditionalizer for text
files, useful for maintaining multiple versions
of documents with one source.
DOCTOR contains DOCTOR mode, a psychiatrist.
DRAW offers functions for editing pictures made of
characters. These partially duplicate the
facilities of the PICTURE library, but contain
other distinct features.
FIXLIB has functions for examining and patching EMACS
functions.
FORTRAN implements FORTRAN mode. See the file INFO;
EFORTRAN.
HAZ1510 redefines commands to be convenient on Hazeltine
1510 terminals.
IBM370 implements IBM370 mode, for editing 370 assembler
code.
INFO peruses tree-structured documentation files.
IVORY is EAK and ECC's alternate generator for EMACS
libraries, which uses a slightly nonstandard
input format. The libraries BABYL, BABYLM,
CACHE, FIXLIB, IVORY, MKDUMP, OUTLINE-MODE, PL1,
TEACH-C100, TMACS and WORDAB are generated with
IVORY. See the file INFO;IVORY.
JOURNAL implements journal files. See section 24.4
[Journals], page 164.
JUSTIFY implements an auto-justfy mode similar to auto
fill mode.
LABELS has functions for arranging a file of addresses
for printing mailing labels.
LEDIT is the EMACS side of the EMACS-to-MacLisp
interface. See the file INFO;LEDIT.î 236 EMACS Manual for ITS Users
LISPT is the EMACS side of another EMACS-to-MacLisp
interface. See the file INFO;LISPT.
LSPUTL contains a couple of useful functions for
searching and manipulating Lisp code.
LUNAR is Moon's personal library, which contains some
useful commands.
MACCNV does part of the work of converting MACRO-10 code
to MIDAS code.
MAZLIB is a game for solving mazes. It's fun to play.
MKDUMP aids in dumping your own customized environment.
See the file INFO;MKDUMP.
MODE2 implements a second additional mode line with
additional information.
MODLIN implements a fancier mode line display.
MOVE provides commands specially for copying and
moving many pieces of text from one file to
another.
MQREPL works with TAGS to perform several Query Replaces
on each of the files in a tag table.
NEWS is for reading the latest AP or New York Times
news summary.
NCOLUMNS has functions for turning single-column text into
many columns, but not vice-versa.
NOVICE implements restricted subsets of EMACS, for
beginners. The beginner can turn commands back
on when he feels ready. See the file INFO;CONV,
node Novice.
OUTLINE implements Outline Mode, for editing outlines.
PAGE defines commands for viewing only one page of the
file at a time. See section 18.1 [PAGE],
page 96.
PASCAL implements PASCAL mode. See the file INFO;EPASC.
PERSONAL has functions for keeping notes on your current
projects.î 237 EMACS Manual for ITS Users
PHRASE has commands for moving over and killing phrases
of text.
PICTURE contains Edit Picture, the command for editing
text pictures. See section 26 [PICTURE],
page 183.
PURIFY generates libraries from EMACS source files, and
contains other functions useful for editing the
source files. See the file INFO;CONV.
QSEND sends a message to another logged-in user, like
:QSEND.
RENUM renumbers figures, equations, theorems or
chapters.
RMAIL is for reading, editing and sending mail. See
the file INFO;RMAIL.
RUNOFF is for text-justified documents divided into
separate source files. It rejustifies the files
which have changed, then runs :@ to print only
the pages which have changed.
SAIL implements SAIL mode.
SCHEME implements SCHEME mode.
SCRLIN contains alternative definitions of C-N and C-P
which move by screen lines instead of by real
lines.
SLOWLY redefines commands and options to suit slow
terminals.
SORT implements the sorting commands.
SPLIT contains the commands Split File and Unsplit File
for breaking up large files into subfiles small
enough to be edited. See section 24.2 [Split],
page 160.
TDEBUG is a debugger for TECO programs. It displays the
buffer in one window and the program in the
other, while stepping by lines or setting
breakpoints. See the file INFO;TDEBUG.
TIME causes the current time of day to be displayed in
the mode line.î 238 EMACS Manual for ITS Users
TMACS contains miscellaneous useful functions
VT100 defines the arrow keys and numeric keypad of the
VT-100 terminal to move the cursor and supply
numeric arguments.
VT52 defines the numeric keypad of the VT-52 terminal
to supply numeric arguments.
XLISP contains functions for global stylistic
transformations of Lisp code. See section 20.6
[Lisp], page 110.
Automatically Loaded Librariesî Automatically Loaded Librariesî Automatically Loaded Libraries
These are libraries which the user need not know about to use.
AUX implements several commands described in the
manual as part of the standard EMACS. Loaded
automatically when needed.
BABYLM contains the part of Babyl that implements mail
sending.
BARE contains the definitions of all built-in
functions. These definitions are not needed for
executing the built-in functions, only so that
Help can describe them properly. Loaded
automatically by documentation commands when
needed. See section 5.2 [BARE], page 24.
DIRED implements the commands for editing and listing
directories. Loaded automatically when needed.
See section 13.6 [DIRED], page 76.
EINIT is used in building and dumping EMACS. See the
file INFO;CONV.
EMACS is the main body of standard EMACS. Always
loaded.
GRIND implements C-M-G. Loaded automatically when
needed. See section 20.7 [Grinding], page 115.
KBDMAC implements keyboard macros. Loaded automaticallyî 239 EMACS Manual for ITS Users
when needed. See section 22.8 [Keyboard Macros],
page 152.
MUDDLE implements Muddle mode.
PL1 implements PL1 mode. See the file INFO;EPL1.
SCRIBE implements SCRIBE mode. See section 11.8
[SCRIBE], page 61. Loaded automatically when
needed.
TAGS implements the TAGS package. See section 21
[TAGS], page 122. Loaded automatically when
needed.
TEX implements TEX mode. See the file INFO;ETEX.
Loaded automatically when needed.
WORDAB implements Word Abbrev mode. Loaded
automatically when needed. See section 25
[WORDAB], page 172.î 240 EMACS Manual for ITS Users
INDEX OF VARIABLESî INDEX OF VARIABLESî INDEX OF VARIABLES
An option is a variable whose value Edit Options offers for
editing. A hook variable is a variable which is normally not
defined, but which you can define if you wish for customization.
Most hook variables require TECO programs as their values.
The default value of the variable is given in parentheses after
its name. If no value is given, the default value is zero. If
the word "nonexistent" appears, then the variable does not exist
unless you create it.
Abort Resumption Message
This is the message to be printed by C-] to tell
you how to resume the aborted command. If this
variable is zero, there is no way to resume, so
C-] asks for confirmation. See section 24.1
[Quitting], page 159.
Additional Abbrev Expanders (nonexistent)
If this variable exists when Word Abbrev mode is
turned on, it is a string of characters which
should terminate and expand an abbrev, in
addition to the punctuation characters which
normally do so. See also WORDAB Ins Chars.
After Compilation Hook (nonexistent)
If this variable exists and is nonzero, then it
is executed as a TECO expression by the function
Compile, after compilation itself is finished.
Exception: If the variable Compile Command is
also nonzero, it overrides this hook. See
section 20.2 [Compile], page 103.
Atom Word Mode The minor mode Atom Word mode is on if this
variable is nonzero. See section 22.1 [Minor
Modes], page 133.
Auto Directory Display
If this is nonzero, certain file operations
automatically display the file directory. See
section 13.4 [Directories], page 75.
Auto Fill Mode The minor mode Auto Fill mode is on if this
variable is nonzero. See section 11.4 [Filling],
page 56.î 241 EMACS Manual for ITS Users
Auto Push Point Notification
The value of this variable is the string printed
in the echo area by some commands to notify you
that the mark has been set to the old location of
point. See section 10 [Search], page 46.
Auto Push Point Option (500)
Searches set the mark if they move at least this
many characters. See section 10 [Search],
page 46.
Auto Save All Buffers
If this is nonzero, auto save saves all buffers
that are modified, not just the selected buffer.
See section 13.3 [Auto Save], page 72.
Auto Save Default
The minor mode Auto Save mode is on by default
for newly visited files if this variable is
nonzero. See section 13.3 [Auto Save], page 72.
Auto Save Filenames (DSK:<working directory>;_SAV00 >)
These are the filenames used for auto saving if
the visited filenames are not used. If the last
two characters of the first filename are "00", as
they are by default, then they are replaced by
the last two characters of the buffer number to
get the filename actually used for saving. See
section 13.3 [Auto Save], page 72.
Auto Save Interval (500)
This is the number of characters between auto
saves. See section 13.3 [Auto Save], page 72.
Auto Save Max (2)
This is the maximum number of auto saves to keep.
See section 13.3 [Auto Save], page 72.
Auto Save Mode If this is nonzero, Auto Save mode is enabled.
See section 13.3 [Auto Save], page 72.
Auto Save Visited File
If this is nonzero, auto saving saves as the
visited filenames. If this is zero, auto saving
saves as the names which are the value of Auto
Save Filenames (q.v.). See section 13.3 [Auto
Save], page 72.
Autoarg Mode When Autoarg Mode is nonzero, numeric argumentsî 242 EMACS Manual for ITS Users
can be specified just by typing the digits. See
section 4 [Arguments], page 19.
Bottom Display Margin
This controls the size of the region at the
bottom of the screen which the cursor is not
allowed to be in. If the cursor would normally
move there, the window is recentered instead.
The value is represented as a percentage of the
screen size, and must not be negative or more
than 99. It controls the TECO flag FS %BOTTOM$.
See section 15 [Display], page 87.
Buffer Creation Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed whenever
a newly created buffer is selected for the first
time. See section 14 [Buffers], page 83.
Buffer Deselection Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed whenever
a buffer is about to be deselected. The
difference between this and Buffer Selection Hook
is that, while both are executed (if they exist)
when you switch buffers, this is executed before
the switch, and Buffer Selection Hook is executed
after the switch. See section 14 [Buffers],
page 83.
Buffer Selection Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed whenever
a buffer is selected. See section 14 [Buffers],
page 83.
Case Replace (1)
When Case Replace is nonzero, Replace String and
Query Replace attempt to preserve case when they
replace. See section 19 [Replace], page 98.
Case Search (1)
If Case Search is nonzero, searches of all sorts
allow upper case letters and lower case letters
to match each other. It controls the TECO flag
FS BOTH CASE$. See section 10 [Search], page 46.
Collapse in Comparison (nonexistent)
If this variable exists and is not zero, itî 243 EMACS Manual for ITS Users
should be a string of characters for M-X Compare
Windows to regard as insignificant. See
section 16 [Windows], page 90.
Comment Begin This is the string used to start new comments.
If it is zero, the value of Comment Start is
used. See section 20.5 [Comments], page 107.
Comment Column This is the column at which comments are aligned.
See section 20.5 [Comments], page 107.
Comment End This is the string which is used to end comments.
It is often empty for languages in which comments
end at the end of the line. See section 20.5
[Comments], page 107.
Comment Multi Line (nonexistent)
If this variable exists and is nonzero, then when
Auto Fill mode breaks a comment line, it does not
insert a new comment starter on the new line.
This is for use with languages that have explicit
comment terminators, if you want single
multi-line comments instead of single-line
comments on consecutive lines. See section 20.5
[Comments], page 107.
Comment Rounding (/8+1*8)
This is the TECO program used to decide what
column to start a comment in when the text of the
line goes past the comment column. The argument
to the program is the column at which text ends.
See section 20.5 [Comments], page 107.
Comment Start This is the string used for recognizing existing
comments, and for starting new ones if Comment
Begin is zero. If Comment Start is zero,
semicolon is used. See section 20.5 [Comments],
page 107.
Compile Command (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be used by the M-X
Compile command to compile the file. See
section 20.2 [Compile], page 103.
Compiler Filename (nonexistent)
If this variable exists and is nonzero, its value
should be the name of the compiler to use,
suitable for a colon command. By default, theî 244 EMACS Manual for ITS Users
name of the major mode is used as the name of the
compiler. See section 20.2 [Compile], page 103.
Compiler Switches (nonexistent)
If this variable exists and is nonzero, its value
is used as switches for compilation. See
section 20.2 [Compile], page 103.
Cursor Centering Point (40)
This specifies how far from the top of the screen
point ought to appear when a new window position
is chosen. The value of the variable is the
percentage of the screen size. It must not be
negative or more than 99. It controls the TECO
flag FS %CENTER$. See section 15 [Display],
page 87.
Default Major Mode (Fundamental)
This is the major mode in which new buffers are
created. If it is the null string, new buffers
are created in the same mode as the previously
selected buffer. See section 14 [Buffers],
page 83.
Digit Shift Table (nonexistent)
If this variable exists and is nonzero, its value
should be a string containing the ten characters
which are the upper case equivalents of the
digits 0 through 9 on the keyboard being used.
Meta-' (^R Upcase Digit) uses this table, and
reads it from the user if the variable does not
exist. See section 12 [Fixing Typos], page 65.
Directory Lister (& Subset Directory Listing)
This is the TECO program used for listing a
directory for C-X C-D and the Auto Directory
Display option. The default value is the
definition of the function & Subset Directory
Listing. Another useful value is the definition
of the function & Rotated Directory Listing. See
section 13.4 [Directories], page 75.
Display Matching Paren (-1)
This variable controls automatic display of the
matching open parenthesis when a close
parenthesis is inserted. See section 20.4
[Matching], page 105.
Display Mode Line Inverse î 245 EMACS Manual for ITS Users
If this is nonzero, the mode line is displayed in
inverse video or otherwise highlighted, on
terminals which can support it. This controls
the TECO flag FS INVMOD$. See section 1.1 [Mode
Line], page 6.
Display Overprinting
If this is nonzero, backspace characters and
stray carriage return characters in the buffer
display as actual overprinting rather than as ^H
and ^M. This variable controls the TECO flags FS
^H PRINT$ and FS ^M PRINT$. See section 2
[Characters], page 10.
Echo Area Height (3)
This is the number of lines in the echo area.
Its value should be at least one. It controls
the TECO flag FS ECHO LINES$. See section 1
[Screen], page 5.
EMACS Version This variable's value is the EMACS version
number.
End of Buffer Display Margin (35)
This specifies how far up the screen the end of
the buffer is placed, if it is on screen at all,
when a new window position is chosen. It is
represented as a percentage of the screen size,
and must not be negative or more than 99. Its
value controls the TECO flag FS %END$. See
section 15 [Display], page 87.
Error Messages in Echo Area
If this is nonzero, error messages are printed in
the echo area instead of at the top of the
screen. It controls the TECO flag FS ECHO
ERRORS$. See section 24.2 [Lossage], page 160.
Exit Hook (nonexistent)
If this variable exists and is nonzero, its value
is a TECO program to be executed whenever EMACS
is exited, instead of the normal action of doing
an auto save. The subroutine & Exit EMACS is
responsible for executing it. See section 6.4
[Exiting], page 31.
Exit to Superior Hook (nonexistent)
If this variable exists and is nonzero, its value
is a TECO program to be executed whenever EMACSî 246 EMACS Manual for ITS Users
is about to return to its superior job, in
addition to all normal actions.
Fill Column (70)
The value of Fill Column is the width used for
filling text. It controls the TECO flag FS
ADLINE$. See section 11.4 [Filling], page 56.
Fill Extra Space List (.?!)
The characters in this string are the ones which
ought to be followed by two spaces when text is
filled. See section 11.4 [Filling], page 56.
Fill Prefix The value of this variable is the prefix expected
on every line of text before filling and placed
at the front of every line after filling. It is
usually empty, for filling nonindented text. See
section 11.4 [Filling], page 56.
Indent Tabs Mode (-1)
If Indent Tabs Mode is nonzero, then tab
characters are used by the indent commands.
Otherwise, only spaces are used. See
section 11.3 [Indenting Text], page 54.
<libname> Setup Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed when the
library <libname> is loaded. The library's
& Setup function is responsible for doing this.
If the library has no & Setup function, it will
not handle a setup hook either. See section 22.2
[Libraries], page 135.
<libname> Kill Hook (nonexistent)
Some libraries may execute the value of this
variable, if it exists and is nonzero, when the
library is being removed from core with Kill
Libraries. This is done by the library's & Kill
function; if the library has no & Kill <libname>
Library function, it will not handle a kill hook.
See section 22.2 [Libraries], page 135.
Lisp <function> Indent
This variable controls the indentation within
calls to the function <function>. Actually, the
variable used is not always Lisp <function>
Indent, but rather <language> <function> Indent,
where <language> is the value of Lisp Indentî 247 EMACS Manual for ITS Users
Language. See section 20.3 [Indenting],
page 104.
Lisp Indent DEFanything (1)
The value of this variable controls indentation
within calls to functions whose names start with
"def". Actually, the variable used is not always
Lisp Indent DEFanything, but rather <language>
Indent DEFanything, where <language> is the value
of Lisp Indent Language. See section 20.3
[Indenting], page 104.
Lisp Indent Language (Lisp)
The value of this variable is the string used as
the language name when looking for <language>
<function> Indent variables. See section 20.3
[Indenting], page 104.
Lisp Indent Offset
If nonzero, this selects an alternative default
style of indentation for Lisp. Actually, the
variable used is not always Lisp Indent Offset,
but rather <language> Indent Offset, where
<language> is the value of Lisp Indent Language.
See section 20.3 [Indenting], page 104.
Mail Reader Library (nonexistent)
If this variable exists and is nonzero, it is the
name of the library to be used by M-X Read Mail
for reading mail and by M-X Send Mail for sending
mail. The former calls the function "<entry>" in
the library, and the latter calls the function
"& Mail Message". If the variable does not
exist, the library RMAIL is used. See
section 6.2 [Mail], page 29.
Mail Sender Library (nonexistent)
If this variable exists and is nonzero, it
specifies the library to be used by M-X Send Mail
only, overriding Mail Reader Library. See
section 6.2 [Mail], page 29.
<mode> ..D (nonexistent)
This variable is used by the major mode <mode> to
record the syntax table for that mode. It is
created by the first use of the mode, and if you
supply your value, that value will be accepted
instead. For example, Text mode uses Text ..D.
Not all major modes have their own syntax tables.
See section 22.4 [Syntax], page 139.î 248 EMACS Manual for ITS Users
<mode> Mode Hook (nonexistent)
If this variable exists and is nonzero, its value
is a TECO program to be executed when the major
mode <mode> is entered. For example, Text Mode
Hook is executed when Text mode is entered. See
section 20.1 [Major Modes], page 102.
Next Screen Context Lines (nonexistent)
If this variable exists, its value specifies the
number of lines of overlap between one screenful
and the next, when scrolling by screens with C-V
and M-V. See section 15 [Display], page 87.
Only Global Abbrevs (nonexistent)
If this variable exists and its value is nonzero,
then Word Abbrev Mode assumes that you are not
using any mode-specific abbrevs. See
section 25.2.1 [Customizing WORDAB], page 178.
Overwrite Mode If this is nonzero, the minor mode Overwrite mode
is in effect. It controls the TECO flag FS ^R
REPLACE$. See section 22.1 [Minor Modes],
page 133.
^î Page Delimiter (|L)
This is the TECO search string used to recognize
page boundaries. See section 18 [Pages],
page 94.
PAGE Flush CRLF
If this variable exists and is nonzero, the PAGE
library expects every page to start with a blank
line, which is not considered part of the
contents of the page. See section 18.1 [PAGE],
page 96.
^ ^ ^ ^î Paragraph Delimiter (.|O|I|O |O')
This is the TECO search string used to recognize
beginnings of paragraphs. See section 11.2
[Sentences], page 52.
Permit Unmatched Paren (-1)
Controls whether the bell is run if you insert an
unmatched close parenthesis. See section 20.4
[Matching], page 105.
Prefix Char List
This variable's value is a string which lists all
the prefix characters defined, so thatî 249 EMACS Manual for ITS Users
self-documentation facilities can find any
subcommands of prefix characters which call a
given function. See the file INFO;CONV, node
Prefix.
Quote Execute Command (nonexistent)
If this variable exists and is zero, then M-X
^î does not quote |] characters which appear in the
string arguments of the command. See section 5.2
[Extended Commands], page 24.
Read Line Delay
This is the amount of time, in 30'ths of a
second, which EMACS should wait after starting to
read a line of input, before it prompts and
starts echoing the input.
Readable Word Abbrev Files (nonexistent)
If this variable exists and is nonzero, word
abbrev files will be written in the format that
M-X List Word Abbrevs uses, instead of in a less
readable but faster loading format. See
section 25.1.6 [Saving Abbrevs], page 176.
Region Query Size (5000)
Many commands which act on the region require
confirmation if the region contains more than
this many characters. See section 8 [Mark],
page 36.
Return from Superior Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed whenever
EMACS is resumed after being exited. See
section 6.4 [Exiting], page 31.
SAIL Character Mode
If this is nonzero, characters in the buffer with
ASCII codes 0 through 37 are displayed without
conversion. Do not try to use this feature
except on terminals specially equipped to handle
it. The variable controls the TECO flag FS
SAIL$. See section I.1 [Ideal Keyboards],
page 186.
Save Word Abbrevs (nonexistent)
If this variable exists, its value determines
which abbrevs will be saved upon exit from EMACS
when abbrevs have been modified. Setting it to 1î 250 EMACS Manual for ITS Users
causes all abbrevs to be saved. See
section 25.1.6 [Saving Abbrevs], page 176.
Setting it to -1 causes just the incremental
abbrevs to be saved. See section 25.2.4 [Dumped
Environments], page 180.
Search Exit Char (27)
This is the numeric code for the 9-bit character
which should exit incremental search and not have
its normal command meaning in that case. The
default, 27, is the code for Altmode.
Search Exit Option (nonexistent)
If this variable is 0, Control and Meta
characters without special meanings do not exit
incrementatl search; instead, they are part of
the string to be searched for. If this variable
does not exist, or is nonzero, then those
characters exit the search and then have their
normal function.
Set Mode Line Hook
This is a hook which is executed every time the
mode line is recomputed. It can insert text in
the buffer to put it in the mode line after the
minor modes. See section 1.1 [Mode Line],
page 6.
SLOWLY Maximum Speed (nonexistent)
If this variable is defined, it is the maximum
output speed for which SLOWLY, if loaded, should
define its commands. See section I.5.4 [SLOWLY],
page 192.
Space Indent Flag
If this flag is nonzero, then Auto Fill indents
the new lines which it creates, by performing a
Tab. Most major modes for programming languages
set this nonzero. See section 11.4 [Filling],
page 56.
Tab Stop Definitions (a string)
The value of Tab Stop Definitions is a string
defining the tab stops to be used by the command
M-I (^R Tab to Tab Stop). See section 11.3
[Indenting Text], page 54.
Tags Find File (nonexistent)
If this variable exists and is not zero, TAGSî 251 EMACS Manual for ITS Users
uses C-X C-F to switch files. Otherwise, TAGS
uses C-X C-V. See section 21 [TAGS], page 122.
Some other things may decide to use multiple
buffers if this variable is nonzero. See
section 14 [Buffers], page 83.
Tags Search Verbose (nonexistent)
If this variable exists and is zero, Tags Search
does not print out the name of each file that it
begins to search. If the variable is
nonexistent, that is equivalent to a value of 1.
See section 21.4.3 [Tags Search], page 127.
^ ^î Temp File FN2 List (MEMO|OXGP|O ...)
This is a TECO search string which recognizes the
filenames which indicate that the file is
probably temporary. See section 13.5 [Clean
Directory], page 75.
Top Display Margin
This controls the size of the region at the top
of the screen which the cursor is not allowed to
be in. If the cursor would normally move there,
the window is recentered instead. The value is
represented as a percentage of the screen size,
and must not be negative or more than 99. It
controls the TECO flag FS %TOP$. See section 15
[Display], page 87.
Underline Begin (nonexistent)
If this variable exists, its value should be the
character or string to use to begin underlines
for the M-_ command. See section 11.7
[Underlining], page 60.
Underline End (nonexistent)
If this variable exists, its value should be the
character or string to use to end underlines for
the M-_ command. See section 11.7 [Underlining],
page 60.
Visit File Hook (nonexistent)
If this variable exists and is nonzero, its value
should be a TECO program to be executed whenever
a file is visited. See section 13.1 [Visiting],
page 69.
Visit File Save Old (1)
This variable controls whether visiting a fileî 252 EMACS Manual for ITS Users
offers to save the file previously visited in the
same buffer, if it has changes. See section 13.1
[Visiting], page 69.
WORDAB All Caps (nonexistent)
If this variable exists and is nonzero, expanding
an all-upper-case abbrev to a multi-word
expansion will cause the words in the expansion
to be all-upper-case, instead of just having
their first letters uppercased. See
section 25.1.2 [Controlling Expansion], page 175.
WORDAB Ins Chars (nonexistent)
If this variable exists when Word Abbrev Mode is
turned on, it should be a string containing
precisely those characters which should terminate
and expand an abbrev. This variable overrides
Additional Abbrev Expanders (q.v.). See
section 25.2.1 [Customizing WORDAB], page 178.î 253 EMACS Manual for ITS Users
INDEXî INDEXî INDEX
133, 134, 150
! 15, 99 Auto Push Point Notification 38
Auto Push Point Option 38
% 67 Auto Save All Buffers 74
Auto Save Default 72, 133
& (in function names) 26 Auto Save Filenames 73
& Alter ..D 142 Auto Save Interval 74
& Exit EMACS 32 Auto Save Max 74
& Mail Message 29 Auto Save mode 7, 72, 133
Auto Save Visited File 73
*Permutation Table* (buffer)Autoarg mode 20, 188
185 Autoloading 136
*Permuted File* (buffer) 185
*Tags Search* (buffer) 127 Backspace 13
*TAGS* (buffer) 124, 126 BARE library 27
Bit prefix characters 188
--MORE-- 8 Blank lines 18, 40, 53, 108,
110
. 99 BOLIO 59
Bottom Display Margin 87
<cr> 11 Buffers 7, 83, 92, 124, 127,
150
@Begin 62 Buggestion 64
@End 62 Bugs 168
Built-in functions 27
Abbrev definition files 176,
180 C- 10
Abbrev definition lists 173,C-. 127
176, 179, 180 C-; 107
Abbrevs 172 C-< 37
Abort Recursive Edit 137, 159 C-> 37
Aborting 159 C-@ 36
Accumulator 119 C-A 16, 52, 105
Additional Abbrev Expanders 179C-B 16, 101
Address 119 C-C 11, 157
Altmode 11, 13, 14, 22, 99,C-C C-Y 158
100, 141, 154, 157 C-D 16, 22, 39
Append to File 44, 79 C-E 16, 52, 105
Apropos 34 C-F 16
Argument 174, 180 C-G 22, 31, 47, 69, 157, 159,
ASCII 10, 13 164
Atom Word mode 7, 51, 133 C-K 16, 39, 52
Auto Directory Display 75 C-L 16, 87, 154, 194
Auto Fill 110 C-M-( 112
Auto Fill mode 7, 54, 56, 108,C-M-) 112î 254 EMACS Manual for ITS Users
C-M-; 108 C-X . 57
C-M-@ 37, 112 C-X 1 90
C-M-A 114, 119 C-X 145, 150
C-M-B 62, 111 C-X 2 90
C-M-C 31, 76, 137 C-X 3 91
C-M-D 62, 112, 119 C-X 4 92
C-M-E 62, 114, 119 C-X ; 109
C-M-F 62, 111 C-X = 58
C-M-G 62, 116, 120 C-X A 44
C-M-H 37, 62, 114 C-X Altmode 24, 99, 157
C-M-K 39, 62, 112 C-X B 83
C-M-L 94 C-X C-A 174, 178, 181
C-M-M 54, 105 C-X C-B 85
C-M-N 62, 112, 119 C-X C-C 31, 176
C-M-P 62, 112, 119 C-X C-D 75
C-M-Q 62, 116 C-X C-F 84
C-M-R 89 C-X C-H 174, 181
C-M-Rubout 39, 62, 112 C-X C-L 59
C-M-Space 175, 181 C-X C-O 18, 40
C-M-T 112 C-X C-P 37, 94, 96
C-M-Tab 115 C-X C-Q 70
C-M-U 62, 112 C-X C-S 17, 70, 74, 85
C-M-V 91 C-X C-T 66
C-M-W 42 C-X C-U 36, 59
C-M-X 23 C-X C-V 17, 69
C-M-[ 114 C-X C-W 74
C-M-\ 55, 116 C-X C-X 37
C-M-] 114 C-X D 79
C-M-^ 105, 115 C-X E 153
C-N 16, 101 C-X F 57, 133
C-O 18, 19, 101, 105 C-X G 45
C-P 16 C-X H 37
C-Q 15, 54, 94, 101, 175, 180 C-X J 97
C-R 46, 96, 99, 154, 191 C-X K 85
C-Rubout 110 C-X L 95
C-S 46, 96, 191 C-X M 29
C-Space 36 C-X N 93
C-T 16, 66 C-X O 90
C-U 19, 22, 69, 180 C-X P 93, 95, 97
C-U C-@ 38, 53 C-X Q 154, 191
C-U C-Space 38 C-X R 29
C-V 88 C-X Rubout 39, 52, 65
C-W 39, 53, 94, 99 C-X T 66
C-X 11, 101 C-X Tab 55
C-X # 60 C-X U 181
C-X ( 153 C-X W 93, 95, 96
C-X ) 153 C-X X 45
C-X + 174, 178, 181 C-X [ 94, 96
C-X - 174, 178, 181 C-X ] 94, 96î 255 EMACS Manual for ITS Users
C-X ^ 91, 158 CRLF 13, 15
C-X _ 61 Cursor 5, 15
C-Y 41 Cursor Centering Point 87
C-\ 157 Customization 12, 26, 116, 143,
C-] 76, 100, 137, 141, 159 150, 178
C-^ 11
C-_ 33 Default Major Mode 83
Capitalization 175 Default Separator 192
Caret 13 Define Word Abbrevs 179
Case conversion 58, 66, 98,Defining abbrevs 174, 176
172, 189 Defuns 37, 114
Case Replace 98 Delete File 80
Case Search 47, 98 Delete Matching Lines 100
Centering 57 Delete Non-Matching Lines 79,
Character Search 48 100
Character set 10 Deletion 15, 39, 65, 100, 163
Clean Directory 76 Describe 33, 138
Clear screen 87 Digit Shift Table 66
Collapse in Comparison 91 Directory 75, 79, 81
Comma 99 Directory Lister 75
Command completion 22, 26 DIRED 76, 136
Commands 21 Disasters 72
Comment Begin 109, 140 Display Matching Paren 106
Comment Column 109, 151 Display Mode Line Inverse 8
Comment End 109, 140 Display Overprinting 13
Comment Start 109, 140, 151 Dissociated Press 63
Comments 50, 97, 102, 107, 110,Documentation 35
111, 119, 140 Dollar Sign 14
Compare Directories 81 Down Picture Movement 183
Compare Windows 91 Drastic Changes 72
Compile 103 Dumped environments 180
Compile Command 104
Compiler Filename 104 Echo area 5, 22, 58, 94, 174
Compiler Switches 104 Echo Area Height 5
Confirmation 59, 71, 72, 77,Edit Indented Text 54
157, 174 Edit key 187, 188
Connected 12, 26 Edit Options 30, 137
Continuation line 15 Edit Picture 30, 183
Control 10, 13, 165 Edit Syntax Table 141
Control characters, display ofEdit Tab Stops 50, 55
13 Edit Word Abbrevs 176
Control characters, insertingEditor Type 6
15 End of Buffer Display Margin 87
Control-Meta 111 Environments 61
Copy File 80 Error handler 5
Correct Spelling 67 Error message 5
Count Matching Lines 100 Error Messages in Echo Area 160
Crashes 72 Escape key 186
Create File 70 EVARS 134, 143, 150î 256 EMACS Manual for ITS Users
EVARS files 177, 178 Insertion 15, 79, 94
Exit Hook 32 Instant Command Prompt 23
Exit to Superior Hook 32 INTER 110
Exiting 31
Exiting EMACS 176, 181 Join pages 97
Expand Word Abbrevs in RegionJournal files 164
175 Justification 57
Expander characters 179
Expanding abbrevs 175 Keyboard macros 7, 152
Extended commands 21 Kill All Word Abbrevs 178
Kill Buffer 85
FAIL 118 Kill Libraries 136, 161
File dates 71 Kill ring 41, 161
File deletion 75, 76 Kill Some Buffers 85, 161
File directory 75 Killing 39, 41, 51, 52, 65,
File Versions Kept 76 112, 163
Files 7, 17, 69, 72, 79, 92,Killing abbrevs 174, 176, 178
150
Fill Column 57, 133, 137 Labels 119
Fill Prefix 53, 57 LEDIT 6, 110
Filling 56 Left Picture Movement 183
Find File 84, 124 Libraries 96, 135, 172, 183
Find Pat 113 Line noise 34
FLUSHED 8 Line separator 13, 15
Fonts 59 Linefeed 13, 54, 102, 105, 115
Formatting 54, 115 Linefeed, stray 13
Formfeed 94 Lines 39, 185
FS Flags 55, 87, 107, 120, 142,Lisp 104, 133
170, 190 Lisp FOO Indent 117
Functions 12, 21, 26 Lisp Indent DEFAnything 116
Lisp Indent Language 118
Global abbrevs 172, 178 Lisp Indent Offset 117
Grinding 115 Lisp Indentation Hook 117
Lisp mode 110
Help 11, 33, 166 Lisp PROG Indent 117
Home Directory 144, 164 Lisp Special Indent Offset 116
Hooks 181 List Buffers 85
List Directories 75
Ignoriginal 64 List Files 75
Incremental abbrev definitionList Library 136
files 180 List Loaded Libraries 136
Indent Tabs Mode 55, 134 List Matching Lines 100
Indentation 54, 104, 107, 115 List Redefinitions 103, 138
Init file 188 List Tags 127
Init files 143, 177, 178 List Variables 138
Insert Buffer 185 List Word Abbrevs 176, 179, 180
Insert File 79 Lists 37, 111, 140
Insert Page Directory 97 Load Library 135
Insert Word Abbrevs 179, 180 Loading 135î 257 EMACS Manual for ITS Users
Local modes lists 134 M-W 42
Local variables 83, 138, 139,M-X 21, 24
150 M-Y 43
Lowercase Lisp Buffer 113 M-[ 53, 62, 119
Lowercase Lisp Region 113 M-\ 40, 54, 105
LSPUTL 113 M-] 53, 119
M-^ 40, 54, 105, 115
M- 10 M-_ 60
M-" 120 M-~ 71
M-# 59 M.L 138
M-$ 67 Macro-10 118
M-% 100, 157 Macsyma 116
M-' 66, 120, 175, 181 Macsyma mode 120
M-( 112 Mail 29
M-) 112 Mail Reader Library 29
M-- M-C 66 Mail Sender Library 29
M-- M-L 66 MAILT 6
M-- M-U 66 Major modes 7, 83, 102, 103,
M-. 124 109, 141, 150, 172
M-; 107 Make Page Permutation Table 185
M-< 16 Make Space 161
M-> 16 Make These Characters Expand
M-@ 37, 51 179
M-A 52 Make Word Abbrev 178
M-Altmode 156 Mark 36, 41, 42, 51, 53, 80,
M-B 50 94, 112, 114, 124
M-C 58 Markov Chain 64
M-D 39, 51 Matching 105, 140
M-E 52 Meta 10, 50, 165, 186, 187, 188
M-F 50 Metizer 11, 157, 188
M-G 57 MIDAS 104, 118
M-H 37, 53, 57 MIDAS mode 118
M-I 55 Minibuffer 6, 15, 24, 31, 79,
M-J 108 87, 100, 156, 170
M-K 39, 52 Minibuffer Separator 192
M-L 58 Minor modes 7, 55, 133, 172
M-Linefeed 108 MM 24, 45
M-M 54, 105 MM Commands 21
M-N 108 Mode abbrevs 172, 178
M-O 191 Mode line 6, 30, 83, 96, 103,
M-P 108 133, 156
M-Q 57 Motion 50, 52, 94, 111, 114
M-R 89 Moving text 41
M-Rubout 39, 51, 65 MQREPL 127
M-S 57 Muddle mode 110
M-T 51
M-Tab 54 Name Kbd Macro 153
M-U 58 Narrowing 58, 93, 95, 98
M-V 88 Next File 126î 258 EMACS Manual for ITS Users
Next Screen Context Lines 88 Reap File 76
Numeric argument 174, 180 Recursive editing level 6, 30,
Numeric arguments 19, 23, 25, 76, 85, 141, 159, 165,
41, 43, 51, 55, 56, 59, 176
61, 72, 75, 88, 91, 92,Redefining abbrevs 174
98, 108, 116, 133, 137,Redefining commands 144, 150
158, 187, 188 Region 36, 41, 42, 53, 59, 60,
61, 80, 93, 94, 114,
Only Global Abbrevs 178 116, 174, 185
Options 137 Region Query Size 59
Outragedy 64 Rename Buffer 85
Overprinting 13 Rename File 80
Overwrite mode 7, 134 Replace String 98
Replacement 98, 100
PAGE 96 Replay Journal File 164
Page Delimiter 53, 95 Restarting 162
PAGE Flush CRLF 97 Return 11, 13, 15, 69
Pages 37, 53, 94, 96, 185 Return from Superior Hook 32
Paragraph Delimiter 53, 120 Return, stray 13
Paragraphs 37, 52, 57, 62, 110,Revert File 72, 74
119, 185 Right Picture Movement 183
Parentheses 50, 105, 140 RMAIL 6, 29
Permit Unmatched Paren 106 Rubout 11, 13, 15, 16, 22, 39,
Permute Pages From Table 185 65, 99, 102, 110, 134,
Pictures 183 154
Point 5, 15 Run Library 136
Prefix characters 11, 145, 150
Prepend to File 44, 79 S-expressions 111, 140
Preventing abbrev expansion 175SAIL Character Mode 134, 186
Printing characters 15 SAIL characters 186
Printing terminal 194 Save All Files 85
Prompting 5, 22 Save Word Abbrevs 176, 181
PURIFY library 120 Saving 69, 72
Saving abbrevs 176
Q-registers 45 Screen 5, 87
Query Replace 68, 99, 154, 157 SCRIBE 61
Quit 164 Scrolling 87, 88, 91
Quitting 47, 159 Search Exit Char 47
Quote Execute Command 25 Search Exit Option 47
Quoting 15, 180 Searching 46, 96, 98
Select Buffer 83
R 59, 60 Send Mail 29
Read Command Prompt 22 Sentences 52, 65
Read Incremental Word Abbrev FileSet Key 26, 178
180 Set Variable 137
Read Mail 29 Set Visited Filename 70, 80
Read Word Abbrev File 176, 180 Short Display Size 191
Read-Only Visiting 70 Slow Search Lines 191
Readable Word Abbrev Files 177 Slow Search Separator 192î 259 EMACS Manual for ITS Users
SLOWLY Maximum Speed 192 Text mode 50, 106
Sort Lines 185 Text Mode Hook 106
Sort Pages 185 TJ6 59
Sort Paragraphs 185 TMACS 29
Sorting 185 Toggling 133
Space 11, 13, 22, 56, 67, 99,Top Display Margin 87
154 Top level 6, 159, 162
Space Indent Flag 54 Transposition 51, 66, 112
Spell Program 67 Two window mode 90
SPLIT 162 Type Mailing List 29
Split File 162 Typeout 5
Split pages 97 Typos 65, 66
SRCCOM 71, 78
Start Journal File 164 Underline Begin 61
String arguments 23, 25, 75,Underline End 61
137 Underlining 60
String Search 48 Undo 41, 59, 72, 161, 163
Submode 7 Unexpanding abbrevs 175
Subroutines 26 Unsplit File 162
Subsystem 6 Untabify 56
Syntax table 50, 51, 106, 110,Up Picture Movement 183
114, 139 Uparrow 13
Uppercase Lisp Buffer 113
Tab 13, 50, 54, 102, 104, 110,Uppercase Lisp Region 113
115 URK 85, 161
Tab Stop Definitions 55 User Name 144
Tabify 56
Tag Table Filenames 125 Variables 13, 137, 144
TAGGEN 123 View Arglist 128
TAGS 84, 92, 136 View Buffer 88
Tags Apropos 127 View Directory 75
Tags File List 128 View File 79, 89
TAGS Find File 84, 124, 127 View Kbd Macro 154
Tags Query Replace 127 View Mail 29
Tags Rescan 128 View Page Directory 97
Tags Search 127 Visit File 81
TCTYP 161 Visit File Save Old 70
Techniquitous 64 Visit Tag Table 123
TECO 22, 24, 27, 45, 53, 58,Visiting 17, 69, 72, 84, 92
80, 87, 101, 104, 106,
118, 136, 138, 142,W2 90
144, 152, 162, 190 What Available Space 162
TECO default filenames 80 What Cursor Position 58
TECO mode 120 What Page 94
TECO search string 127 What Tag? 128
TECO search strings 76, 98, 101Windows 90
Temp File FN2 List 76 Word Abbrev Hook 181
Terminal type 161 Word abbrev mode 7, 134, 172,
Text justifiers 59, 60 173, 178î 260 EMACS Manual for ITS Users
Word Search 48 ^R Beginning of Line 16
WORDAB 172 ^R Buffer Not Modified 71
WORDAB All Caps 175 ^R Center Line 57
WORDAB DEFNS 176 ^R Change Environment Name 62
WORDAB Ins Chars 179 ^R Change Font Region 60
WORDAB Setup Hook 181 ^R Change Font Word 59
Words 37, 50, 58, 59, 60, 65,^R Change Form 62
66, 139 ^R Commands 21
Write File 74, 79 ^R Copy Region 42
Write Incremental Word Abbrev^R Correct Word Spelling 67
File 180 ^R Count Lines Page 95
Write Kbd Macro 154 ^R CRLF 15
Write Word Abbrev File 176, 180^R Delete Blank Lines 18, 40
^R Delete Character 39
XLISP 113 ^R Delete Horizontal Space 40,
54, 105
^ 13, 99 ^R Delete Indentation 40, 54,
^R (in function names) 12 105, 115
^R Abbrev Expand Only 175 ^R Directory Display 75
^R Add Global Word Abbrev 174,^R DIRED 79
178 ^R Down Comment Line 108
^R Add Mode Word Abbrev 174,^R Down Environment 62
178 ^R Down List 112
^R Add Tag 125 ^R Down Real Line 16
^R Append Next Kill 42 ^R Edit Quietly 191
^R Append to Buffer 44 ^R End Kbd Macro 153
^R Back to Indentation 54 ^R End of Defun 114
^R Backward Character 16 ^R End of Environment 62
^R Backward Delete Character^R End of Line 16
15, 39, 65, 110 ^R Exchange Point and Mark 37
^R Backward Delete Hacking Tabs^R Execute Kbd Macro 153
110 ^R Execute Minibuffer 156
^R Backward Environment 62 ^R Exit 31, 137
^R Backward Kill Sentence 39,^R Extract Sublist 113
52, 65 ^R Fill Paragraph 57
^R Backward Kill Sexp 39, 112 ^R Fill Region 57
^R Backward Kill Word 39, 51,^R Format Code 116
65 ^R Forward Character 16
^R Backward List 112 ^R Forward Environment 62
^R Backward Paragraph 53, 119 ^R Forward List 112
^R Backward SCRIBE Paragraph 62^R Forward Paragraph 53, 119
^R Backward Sentence 52 ^R Forward Sentence 52
^R Backward Sexp 111 ^R Forward Sexp 111
^R Backward TECO Conditional^R Forward TECO Conditional 120
120 ^R Forward Up List 112
^R Backward Up Environment 62 ^R Forward Word 50
^R Backward Up List 112 ^R Get Q-reg 45
^R Backward Word 50 ^R Go to AC Field 119
^R Beginning of Defun 114 ^R Go to Address Field 119î 261 EMACS Manual for ITS Users
^R Go to Next Label 119 ^R Narrow Bounds to Page 93, 95
^R Go to Previous Label 119 ^R Narrow Bounds to Region 93
^R Goto Beginning 16 ^R New Window 16, 87, 194
^R Goto End 16 ^R Next Page 94
^R Goto Next Page 96 ^R Next Screen 88
^R Goto Page 96 ^R One Window 90
^R Goto Previous Page 96 ^R Open Line 18, 19
^R Grow Window 91, 158 ^R Other Window 90
^R Incremental Search 46, 96 ^R PAGE Widen Bounds 96
^R Indent for Comment 107 ^R Prefix Control 11
^R Indent for Lisp 110, 115 ^R Prefix Control-Meta 11
^R Indent Nested 120 ^R Prefix Meta 11
^R Indent New Comment Line 108 ^R Previous Page 94
^R Indent New Line 54, 102,^R Previous Screen 88
105, 115 ^R Put Q-reg 45
^R Indent Region 55, 116 ^R Query Replace 100, 157
^R Indent Rigidly 55 ^R Quoted Insert 15
^R Indent Sexp 116 ^R Re-execute Minibuffer 24,
^R Insert () 112 99, 157
^R Insert Pagemark 97 ^R Reposition Window 89
^R Instant Extended Command 23 ^R Return to Superior 31
^R Inverse Add Global Word Abbrev^R Reverse Search 46, 96
174, 178 ^R Save File 17, 70, 85
^R Inverse Add Mode Word Abbrev^R Scroll Other Window 91
174, 178 ^R Set Comment Column 109
^R Join Next Page 97 ^R Set File Read-Only 70
^R Kbd Macro Query 154 ^R Set Fill Column 57, 133
^R Kill Comment 108 ^R Set Fill Prefix 57
^R Kill Global Word Abbrev 178 ^R Set Screen Size 191
^R Kill Line 39 ^R Set/Pop Mark 36
^R Kill Mode Word Abbrev 178 ^R Slow Display I-Search 191
^R Kill Region 39 ^R Slow Reverse Display I-search
^R Kill Sentence 39, 52 191
^R Kill Sexp 39, 112 ^R Start Kbd Macro 153
^R Kill Terminated Word 119 ^R Tab to Tab Stop 50, 55
^R Kill Word 39, 51 ^R Transpose Characters 16, 66
^R Lowercase Region 59 ^R Transpose Lines 66
^R Lowercase Word 58, 66 ^R Transpose Regions 66
^R Mark Beginning 37 ^R Transpose Sexps 112
^R Mark Defun 37, 114 ^R Transpose Words 51
^R Mark End 37 ^R Two Windows 90
^R Mark Environment 62 ^R Un-kill 41
^R Mark Page 37, 94 ^R Un-kill Pop 43
^R Mark Paragraph 37, 53 ^R Underline Region 61
^R Mark Sexp 37, 112 ^R Underline Word 60
^R Mark Whole Buffer 37 ^R Universal Argument 19
^R Mark Word 37, 51 ^R Up Comment Line 108
^R Move Over ) 112 ^R Up Real Line 16
^R Move to Screen Edge 89 ^R Upcase Digit 66î 262 EMACS Manual for ITS Users
^R Uppercase Initial 58, 66
^R Uppercase Region 36, 59
^R Uppercase Word 58, 66
^R View Two Windows 91
^R Visit File 17, 69
^R Visit in Other Window 92
^R Widen Bounds 93, 95
^R Word Abbrev Prefix Mark 175î i EMACS Manual for ITS Users
TABLE OF CONTENTSî TABLE OF CONTENTSî TABLE OF CONTENTS
Introductionî Introductionî Introduction 3
1. The Organization of the Screenî 1. The Organization of the Screenî 1. The Organization of the Screen 5
1.1 The Mode Line 6
2. Character Sets and Command Input Conventionsî 2. Character Sets and Command Input Conventionsî 2. Character Sets and Command Input Conventions 10
2.1 The 9-bit Command Character Set 10
2.2 Prefix Characters 11
2.3 Commands, Functions, and Variables 12
2.4 Notational Conventions for ASCII Characters 13
3. Basic Editing Commandsî 3. Basic Editing Commandsî 3. Basic Editing Commands 15
3.1 Inserting Text 15
3.2 Moving The Cursor 16
3.3 Erasing Text 16
3.4 Files 17
3.5 Help 17
3.6 Using Blank Lines Can Make Editing Faster 18
4. Giving Numeric Arguments to EMACS Commandsî 4. Giving Numeric Arguments to EMACS Commandsî 4. Giving Numeric Arguments to EMACS Commands 19
4.1 Autoarg Mode 20
5. Extended (Meta-X) Commands and Functionsî 5. Extended (Meta-X) Commands and Functionsî 5. Extended (Meta-X) Commands and Functions 21
5.1 Issuing Extended Commands 21
5.2 Arcane Information about M-X Commands 24
6. Moving Up And Down Levelsî 6. Moving Up And Down Levelsî 6. Moving Up And Down Levels 28
6.1 Subsystems 28
6.2 Reading Mail 29
6.3 Recursive Editing Levels 30
6.4 Exiting Levels; Exiting EMACS 31î ii EMACS Manual for ITS Users
7. Self-Documentation Commandsî 7. Self-Documentation Commandsî 7. Self-Documentation Commands 33
8. The Mark and the Regionî 8. The Mark and the Regionî 8. The Mark and the Region 36
8.1 Commands to Mark Textual Objects 37
8.2 The Ring of Marks 38
9. Killing and Moving Textî 9. Killing and Moving Textî 9. Killing and Moving Text 39
9.1 Deletion and Killing 39
9.2 Un-Killing 41
9.3 Other Ways of Copying Text 44
10. Searchingî 10. Searchingî 10. Searching 46
11. Commands for English Textî 11. Commands for English Textî 11. Commands for English Text 50
11.1 Word Commands 50
11.2 Sentence and Paragraph Commands 52
11.3 Indentation Commands for Text 54
11.4 Text Filling 56
11.5 Case Conversion Commands 58
11.6 Font-Changing 59
11.7 Underlining 60
11.8 SCRIBE Mode 61
11.9 Dissociated Press 63
12. Commands for Fixing Typosî 12. Commands for Fixing Typosî 12. Commands for Fixing Typos 65
12.1 Killing Your Mistakes 65
12.2 Transposition 66
12.3 Case Conversion 66
12.4 Checking and Correcting Spelling 67
13. File Handlingî 13. File Handlingî 13. File Handling 69
13.1 Visiting Files 69
13.2 How to Undo Drastic Changes to a File 72
13.3 Auto Save Mode: Protection Against Disasters 72
13.4 Listing a File Directory 75
13.5 Cleaning a File Directory 75î iii EMACS Manual for ITS Users
13.6 DIRED, the Directory Editor Subsystem 76
13.7 Miscellaneous File Operations 79
13.8 The Directory Comparison Subsystem 81
14. Using Multiple Buffersî 14. Using Multiple Buffersî 14. Using Multiple Buffers 83
14.1 Creating and Selecting Buffers 83
14.2 Using Existing Buffers 85
14.3 Killing Buffers 85
15. Controlling the Displayî 15. Controlling the Displayî 15. Controlling the Display 87
16. Two Window Modeî 16. Two Window Modeî 16. Two Window Mode 90
16.1 Multiple Windows and Multiple Buffers 92
17. Narrowingî 17. Narrowingî 17. Narrowing 93
18. Commands for Manipulating Pagesî 18. Commands for Manipulating Pagesî 18. Commands for Manipulating Pages 94
18.1 Editing Only One Page at a Time 96
19. Replacement Commandsî 19. Replacement Commandsî 19. Replacement Commands 98
19.1 Query Replace 99
19.2 Other Search-and-loop Functions 100
19.3 TECO Search Strings 101
20. Editing Programsî 20. Editing Programsî 20. Editing Programs 102
20.1 Major Modes 102
20.2 Compiling Your Program 103
20.3 Indentation Commands for Code 104
20.4 Automatic Display Of Matching Parentheses 105
20.5 Manipulating Comments 107
20.6 Lisp Mode and Muddle Mode 110
20.7 Lisp Grinding 115
20.8 Editing Assembly-Language Programs 118
20.9 Major Modes for Other Languages 120î iv EMACS Manual for ITS Users
21. The TAGS Package.î 21. The TAGS Package.î 21. The TAGS Package. 122
21.1 How to Make a Tag Table for a Program 122
21.2 How to Tell EMACS You Want to Use TAGS 123
21.3 Jumping to a Tag 124
21.4 Other Operations on Tag Tables 125
21.5 What Constitutes a Tag 128
21.6 Adding or Removing Source Files 129
21.7 How a Tag Is Described in the Tag Table 130
21.8 Tag Tables for INFO Structured Documentation Files 131
22. Simple Customizationî 22. Simple Customizationî 22. Simple Customization 133
22.1 Minor Modes 133
22.2 Libraries of Commands 135
22.3 Variables 137
22.4 The Syntax Table 139
22.5 FS Flags 142
22.6 Init Files and EVARS Files 143
22.7 Local Variables in Files 150
22.8 Keyboard Macros 152
23. The Minibufferî 23. The Minibufferî 23. The Minibuffer 156
24. Correcting Mistakes and EMACS Problemsî 24. Correcting Mistakes and EMACS Problemsî 24. Correcting Mistakes and EMACS Problems 159
24.1 Quitting and Aborting 159
24.2 Dealing with Common Forms of EMACS Lossage 160
24.3 Undoing Changes to the Buffer 163
24.4 Journal Files 164
24.5 Reporting Bugs 168
25. Word Abbreviation Inputî 25. Word Abbreviation Inputî 25. Word Abbreviation Input 172
25.1 Basic Usage 173
25.2 Advanced Usage 177
25.3 Teco Details for Extension Writers 181
26. The PICTURE Subsystem, an Editor for Text Picturesî 26. The PICTURE Subsystem, an Editor for Text Picturesî 26. The PICTURE Subsystem, an Editor for Text Pictures 183
27. Sorting Functionsî 27. Sorting Functionsî 27. Sorting Functions 185î v EMACS Manual for ITS Users
Appendix I. Particular Types of Terminalsî Appendix I. Particular Types of Terminalsî Appendix I. Particular Types of Terminals 186
I.1 Ideal Keyboards 186
I.2 Keyboards with an "Edit" key 187
I.3 ASCII Keyboards 188
I.4 Upper-case-only Terminals 189
I.5 The SLOWLY Package for Slow Terminals 190
Appendix II. Use of EMACS from Printing Terminalsî Appendix II. Use of EMACS from Printing Terminalsî Appendix II. Use of EMACS from Printing Terminals 194
Glossaryî Glossaryî Glossary 196
Command Summaryî Command Summaryî Command Summary 208
Catalog of Librariesî Catalog of Librariesî Catalog of Libraries 234
Index of Variablesî Index of Variablesî Index of Variables 240
Indexî Indexî Index 253î
Reference in New Issue View Git Blame Copy Permalink