GNU Emacs Manual

Emacs is the extensible, customizable, self-documenting real-time display editor. This Info file describes how to edit with Emacs and some of how to customize it; it corresponds to GNU Emacs version 21.2. For information on extending Emacs, see section `Top' in The Emacs Lisp Reference Manual.

Distribution		How to get the latest Emacs distribution.
GNU GENERAL PUBLIC LICENSE		The GNU General Public License gives you permission to redistribute GNU Emacs on certain terms; it also explains that there is no warranty.
A. GNU Free Documentation License		The license for this documentation.
Introduction		An introduction to Emacs concepts.
Glossary		The glossary.
AF. Emacs 20 Antinews		Information about Emacs version 20.
AG. Emacs and the Mac OS		Using Emacs in the Mac.
AH. Emacs and MS-DOS		Using Emacs on MS-DOS (otherwise known as "MS-DOG").
The GNU Manifesto		What's GNU? Gnu's Not Unix!
AI. Acknowledgments		Major contributors to GNU Emacs.

Indexes (nodes containing large menus)

Key (Character) Index		An item for each standard Emacs key sequence.
Command and Function Index		An item for each command name.
Variable Index		An item for each documented variable.
Concept Index		An item for each concept.
Command-Line Options Index		An item for every command-line option.

Important General Concepts

B. The Organization of the Screen		How to interpret what you see on the screen.
B.5 Kinds of User Input		Kinds of input events (characters, buttons, function keys).
B.6 Keys		Key sequences: what you type to request one editing action.
B.7 Keys and Commands		Named functions run by key sequences to do editing.
B.8 Character Set for Text		Character set for text (the contents of buffers and strings).
C. Entering and Exiting Emacs		Starting Emacs from the shell.
C.1 Exiting Emacs		Stopping or killing Emacs.
AE. Command Line Arguments		Hairy startup options.

Fundamental Editing Commands

D. Basic Editing Commands		The most basic editing commands.
E. The Minibuffer		Entering arguments that are prompted for.
F. Running Commands by Name		Invoking commands by their names.
G. Help		Commands for asking Emacs about its commands.

Important Text-Changing Commands

H. The Mark and the Region		The mark: how to delimit a "region" of text.
H.7 Deletion and Killing		Killing text.
H.8 Yanking		Recovering killed text. Moving text.
H.9 Accumulating Text		Other ways of copying text.
H.10 Rectangles		Operating on the text inside a rectangle on the screen.
I. Registers		Saving a text string or a location in the buffer.
J. Controlling the Display		Controlling what text is displayed.
K. Searching and Replacement		Finding or replacing occurrences of a string.
L. Commands for Fixing Typos		Commands especially useful for fixing typos.

Major Structures of Emacs

M. File Handling		All about handling files.
N. Using Multiple Buffers		Multiple buffers; editing several files at once.
O. Multiple Windows		Viewing two pieces of text at once.
P. Frames and X Windows		Running the same Emacs session in multiple X windows.
Q. International Character Set Support		Using non-ASCII character sets (the MULE features).

Advanced Features

R. Major Modes		Text mode vs. Lisp mode vs. C mode ...
S. Indentation		Editing the white space at the beginnings of lines.
T. Commands for Human Languages		Commands and modes for editing English.
U. Editing Programs		Commands and modes for editing programs.
V. Compiling and Testing Programs		Compiling, running and debugging programs.
W. Maintaining Programs		Features for maintaining large programs.
X. Abbrevs		How to define text abbreviations to reduce the number of characters you must type.
Y. Editing Pictures		Editing pictures made up of characters using the quarter-plane screen model.
Z. Sending Mail		Sending mail in Emacs.
AA. Reading Mail with Rmail		Reading mail in Emacs.
AB. Dired, the Directory Editor		You can "edit" a directory to manage files in it.
AC. The Calendar and the Diary		The calendar and diary facilities.
AC.14 Gnus		How to read netnews with Emacs.
AC.15 Running Shell Commands from Emacs		Executing shell commands from Emacs.
AC.16 Using Emacs as a Server		Using Emacs as an editing server for mail, etc.
AC.18 Hardcopy Output		Printing buffers or regions.
AC.19 PostScript Hardcopy		Printing buffers or regions as PostScript.
AC.20 Variables for PostScript Hardcopy		Customizing the PostScript printing commands.
AC.21 Sorting Text		Sorting lines, paragraphs or pages within Emacs.
AC.22 Narrowing		Restricting display and editing to a portion of the buffer.
AC.23 Two-Column Editing		Splitting apart columns to edit them in side-by-side windows.
AC.24 Editing Binary Files		Using Hexl mode to edit binary files.
AC.25 Saving Emacs Sessions		Saving Emacs state from one session to the next.
AC.26 Recursive Editing Levels		A command can allow you to do editing

  "within the command".  This is called a
  "recursive editing level".

AC.27 Emulation		Emulating some other editors with Emacs.
AC.28 Hyperlinking and Navigation Features		Following links in buffers.
AC.29 Dissociated Press		Dissociating text for fun.
AC.30 Other Amusements		Various games and hacks.
AD. Customization		Modifying the behavior of Emacs.

Recovery from Problems

AD.8 Quitting and Aborting		Quitting and aborting.
AD.9 Dealing with Emacs Trouble		What to do if Emacs is hung or malfunctioning.
AD.10 Reporting Bugs		How and when to report a bug.
AD.11 Contributing to Emacs Development		How to contribute improvements to Emacs.
AD.12 How To Get Help with GNU Emacs		How to get help for your own Emacs needs.

Here are some other nodes which are really inferiors of the ones
already listed, mentioned here so you can get to them in one step:

 -- The Detailed Node Listing ---

The Organization of the Screen

B.1 Point		The place in the text where editing commands operate.
B.2 The Echo Area		Short messages appear at the bottom of the screen.
B.3 The Mode Line		Interpreting the mode line.
B.4 The Menu Bar		How to use the menu bar.

Basic Editing Commands

D.1 Inserting Text		Inserting text by simply typing it.
D.2 Changing the Location of Point		How to move the cursor to the place where you want to change something.
D.3 Erasing Text		Deleting and killing text.
D.4 Undoing Changes		Undoing recent changes in the text.
D.5 Files		Visiting, creating, and saving files.
D.6 Help		Asking what a character does.
D.7 Blank Lines		Commands to make or delete blank lines.
D.8 Continuation Lines		Lines too wide for the screen.
D.9 Cursor Position Information		What page, line, row, or column is point on?
D.10 Numeric Arguments		Numeric arguments for repeating a command.

The Minibuffer

E.1 Minibuffers for File Names		Entering file names with the minibuffer.
E.2 Editing in the Minibuffer		How to edit in the minibuffer.
E.3 Completion		An abbreviation facility for minibuffer input.
E.4 Minibuffer History		Reusing recent minibuffer arguments.
E.5 Repeating Minibuffer Commands		Re-executing commands that used the minibuffer.

Help

G.1 Help Summary		Brief list of all Help commands.
G.2 Documentation for a Key		Asking what a key does in Emacs.
G.3 Help by Command or Variable Name		Asking about a command, variable or function name.
G.4 Apropos		Asking what pertains to a given topic.
G.5 Keyword Search for Lisp Libraries		Finding Lisp libraries by keywords (topics).
G.6 Help for International Language Support		Help relating to international language support.
G.8 Other Help Commands		Other help commands.

The Mark and the Region

H.1 Setting the Mark		Commands to set the mark.
H.2 Transient Mark Mode		How to make Emacs highlight the region-- when there is one.
H.3 Operating on the Region		Summary of ways to operate on contents of the region.
H.4 Commands to Mark Textual Objects		Commands to put region around textual units.
H.5 The Mark Ring		Previous mark positions saved so you can go back there.
H.6 The Global Mark Ring		Previous mark positions in various buffers.

Deletion and Killing

H.7.1 Deletion		Commands for deleting small amounts of text and blank areas.
H.7.2 Killing by Lines		How to kill entire lines of text at one time.
H.7.3 Other Kill Commands		Commands to kill large regions of text and syntactic units such as words and sentences.

Yanking

H.8.1 The Kill Ring		Where killed text is stored. Basic yanking.
H.8.2 Appending Kills		Several kills in a row all yank together.
H.8.3 Yanking Earlier Kills		Yanking something killed some time ago.

Registers

I.1 Saving Positions in Registers		Saving positions in registers.
I.2 Saving Text in Registers		Saving text in registers.
I.3 Saving Rectangles in Registers		Saving rectangles in registers.
I.4 Saving Window Configurations in Registers		Saving window configurations in registers.
I.6 Keeping File Names in Registers		File names in registers.
I.7 Bookmarks		Bookmarks are like registers, but persistent.

Controlling the Display

J.6 Scrolling		Moving text up and down in a window.
J.7 Horizontal Scrolling		Moving text left and right in a window.
J.8 Follow Mode		Follow mode lets two windows scroll as one.
J.9 Selective Display		Hiding lines with lots of indentation.
J.10 Optional Mode Line Features		Optional mode line display features.
J.11 How Text Is Displayed		How text is normally displayed.
J.12 Customization of Display		Information on variables for customizing display.

Searching and Replacement

K.1 Incremental Search		Search happens as you type the string.
K.2 Nonincremental Search		Specify entire string and then search.
K.3 Word Search		Search for sequence of words.
K.4 Regular Expression Search		Search for match for a regexp.
K.5 Syntax of Regular Expressions		Syntax of regular expressions.
K.6 Searching and Case		To ignore case while searching, or not.
K.7 Replacement Commands		Search, and replace some or all matches.
K.8 Other Search-and-Loop Commands		Operating on all matches for some regexp.

Replacement Commands

K.7.1 Unconditional Replacement		Replacing all matches for a string.
K.7.2 Regexp Replacement		Replacing all matches for a regexp.
K.7.3 Replace Commands and Case		How replacements preserve case of letters.
K.7.4 Query Replace		How to use querying.

Commands for Fixing Typos

L.1 Killing Your Mistakes		Commands to kill a batch of recently entered text.
L.2 Transposing Text		Exchanging two characters, words, lines, lists...
L.3 Case Conversion		Correcting case of last word entered.
L.4 Checking and Correcting Spelling		Apply spelling checker to a word or a whole buffer.

File Handling

M.1 File Names		How to type and edit file-name arguments.
M.2 Visiting Files		Visiting a file prepares Emacs to edit the file.
M.3 Saving Files		Saving makes your changes permanent.
M.4 Reverting a Buffer		Reverting cancels all the changes not saved.
M.5 Auto-Saving: Protection Against Disasters		Auto Save periodically protects against loss of data.
M.6 File Name Aliases		Handling multiple names for one file.
M.7 Version Control		Version control systems (RCS, CVS and SCCS).
M.8 File Directories		Creating, deleting, and listing file directories.
M.9 Comparing Files		Finding where two files differ.
M.10 Miscellaneous File Operations		Other things you can do on files.
M.11 Accessing Compressed Files		Accessing compressed files.
M.13 Remote Files		Accessing files on other sites.
M.14 Quoted File Names		Quoting special characters in file names.

Saving Files

M.3.1 Backup Files		How Emacs saves the old version of your file.
M.3.2 Protection against Simultaneous Editing		How Emacs protects against simultaneous editing of one file by two users.

Version Control

M.7.1 Introduction to Version Control		How version control works in general.
M.7.2 Version Control and the Mode Line		How the mode line shows version control status.
M.7.3 Basic Editing under Version Control		How to edit a file under version control.
M.7.4 Examining And Comparing Old Versions		Examining and comparing old versions.
M.7.5 The Secondary Commands of VC		The commands used a little less frequently.
M.7.6 Multiple Branches of a File		Multiple lines of development.
M.7.8 Snapshots		Sets of file versions treated as a unit.
M.7.9 Miscellaneous Commands and Features of VC		Various other commands and features of VC.
M.7.10 Customizing VC		Variables that change VC's behavior.

Using Multiple Buffers

N.1 Creating and Selecting Buffers		Creating a new buffer or reselecting an old one.
N.2 Listing Existing Buffers		Getting a list of buffers that exist.
N.3 Miscellaneous Buffer Operations		Renaming; changing read-onliness; copying text.
N.4 Killing Buffers		Killing buffers you no longer need.
N.5 Operating on Several Buffers		How to go through the list of all buffers and operate variously on several of them.
N.6 Indirect Buffers		An indirect buffer shares the text of another buffer.

Multiple Windows

O.1 Concepts of Emacs Windows		Introduction to Emacs windows.
O.2 Splitting Windows		New windows are made by splitting existing windows.
O.3 Using Other Windows		Moving to another window or doing something to it.
O.4 Displaying in Another Window		Finding a file or buffer in another window.
O.5 Forcing Display in the Same Window		Forcing certain buffers to appear in the selected window rather than in another window.
O.6 Deleting and Rearranging Windows		Deleting windows and changing their sizes.

Frames and X Windows

P.1 Mouse Commands for Editing		Moving, cutting, and pasting, with the mouse.
P.2 Secondary Selection		Cutting without altering point and mark.
P.3 Using the Clipboard		Using the clipboard for selections.
P.4 Following References with the Mouse		Using the mouse to select an item from a list.
P.5 Mouse Clicks for Menus		Mouse clicks that bring up menus.
P.6 Mode Line Mouse Commands		Mouse clicks on the mode line.
P.7 Creating Frames		Creating additional Emacs frames with various contents.
P.8 Frame Commands		Iconifying, deleting, and switching frames.
P.9 Making and Using a Speedbar Frame		How to make and use a speedbar frame.
P.10 Multiple Displays		How one Emacs job can talk to several displays.
P.11 Special Buffer Frames		You can make certain buffers have their own frames.
P.12 Setting Frame Parameters		Changing the colors and other modes of frames.
P.13 Scroll Bars		How to enable and disable scroll bars; how to use them.
P.14 Scrolling With "Wheeled" Mice		Using mouse wheels for scrolling.
P.15 Menu Bars		Enabling and disabling the menu bar.
P.16 Tool Bars		Enabling and disabling the tool bar.
P.17 Using Dialog Boxes		Controlling use of dialog boxes.
J.1 Using Multiple Typefaces		How to change the display style using faces.
J.2 Font Lock mode		Minor mode for syntactic highlighting using faces.
J.3 Highlight Changes Mode		Using colors to show where you changed the buffer.
J.4 Interactive Highlighting by Matching		Tell Emacs what text to highlight.
J.5 Trailing Whitespace		Showing possibly-spurious trailing whitespace.
P.18 Tooltips (or "Balloon Help")		Showing "tooltips", AKA "ballon help" for active text.
P.19 Mouse Avoidance		Moving the mouse pointer out of the way.
P.20 Non-Window Terminals		Multiple frames on terminals that show only one.
P.21 Using a Mouse in Terminal Emulators		Using the mouse in an XTerm terminal emulator.

International Character Set Support

Q.1 Introduction to International Character Sets		Basic concepts of multibyte characters.
Q.2 Enabling Multibyte Characters		Controlling whether to use multibyte characters.
Q.3 Language Environments		Setting things up for the language you use.
Q.4 Input Methods		Entering text characters not on your keyboard.
Q.5 Selecting an Input Method		Specifying your choice of input methods.
Q.7 Coding Systems		Character set conversion when you read and write files, and so on.
Q.8 Recognizing Coding Systems		How Emacs figures out which conversion to use.
Q.9 Specifying a Coding System		Various ways to choose which conversion to use.
Q.10 Fontsets		Fontsets are collections of fonts that cover the whole spectrum of characters.
Q.11 Defining fontsets		Defining a new fontset.
Q.13 Single-byte Character Set Support		You can pick one European character set to use without multibyte characters.

Major Modes

R.1 How Major Modes are Chosen

How major modes are specified or chosen.

Indentation

S.1 Indentation Commands and Techniques		Various commands and techniques for indentation.
S.2 Tab Stops		You can set arbitrary "tab stops" and then indent to the next tab stop when you want to.
S.3 Tabs vs. Spaces		You can request indentation using just spaces.

Commands for Human Languages

T.1 Words		Moving over and killing words.
T.2 Sentences		Moving over and killing sentences.
T.3 Paragraphs		Moving over paragraphs.
T.4 Pages		Moving over pages.
T.5 Filling Text		Filling or justifying text.
T.6 Case Conversion Commands		Changing the case of text.
T.7 Text Mode		The major modes for editing text files.
T.8 Outline Mode		Editing outlines.
T.9 TeX Mode		Editing input to the formatter TeX.
T.10 Nroff Mode		Editing input to the formatter nroff.
T.11 Editing Formatted Text		Editing formatted text directly in WYSIWYG fashion.

Filling Text

T.5.1 Auto Fill Mode		Auto Fill mode breaks long lines automatically.
T.5.3 Explicit Fill Commands		Commands to refill paragraphs and center lines.
T.5.4 The Fill Prefix		Filling paragraphs that are indented or in a comment, etc.
T.5.5 Adaptive Filling		How Emacs can determine the fill prefix automatically.

Editing Programs

U.1 Major Modes for Programming Languages		Major modes for editing programs.
U.2 Top-Level Definitions, or Defuns		Commands to operate on major top-level parts of a program.
U.3 Indentation for Programs		Adjusting indentation to show the nesting.
U.5 Manipulating Comments		Inserting, killing, and aligning comments.
U.4 Commands for Editing with Parentheses		Commands that operate on parentheses.
U.6 Documentation Lookup		Getting documentation of functions you plan to call.
U.7 Hideshow minor mode		Displaying blocks selectively.
U.8 Completion for Symbol Names		Completion on symbol names of your program or language.
U.9 Glasses minor mode		Making identifiersLikeThis more readable.
U.10 Other Features Useful for Editing Programs		Other Emacs features useful for editing programs.
U.11 C and Related Modes		Special commands of C, C++, Objective-C, Java, and Pike modes.
U.12 Fortran Mode		Fortran mode and its special features.
U.13 Asm Mode		Asm mode and its special features.

Top-Level Definitions, or Defuns

U.2.1 Left Margin Convention		An open-paren or similar opening delimiter starts a defun if it is at the left margin.
U.2.2 Moving by Defuns		Commands to move over or mark a major definition.
U.2.3 Imenu		Making buffer indexes as menus.
U.2.4 Which Function Mode		Which Function mode shows which function you are in.

Indentation for Programs

U.3.1 Basic Program Indentation Commands		Indenting a single line.
U.3.2 Indenting Several Lines		Commands to reindent many lines at once.
U.3.3 Customizing Lisp Indentation		Specifying how each Lisp function should be indented.
U.3.4 Commands for C Indentation		Extra features for indenting C and related modes.
U.3.5 Customizing C Indentation		Controlling indentation style for C and related modes.

Commands for Editing with Parentheses

U.4.1 Expressions with Balanced Parentheses		Expressions with balanced parentheses.
U.4.2 Moving in the Parenthesis Structure		Commands for moving up, down and across in the structure of parentheses.
U.4.3 Automatic Display Of Matching Parentheses		Insertion of a close-delimiter flashes matching open.

Manipulating Comments

U.5.1 Comment Commands		Inserting, killing, and indenting comments.
U.5.2 Multiple Lines of Comments		Commands for adding and editing multi-line comments.
U.5.3 Options Controlling Comments		Customizing the comment features.

Documentation Lookup

U.6.1 Info Documentation Lookup		Looking up library functions and commands in Info files.
U.6.2 Man Page Lookup		Looking up man pages of library functions and commands.
U.6.3 Emacs Lisp Documentation Lookup		Looking up Emacs Lisp functions, etc.

C and Related Modes

U.11.1 C Mode Motion Commands		Commands to move by C statements, etc.
U.11.2 Electric C Characters		Colon and other chars can automatically reindent.
U.11.3 Hungry Delete Feature in C		A more powerful DEL command.
U.11.4 Other Commands for C Mode		Filling comments, viewing expansion of macros, and other neat features.
U.11.5 Comments in C Modes		Options for customizing comment style.

Fortran Mode

U.12.1 Motion Commands		Moving point by statements or subprograms.
U.12.2 Fortran Indentation		Indentation commands for Fortran.
U.12.3 Fortran Comments		Inserting and aligning comments.
U.12.4 Fortran Auto Fill Mode		Auto fill minor mode for Fortran.
U.12.5 Checking Columns in Fortran		Measuring columns for valid Fortran.
U.12.6 Fortran Keyword Abbrevs		Built-in abbrevs for Fortran keywords.

Compiling and Testing Programs

V.1 Running Compilations under Emacs		Compiling programs in languages other than Lisp (C, Pascal, etc.).
V.3 Compilation Mode		The mode for visiting compiler errors.
V.4 Subshells for Compilation		Customizing your shell properly for use in the compilation buffer.
V.5 Running Debuggers Under Emacs		Running symbolic debuggers for non-Lisp programs.
V.6 Executing Lisp Expressions		Various modes for editing Lisp programs, with different facilities for running the Lisp programs.
V.7 Libraries of Lisp Code for Emacs		Creating Lisp programs to run in Emacs.
V.9 Lisp Interaction Buffers		Executing Lisp in an Emacs buffer.
V.8 Evaluating Emacs-Lisp Expressions		Executing a single Lisp expression in Emacs.
V.10 Running an External Lisp		Communicating through Emacs with a separate Lisp.

Running Debuggers Under Emacs

V.5.1 Starting GUD		How to start a debugger subprocess.
V.5.2 Debugger Operation		Connection between the debugger and source buffers.
V.5.3 Commands of GUD		Key bindings for common commands.
V.5.4 GUD Customization		Defining your own commands for GUD.

Maintaining Programs

W.1 Change Logs		Maintaining a change history for your program.
W.2 Tags Tables		Go direct to any function in your program in one command. Tags remembers which file it is in.
W.3 Merging Files with Emerge		A convenient way of merging two versions of a program.

Tags Tables

W.2.1 Source File Tag Syntax		Tag syntax for various types of code and text files.
W.2.2 Creating Tags Tables		Creating a tags table with etags.
W.2.4 Selecting a Tags Table		How to visit a tags table.
W.2.5 Finding a Tag		Commands to find the definition of a specific tag.
W.2.6 Searching and Replacing with Tags Tables		Using a tags table for searching and replacing.
W.2.7 Tags Table Inquiries		Listing and finding tags defined in a file.

Merging Files with Emerge

W.3.1 Overview of Emerge		How to start Emerge. Basic concepts.
W.3.2 Submodes of Emerge		Fast mode vs. Edit mode. Skip Prefers mode and Auto Advance mode.
W.3.3 State of a Difference		You do the merge by specifying state A or B for each difference.
W.3.4 Merge Commands		Commands for selecting a difference, changing states of differences, etc.
W.3.5 Exiting Emerge		What to do when you've finished the merge.
W.3.6 Combining the Two Versions		How to keep both alternatives for a difference.
W.3.7 Fine Points of Emerge		Misc.

Abbrevs

X.1 Abbrev Concepts		Fundamentals of defined abbrevs.
X.2 Defining Abbrevs		Defining an abbrev, so it will expand when typed.
X.3 Controlling Abbrev Expansion		Controlling expansion: prefixes, canceling expansion.
X.4 Examining and Editing Abbrevs		Viewing or editing the entire list of defined abbrevs.
X.5 Saving Abbrevs		Saving the entire list of abbrevs for another session.
X.6 Dynamic Abbrev Expansion		Abbreviations for words already in the buffer.

Editing Pictures

Y.1 Basic Editing in Picture Mode		Basic concepts and simple commands of Picture Mode.
Y.2 Controlling Motion after Insert		Controlling direction of cursor motion after "self-inserting" characters.
Y.3 Picture Mode Tabs		Various features for tab stops and indentation.
Y.4 Picture Mode Rectangle Commands		Clearing and superimposing rectangles.

Sending Mail

Z.1 The Format of the Mail Buffer		Format of the mail being composed.
Z.2 Mail Header Fields		Details of permitted mail header fields.
Z.3 Mail Aliases		Abbreviating and grouping mail addresses.
Z.4 Mail Mode		Special commands for editing mail being composed.
Z.5 Mail Amusements		Distract the NSA's attention; add a fortune to a msg.
Z.6 Mail-Composition Methods		Using alternative mail-composition methods.

Reading Mail with Rmail

AA.1 Basic Concepts of Rmail		Basic concepts of Rmail, and simple use.
AA.2 Scrolling Within a Message		Scrolling through a message.
AA.3 Moving Among Messages		Moving to another message.
AA.4 Deleting Messages		Deleting and expunging messages.
AA.5 Rmail Files and Inboxes		How mail gets into the Rmail file.
AA.6 Multiple Rmail Files		Using multiple Rmail files.
AA.7 Copying Messages Out to Files		Copying message out to files.
AA.8 Labels		Classifying messages by labeling them.
AA.9 Rmail Attributes		Certain standard labels, called attributes.
AA.10 Sending Replies		Sending replies to messages you are viewing.
AA.11 Summaries		Summaries show brief info on many messages.
AA.12 Sorting the Rmail File		Sorting messages in Rmail.
AA.13 Display of Messages		How Rmail displays a message; customization.
AA.15 Editing Within a Message		Editing message text and headers in Rmail.
AA.16 Digest Messages		Extracting the messages from a digest message.
AA.17 Converting an Rmail File to Inbox Format		Converting an Rmail file to mailbox format.
AA.18 Reading Rot13 Messages		Reading messages encoded in the rot13 code.
AA.19 movemail and POP		More details of fetching new mail.

Dired, the Directory Editor

AB.1 Entering Dired		How to invoke Dired.
AB.2 Navigation in the Dired Buffer		How to move in the Dired buffer.
AB.3 Deleting Files with Dired		Deleting files with Dired.
AB.4 Flagging Many Files at Once		Flagging files based on their names.
AB.5 Visiting Files in Dired		Other file operations through Dired.
AB.6 Dired Marks vs. Flags		Flagging for deletion vs marking.
AB.7 Operating on Files		How to copy, rename, print, compress, etc. either one file or several files.
AB.8 Shell Commands in Dired		Running a shell command on the marked files.
AB.9 Transforming File Names in Dired		Using patterns to rename multiple files.
AB.10 File Comparison with Dired		Running `diff' by way of Dired.
AB.11 Subdirectories in Dired		Adding subdirectories to the Dired buffer.
AB.12 Moving Over Subdirectories		Moving across subdirectories, and up and down.
AB.13 Hiding Subdirectories		Making subdirectories visible or invisible.
AB.14 Updating the Dired Buffer		Discarding lines for files of no interest.
AB.15 Dired and find		Using `find' to choose the files for Dired.

The Calendar and the Diary

AC.1 Movement in the Calendar		Moving through the calendar; selecting a date.
AC.2 Scrolling in the Calendar		Bringing earlier or later months onto the screen.
AC.3 Counting Days		How many days are there between two dates?
AC.4 Miscellaneous Calendar Commands		Exiting or recomputing the calendar.
AC.5 LaTeX Calendar		Print a calendar using LaTeX.
AC.6 Holidays		Displaying dates of holidays.
AC.7 Times of Sunrise and Sunset		Displaying local times of sunrise and sunset.
AC.8 Phases of the Moon		Displaying phases of the moon.
AC.9 Conversion To and From Other Calendars		Converting dates to other calendar systems.
AC.10 The Diary		Displaying events from your diary.
AC.11 Appointments		Reminders when it's time to do something.
AC.12 Daylight Savings Time		How to specify when daylight savings time is active.

Movement in the Calendar

AC.1.1 Motion by Standard Lengths of Time		Moving by days, weeks, months, and years.
AC.1.2 Beginning or End of Week, Month or Year		Moving to start/end of weeks, months, and years.
AC.1.3 Specified Dates		Moving to the current date or another specific date.

Conversion To and From Other Calendars

AC.9.1 Supported Calendar Systems

The calendars Emacs understands

     (aside from Gregorian).

AC.9.2 Converting To Other Calendars		Converting the selected date to various calendars.
AC.9.3 Converting From Other Calendars		Moving to a date specified in another calendar.
AC.9.4 Converting from the Mayan Calendar		Moving to a date specified in a Mayan calendar.

The Diary

AC.10.1 Commands Displaying Diary Entries		Viewing diary entries and associated calendar dates.
AC.10.2 The Diary File		Entering events in your diary.
AC.10.3 Date Formats		Various ways you can specify dates.
AC.10.4 Commands to Add to the Diary		Commands to create diary entries.
AC.10.5 Special Diary Entries		Anniversaries, blocks of dates, cyclic entries, etc.

GNUS

AC.14.1 Gnus Buffers		The group, summary, and article buffers.
AC.14.2 When Gnus Starts Up		What you should know about starting Gnus.
AC.14.3 Summary of Gnus Commands		A short description of the basic Gnus commands.

Running Shell Commands from Emacs

AC.15.1 Single Shell Commands		How to run one shell command and return.
AC.15.2 Interactive Inferior Shell		Permanent shell taking input via Emacs.
AC.15.3 Shell Mode		Special Emacs commands used with permanent shell.
AC.15.4 Shell Command History		Repeating previous commands in a shell buffer.
AC.15.6 Shell Mode Options		Options for customizing Shell mode.
AC.15.10 Remote Host Shell		Connecting to another computer.

Customization

AD.1 Minor Modes		Each minor mode is one feature you can turn on independently of any others.
AD.2 Variables		Many Emacs commands examine Emacs variables to decide what to do; by setting variables, you can control their functioning.
AD.3 Keyboard Macros		A keyboard macro records a sequence of keystrokes to be replayed with a single command.
AD.4 Customizing Key Bindings		The keymaps say what command each key runs. By changing them, you can "redefine keys".
AD.5 Keyboard Translations		If your keyboard passes an undesired code for a key, you can tell Emacs to substitute another code.
AD.6 The Syntax Table		The syntax table controls how words and expressions are parsed.
AD.7 The Init File, `~/.emacs'		How to write common customizations in the

  `.emacs' file. 

Variables

AD.2.1 Examining and Setting Variables		Examining or setting one variable's value.
AD.2.2 Easy Customization Interface		Convenient and easy customization of variables.
AD.2.3 Hooks		Hook variables let you specify programs for parts of Emacs to run on particular occasions.
AD.2.4 Local Variables		Per-buffer values of variables.
AD.2.5 Local Variables in Files		How files can specify variable values.

Keyboard Macros

AD.3.1 Basic Use		Defining and running keyboard macros.
AD.3.2 Naming and Saving Keyboard Macros		Giving keyboard macros names; saving them in files.
AD.3.3 Executing Macros with Variations		Making keyboard macros do different things each time.

Customizing Key Bindings

AD.4.1 Keymaps		Generalities. The global keymap.
AD.4.2 Prefix Keymaps		Keymaps for prefix keys.
AD.4.3 Local Keymaps		Major and minor modes have their own keymaps.
AD.4.4 Minibuffer Keymaps		The minibuffer uses its own local keymaps.
AD.4.5 Changing Key Bindings Interactively		How to redefine one key's meaning conveniently.
AD.4.6 Rebinding Keys in Your Init File		Rebinding keys with your init file, `.emacs'.
AD.4.7 Rebinding Function Keys		Rebinding terminal function keys.
AD.4.8 Named ASCII Control Characters		Distinguishing TAB from C-i, and so on.
AD.4.10 Rebinding Mouse Buttons		Rebinding mouse buttons in Emacs.
AD.4.11 Disabling Commands		Disabling a command means confirmation is required before it can be executed. This is done to protect beginners from surprises.

The Init File, `~/.emacs'

AD.7.1 Init File Syntax		Syntax of constants in Emacs Lisp.
AD.7.2 Init File Examples		How to do some things with an init file.
AD.7.3 Terminal-specific Initialization		Each terminal type can have an init file.
AD.7.4 How Emacs Finds Your Init File		How Emacs finds the init file.

Dealing with Emacs Trouble

AD.9.1 If DEL Fails to Delete		What to do if DEL doesn't delete.
AD.9.2 Recursive Editing Levels		`[...]' in mode line around the parentheses.
AD.9.3 Garbage on the Screen		Garbage on the screen.
AD.9.4 Garbage in the Text		Garbage in the text.
AD.9.5 Spontaneous Entry to Incremental Search		Spontaneous entry to incremental search.
AD.9.6 Running out of Memory		How to cope when you run out of memory.
AD.9.8 Emergency Escape		Emergency escape--- What to do if Emacs stops responding.
AD.9.9 Help for Total Frustration		When you are at your wits' end.

Reporting Bugs

AD.10.1 When Is There a Bug		Have you really found a bug?
AD.10.2 Understanding Bug Reporting		How to report a bug effectively.
AD.10.3 Checklist for Bug Reports		Steps to follow for a good bug report.
AD.10.4 Sending Patches for GNU Emacs		How to send a patch for GNU Emacs.

Command Line Options and Arguments

AE.1 Action Arguments		Arguments to visit files, load libraries, and call functions.
AE.2 Initial Options		Arguments that take effect while starting Emacs.
AE.3 Command Argument Example		Examples of using command line arguments.
AE.4 Resuming Emacs with Arguments		Specifying arguments when you resume a running Emacs.
AE.5 Environment Variables		Environment variables that Emacs uses.

AE.6 Specifying the Display Name		Changing the default display and using remote login.
AE.7 Font Specification Options		Choosing a font for text, under X.
AE.8 Window Color Options		Choosing colors, under X.
AE.9 Options for Window Geometry		Start-up window size, under X.
AE.10 Internal and External Borders		Internal and external borders, under X.
AE.11 Frame Titles		Specifying the initial frame's title.
AE.12 Icons		Choosing what sort of icon to use, under X.
AE.13 X Resources		Advanced use of classes and resources, under X.
AE.14 Lucid Menu X Resources		X resources for Lucid menus.
AE.15 LessTif Menu X Resources		X resources for LessTif and Motif menus.

Environment Variables

AE.5.1 General Variables		Environment variables that all versions of Emacs use.
AE.5.2 Miscellaneous Variables		Certain system specific variables.

MS-DOS and Windows 95/98/NT

AH.1 Keyboard and Mouse on MS-DOS		Keyboard and mouse usage on MS-DOS.
AH.2 Display on MS-DOS		Fonts, frames and display size on MS-DOS.
AH.3 File Names on MS-DOS		File-name conventions on MS-DOS.
AH.4 Text Files and Binary Files		Text files on MS-DOS use CRLF to separate lines.
AH.5 Printing and MS-DOS		How to specify the printer on MS-DOS.
AH.7 Subprocesses on MS-DOS		Running subprocesses on MS-DOS.
AH.8 Subprocesses on Windows 9X/ME and Windows NT/2K		Running subprocesses on Windows.
AH.9 Using the System Menu on Windows		Controlling what the ALT key does.

Distribution

GNU Emacs is free software; this means that everyone is free to use it and free to redistribute it on certain conditions. GNU Emacs is not in the public domain; it is copyrighted and there are restrictions on its distribution, but these restrictions are designed to permit everything that a good cooperating citizen would want to do. What is not allowed is to try to prevent others from further sharing any version of GNU Emacs that they might get from you. The precise conditions are found in the GNU General Public License that comes with Emacs and also appears following this section.

One way to get a copy of GNU Emacs is from someone else who has it. You need not ask for our permission to do so, or tell any one else; just copy it. If you have access to the Internet, you can get the latest distribution version of GNU Emacs by anonymous FTP; see the file `etc/FTP' in the Emacs distribution for more information.

You may also receive GNU Emacs when you buy a computer. Computer manufacturers are free to distribute copies on the same terms that apply to everyone else. These terms require them to give you the full sources, including whatever changes they may have made, and to permit you to redistribute the GNU Emacs received from them under the usual terms of the General Public License. In other words, the program must be free for you when you get it, not just free for the manufacturer.

You can also order copies of GNU Emacs from the Free Software Foundation on CD-ROM. This is a convenient and reliable way to get a copy; it is also a good way to help fund our work. (The Foundation has always received most of its funds in this way.) An order form is included in the file `etc/ORDERS' in the Emacs distribution, and on our web site in http://www.gnu.org/order/order.html. For further information, write to

Free Software Foundation 59 Temple Place, Suite 330 Boston, MA 02111-1307 USA USA

The income from distribution fees goes to support the foundation's purpose: the development of new free software, and improvements to our existing programs including GNU Emacs.

If you find GNU Emacs useful, please send a donation to the Free Software Foundation to support our work. Donations to the Free Software Foundation are tax deductible in the US. If you use GNU Emacs at your workplace, please suggest that the company make a donation. If company policy is unsympathetic to the idea of donating to charity, you might instead suggest ordering a CD-ROM from the Foundation occasionally, or subscribing to periodic updates.

GNU GENERAL PUBLIC LICENSE

Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.

When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.

We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.

Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and modification follow.

1. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program," below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification.") Each licensee is addressed as "you."

   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.

2. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.

   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.

3. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:
   1. You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.

   2. You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

   3. If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)

   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.

   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.

   In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.

4. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:
   1. Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

   2. Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,

   3. Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)

   The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.

   If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.

5. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

6. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.

7. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.

8. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.

   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.

   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.

   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.

9. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.

10. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.

    Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version," you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.

11. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.
    NO WARRANTY

12. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

13. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.

one line to give the program's name and an idea of what it does. Copyright (C) 19yy name of author This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 20yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. signature of Ty Coon, 1 April 1989 Ty Coon, President of Vice

This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License.

A. GNU Free Documentation License

Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

1. PREAMBLE

   The purpose of this License is to make a manual, textbook, or other written document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

   This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

   We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

2. APPLICABILITY AND DEFINITIONS

   This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you."

   A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

   A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

   The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License.

   The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License.

   A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not "Transparent" is called "Opaque."

   Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only.

   The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.

3. VERBATIM COPYING

   You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

   You may also lend copies, under the same conditions stated above, and you may publicly display copies.

4. COPYING IN QUANTITY

   If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

   If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

   If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

   It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

5. MODIFICATIONS

   You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

   A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
   B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five).
   C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
   D. Preserve all the copyright notices of the Document.
   E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
   F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
   G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.
   H. Include an unaltered copy of this License.
   I. Preserve the section entitled "History", and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
   J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
   K. In any section entitled "Acknowledgements" or "Dedications", preserve the section's title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
   L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
   M. Delete any section entitled "Endorsements." Such a section may not be included in the Modified Version.
   N. Do not retitle any existing section as "Endorsements" or to conflict in title with any Invariant Section.
   If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.

   You may add a section entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

   You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

   The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

6. COMBINING DOCUMENTS

   You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice.

   The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

   In the combination, you must combine any sections entitled "History" in the various original documents, forming one section entitled "History"; likewise combine any sections entitled "Acknowledgements", and any sections entitled "Dedications." You must delete all sections entitled "Endorsements."

7. COLLECTIONS OF DOCUMENTS

   You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

   You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

8. AGGREGATION WITH INDEPENDENT WORKS

   A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an "aggregate", and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document.

   If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate.

9. TRANSLATION

   Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail.

10. TERMINATION

    You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

11. FUTURE REVISIONS OF THIS LICENSE

    The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

    Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

ADDENDUM: How to use this License for your documents

To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:

Copyright (C) year your name. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being list their titles, with the Front-Cover Texts being list, and with the Back-Cover Texts being list. A copy of the license is included in the section entitled "GNU Free Documentation License."

If you have no Invariant Sections, write "with no Invariant Sections" instead of saying which ones are invariant. If you have no Front-Cover Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being list"; likewise for Back-Cover Texts.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.

Introduction

You are reading about GNU Emacs, the GNU incarnation of the advanced, self-documenting, customizable, extensible real-time display editor Emacs. (The `G' in `GNU' is not silent.)

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 Display.

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 Basic Editing.

We call Emacs advanced because it provides facilities that go beyond simple insertion and deletion: controlling subprocesses; automatic indentation of programs; viewing two or more files at once; editing formatted text; and dealing in terms of characters, words, lines, sentences, paragraphs, and pages, as well as expressions and comments in several different programming languages.

Self-documenting means that at any time you can type a special character, Control-h, 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 G. Help.

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 (see section U.5 Manipulating Comments). 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 rebind the keys that way. See section AD. Customization.

Extensible means that you can go beyond simple customization and write entirely new commands, programs in the Lisp language to be run by Emacs's own Lisp interpreter. 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. Almost any part of Emacs can be replaced without making a separate copy of all of Emacs. Most of the editing commands of Emacs are written in Lisp; the few exceptions could have been written in Lisp but are written in C for efficiency. Although only a programmer can write an extension, anybody can use it afterward. If you want to learn Emacs Lisp programming, we recommend the Introduction to Emacs Lisp by Robert J. Chassell, also published by the Free Software Foundation.

When run under the X Window System, Emacs provides its own menus and convenient bindings to mouse buttons. But Emacs can provide many of the benefits of a window system on a text-only terminal. For instance, you can look at or edit several files at once, move text between files, and edit files while running shell commands.

B. The Organization of the Screen

On a text-only terminal, the Emacs display occupies the whole screen. On the X Window System, Emacs creates its own X windows to use. We use the term frame to mean an entire text-only screen or an entire X window used by Emacs. Emacs uses both kinds of frames in the same way to display your editing. Emacs normally starts out with just one frame, but you can create additional frames if you wish. See section P. Frames and X Windows.

When you start Emacs, the entire frame except for the top and bottom is devoted to the text you are editing. This area is called the window. At the top there is normally a menu bar where you can access a series of menus; then there may be a tool bar, a row of icons that perform editing commands if you click on them. Below this, the window begins. The last line is a special echo area or minibuffer window, where prompts appear and where you can enter information when Emacs asks for it. See below for more information about these special lines.

You can subdivide the large text window horizontally or vertically into multiple text windows, each of which can be used for a different file (see section O. Multiple Windows). In this manual, the word "window" always refers to the subdivisions of a frame within Emacs.

The window that the cursor is in is the selected window, in which editing takes place. Most Emacs commands implicitly apply to the text in the selected window (though mouse commands generally operate on whatever window you click them in, whether selected or not). The other windows display text for reference only, unless/until you select them. If you use multiple frames under the X Window System, then giving the input focus to a particular frame selects a window in that frame.

Each window's last line is a mode line, which describes what is going on in that window. It appears in inverse video, if the terminal supports that; its contents normally begin with `--:-- *scratch*' when Emacs starts. The mode line displays status information such as what buffer is being displayed above it in the window, what major and minor modes are in use, and whether the buffer contains unsaved changes.

B.1 Point		The place in the text where editing commands operate.
B.2 The Echo Area		Short messages appear at the bottom of the screen.
B.3 The Mode Line		Interpreting the mode line.
B.4 The Menu Bar		How to use the menu bar.

B.1 Point

Within Emacs, the terminal's cursor shows the location at which editing commands will take effect. This location is called point. Many Emacs commands move point through the text, so that you can edit at different places in it. You can also place point by clicking mouse button 1.

While the cursor appears to point at a character, you should think of point as between two characters; it points before the character that appears under the cursor. For example, if your text looks like `frob' with the cursor over the `b', then point is between the `o' and the `b'. If you insert the character `!' at that position, the result is `fro!b', with point between the `!' and the `b'. Thus, the cursor remains over the `b', as before.

Sometimes people speak of "the cursor" when they mean "point," or speak of commands that move point as "cursor motion" commands.

Text-only terminals have only one cursor, and when output is in progress it must appear where the output is being displayed. 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.

If you are editing several files in Emacs, each in its own buffer, each buffer has its own point location. A buffer that is not currently displayed remembers where point is in case you display it again later.

When Emacs displays multiple windows, each window has its own point location. On text-only terminals, the cursor shows the location of point in the selected window. On graphical terminals, Emacs shows a cursor in each window; the selected window's cursor is solid, and the other cursors are hollow. Either way, the cursor or cursors tell you which window is selected. If the same buffer appears in more than one window, each window has its own position for point in that buffer, and (when possible) its own cursor.

See section J.13 Displaying the Cursor, for customization options that control display of the cursor or cursors.

The term "point" comes from the character `.', which was the command in TECO (the language in which the original Emacs was written) for accessing the value now called "point."

B.2 The Echo Area

The line at the bottom of the frame (below the mode line) is the echo area. It is used to display small amounts of text for several purposes.

Echoing means displaying the characters that you type. Outside Emacs, the operating system normally echoes all your input. Emacs handles echoing differently.

Single-character commands do not echo in Emacs, and multi-character commands echo only if you pause while typing them. As soon as you pause for more than a second in the middle of a command, Emacs echoes all the characters of the command so far. This is to prompt you for the rest of the command. Once echoing has started, the rest of the command echoes immediately as you type it. This behavior is designed to give confident users fast response, while giving hesitant users maximum feedback. You can change this behavior by setting a variable (see section J.12 Customization of Display).

If a command cannot be executed, it may display an error message in the echo area. Error messages are accompanied by beeping or by flashing the screen. The error also discards any input you have typed ahead.

Some commands display informative messages in the echo area. These messages look much like error messages, but they are not announced with a beep and do not throw away input. Sometimes the message tells you what the command has done, when this is not obvious from looking at the text being edited. Sometimes the sole purpose of a command is to show you a message giving you specific information--for example, C-x = displays a message describing the character position of point in the text and its current column in the window. Commands that take a long time often display messages ending in `...' while they are working, and add `done' at the end when they are finished.

Echo-area informative messages are saved in an editor buffer named `*Messages*'. (We have not explained buffers yet; see N. Using Multiple Buffers, for more information about them.) If you miss a message that appears briefly on the screen, you can switch to the `*Messages*' buffer to see it again. (Successive progress messages are often collapsed into one in that buffer.)

The size of `*Messages*' is limited to a certain number of lines. The variable message-log-max specifies how many lines. Once the buffer has that many lines, each line added at the end deletes one line from the beginning. See section AD.2 Variables, for how to set variables such as message-log-max.

The echo area is also used to display the minibuffer, a window that is used for reading arguments to commands, such as the name of a file to be edited. When the minibuffer is in use, the echo area begins with a prompt string that usually ends with a colon; also, the cursor appears in that line because it is the selected window. You can always get out of the minibuffer by typing C-g. See section E. The Minibuffer.

B.3 The Mode Line

Each text window's last line is a mode line, which describes what is going on in that window. When there is only one text window, the mode line appears right above the echo area; it is the next-to-last line in the frame. The mode line starts and ends with dashes. On a text-mode display, the mode line is in inverse video if the terminal supports that; on a graphics display, the mode line has a 3D box appearance to help it stand out.

Normally, the mode line looks like this:

-cs:ch buf (major minor)--line--pos------

This gives information about the buffer being displayed in the window: the buffer's name, what major and minor modes are in use, whether the buffer's text has been changed, and how far down the buffer you are currently looking.

ch contains two stars `**' if the text in the buffer has been edited (the buffer is "modified"), or `--' if the buffer has not been edited. For a read-only buffer, it is `%*' if the buffer is modified, and `%%' otherwise.

buf is the name of the window's buffer. In most cases this is the same as the name of a file you are editing. See section N. Using Multiple Buffers.

The buffer displayed in the selected window (the window that the cursor is in) is also Emacs's current buffer, the one that editing takes place in. When we speak of what some command does to "the buffer," we are talking about the current buffer.

line is `L' followed by the current line number of point. This is present when Line Number mode is enabled (which it normally is). You can optionally display the current column number too, by turning on Column Number mode (which is not enabled by default because it is somewhat slower). See section J.10 Optional Mode Line Features.

pos tells you whether there is additional text above the top of the window, or below the bottom. If your buffer is small and it is all visible in the window, pos is `All'. Otherwise, it is `Top' if you are looking at the beginning of the buffer, `Bot' if you are looking at the end of the buffer, or `nn%', where nn is the percentage of the buffer above the top of the window.

major is the name of the major mode in effect in the buffer. At any time, each buffer is in one and only one of the possible major modes. The major modes available include Fundamental mode (the least specialized), Text mode, Lisp mode, C mode, Texinfo mode, and many others. See section R. Major Modes, for details of how the modes differ and how to select one.

Some major modes display additional information after the major mode name. For example, Rmail buffers display the current message number and the total number of messages. Compilation buffers and Shell buffers display the status of the subprocess.

minor is a list of some of the minor modes that are turned on at the moment in the window's chosen buffer. For example, `Fill' means that Auto Fill mode is on. `Abbrev' means that Word Abbrev mode is on. `Ovwrt' means that Overwrite mode is on. See section AD.1 Minor Modes, for more information. `Narrow' means that the buffer being displayed has editing restricted to only a portion of its text. This is not really a minor mode, but is like one. See section AC.22 Narrowing. `Def' means that a keyboard macro is being defined. See section AD.3 Keyboard Macros.

In addition, if Emacs is currently inside a recursive editing level, square brackets (`[...]') appear around the parentheses that surround the modes. If Emacs is in one recursive editing level within another, double square brackets appear, and so on. Since recursive editing levels affect Emacs globally, not just one buffer, the square brackets appear in every window's mode line or not in any of them. See section AC.26 Recursive Editing Levels.

Non-windowing terminals can only show a single Emacs frame at a time (see section P. Frames and X Windows). On such terminals, the mode line displays the name of the selected frame, after ch. The initial frame's name is `F1'.

cs states the coding system used for the file you are editing. A dash indicates the default state of affairs: no code conversion, except for end-of-line translation if the file contents call for that. `=' means no conversion whatsoever. Nontrivial code conversions are represented by various letters--for example, `1' refers to ISO Latin-1. See section Q.7 Coding Systems, for more information. If you are using an input method, a string of the form `i>' is added to the beginning of cs; i identifies the input method. (Some input methods show `+' or `@' instead of `>'.) See section Q.4 Input Methods.

When you are using a character-only terminal (not a window system), cs uses three characters to describe, respectively, the coding system for keyboard input, the coding system for terminal output, and the coding system used for the file you are editing.

When multibyte characters are not enabled, cs does not appear at all. See section Q.2 Enabling Multibyte Characters.

The colon after cs can change to another string in certain circumstances. Emacs uses newline characters to separate lines in the buffer. Some files use different conventions for separating lines: either carriage-return linefeed (the MS-DOS convention) or just carriage-return (the Macintosh convention). If the buffer's file uses carriage-return linefeed, the colon changes to either a backslash (`\') or `(DOS)', depending on the operating system. If the file uses just carriage-return, the colon indicator changes to either a forward slash (`/') or `(Mac)'. On some systems, Emacs displays `(Unix)' instead of the colon even for files that use newline to separate lines.

You can customize the mode line display for each of the end-of-line formats by setting each of the variables eol-mnemonic-unix, eol-mnemonic-dos, eol-mnemonic-mac, and eol-mnemonic-undecided to any string you find appropriate. See section AD.2 Variables, for an explanation of how to set variables.

See section J.10 Optional Mode Line Features, for features that add other handy information to the mode line, such as the current column number of point, the current time, and whether new mail for you has arrived.

The mode line is mouse-sensitive; when you move the mouse across various parts of it, Emacs displays help text to say what a click in that place will do. See section P.6 Mode Line Mouse Commands.

B.4 The Menu Bar

Each Emacs frame normally has a menu bar at the top which you can use to perform certain common operations. There's no need to list them here, as you can more easily see for yourself.

When you are using a window system, you can use the mouse to choose a command from the menu bar. An arrow pointing right, after the menu item, indicates that the item leads to a subsidiary menu; `...' at the end means that the command will read arguments from the keyboard before it actually does anything.

To view the full command name and documentation for a menu item, type C-h k, and then select the menu bar with the mouse in the usual way (see section G.2 Documentation for a Key).

On text-only terminals with no mouse, you can use the menu bar by typing M-` or F10 (these run the command tmm-menubar). This command enters a mode in which you can select a menu item from the keyboard. A provisional choice appears in the echo area. You can use the left and right arrow keys to move through the menu to different choices. When you have found the choice you want, type RET to select it.

Each menu item also has an assigned letter or digit which designates that item; it is usually the initial of some word in the item's name. This letter or digit is separated from the item name by `=>'. You can type the item's letter or digit to select the item.

Some of the commands in the menu bar have ordinary key bindings as well; if so, the menu lists one equivalent key binding in parentheses after the item itself.

B.5 Kinds of User Input

GNU Emacs uses an extension of the ASCII character set for keyboard input; it also accepts non-character input events including function keys and mouse button actions.

ASCII consists of 128 character codes. Some of these codes are assigned graphic symbols such as `a' and `='; the rest are control characters, such as Control-a (usually written C-a for short). C-a gets its name from the fact that you type it by holding down the CTRL key while pressing a.

Some ASCII control characters have special names, and most terminals have special keys you can type them with: for example, RET, TAB, DEL and ESC. The space character is usually referred to below as SPC, even though strictly speaking it is a graphic character whose graphic happens to be blank. Some keyboards have a key labeled "linefeed" which is an alias for C-j.

Emacs extends the ASCII character set with thousands more printing characters (see section Q. International Character Set Support), additional control characters, and a few more modifiers that can be combined with any character.

On ASCII terminals, there are only 32 possible control characters. These are the control variants of letters and `@[]\^_'. In addition, the shift key is meaningless with control characters: C-a and C-A are the same character, and Emacs cannot distinguish them.

But the Emacs character set has room for control variants of all printing characters, and for distinguishing between C-a and C-A. The X Window System makes it possible to enter all these characters. For example, C-- (that's Control-Minus) and C-5 are meaningful Emacs commands under X.

Another Emacs character-set extension is additional modifier bits. Only one modifier bit is commonly used; it is called Meta. Every character has a Meta variant; examples include Meta-a (normally written M-a, for short), M-A (not the same character as M-a, but those two characters normally have the same meaning in Emacs), M-RET, and M-C-a. For reasons of tradition, we usually write C-M-a rather than M-C-a; logically speaking, the order in which the modifier keys CTRL and META are mentioned does not matter.

Some terminals have a META key, and allow you to type Meta characters by holding this key down. Thus, Meta-a is typed by holding down META and pressing a. The META key works much like the SHIFT key. Such a key is not always labeled META, however, as this function is often a special option for a key with some other primary purpose. Sometimes it is labeled ALT or EDIT; on a Sun keyboard, it may have a diamond on it.

If there is no META key, you can still type Meta characters using two-character sequences starting with ESC. Thus, you can enter M-a by typing ESC a. You can enter C-M-a by typing ESC C-a. ESC is allowed on terminals with META keys, too, in case you have formed a habit of using it. The X Window System provides several other modifier keys that can be applied to any input character. These are called SUPER, HYPER and ALT. We write `s-', `H-' and `A-' to say that a character uses these modifiers. Thus, s-H-C-x is short for Super-Hyper-Control-x. Not all X terminals actually provide keys for these modifier flags--in fact, many terminals have a key labeled ALT which is really a META key. The standard key bindings of Emacs do not include any characters with these modifiers. But you can assign them meanings of your own by customizing Emacs.

Keyboard input includes keyboard keys that are not characters at all: for example function keys and arrow keys. Mouse buttons are also outside the gamut of characters. You can modify these events with the modifier keys CTRL, META, SUPER, HYPER and ALT, just like keyboard characters.

Input characters and non-character inputs are collectively called input events. See section `Input Events' in The Emacs Lisp Reference Manual, for more information. If you are not doing Lisp programming, but simply want to redefine the meaning of some characters or non-character events, see AD. Customization.

ASCII terminals cannot really send anything to the computer except ASCII characters. These terminals use a sequence of characters to represent each function key. But that is invisible to the Emacs user, because the keyboard input routines recognize these special sequences and convert them to function key events before any other part of Emacs gets to see them.

B.6 Keys

A key sequence (key, for short) is a sequence of input events that are meaningful as a unit--as "a single command." Some Emacs command sequences are just one character or one event; for example, just C-f is enough to move forward one character in the buffer. But Emacs also has commands that take two or more events to invoke.

If a sequence of events is enough to invoke a command, it is a complete key. Examples of complete keys include C-a, X, RET, NEXT (a function key), DOWN (an arrow key), C-x C-f, and C-x 4 C-f. If it isn't long enough to be complete, we call it a prefix key. The above examples show that C-x and C-x 4 are prefix keys. Every key sequence is either a complete key or a prefix key.

Most single characters constitute complete keys in the standard Emacs command bindings. A few of them are prefix keys. A prefix key combines with the following input event to make a longer key sequence, which may itself be complete or a prefix. For example, C-x is a prefix key, so C-x and the next input event combine to make a two-event key sequence. Most of these key sequences are complete keys, including C-x C-f and C-x b. A few, such as C-x 4 and C-x r, are themselves prefix keys that lead to three-event key sequences. There's no limit to the length of a key sequence, but in practice people rarely use sequences longer than four events.

By contrast, you can't add more events onto a complete key. For example, the two-event sequence C-f C-k is not a key, because the C-f is a complete key in itself. It's impossible to give C-f C-k an independent meaning as a command. C-f C-k is two key sequences, not one.

All told, the prefix keys in Emacs are C-c, C-h, C-x, C-x RET, C-x @, C-x a, C-x n, C-x r, C-x v, C-x 4, C-x 5, C-x 6, ESC, and M-g. But this list is not cast in concrete; it is just a matter of Emacs's standard key bindings. If you customize Emacs, you can make new prefix keys, or eliminate these. See section AD.4 Customizing Key Bindings.

If you do make or eliminate prefix keys, that changes the set of possible key sequences. For example, if you redefine C-f as a prefix, C-f C-k automatically becomes a key (complete, unless you define that too as a prefix). Conversely, if you remove the prefix definition of C-x 4, then C-x 4 f (or C-x 4 anything) is no longer a key.

Typing the help character (C-h or F1) after a prefix key displays a list of the commands starting with that prefix. There are a few prefix keys for which C-h does not work--for historical reasons, they have other meanings for C-h which are not easy to change. But F1 should work for all prefix keys.

B.7 Keys and Commands

This manual is full of passages that tell you what particular keys do. But Emacs does not assign meanings to keys directly. Instead, Emacs assigns meanings to named commands, and then gives keys their meanings by binding them to commands.

Every command has a name chosen by a programmer. The name is usually made of a few English words separated by dashes; for example, next-line or forward-word. A command also has a function definition which is a Lisp program; this is what makes the command do what it does. In Emacs Lisp, a command is actually a special kind of Lisp function; one which specifies how to read arguments for it and call it interactively. For more information on commands and functions, see section `What Is a Function' in The Emacs Lisp Reference Manual. (The definition we use in this manual is simplified slightly.)

The bindings between keys and commands are recorded in various tables called keymaps. See section AD.4.1 Keymaps.

When we say that "C-n moves down vertically one line" we are glossing over a distinction that is irrelevant in ordinary use but is vital in understanding how to customize Emacs. It is the command next-line that is programmed to move down vertically. C-n has this effect because it is bound to that command. If you rebind C-n to the command forward-word then C-n will move forward by words instead. Rebinding keys is a common method of customization.

In the rest of this manual, we usually ignore this subtlety to keep things simple. To give the information needed for customization, we state the name of the command which really does the work in parentheses after mentioning the key that runs it. For example, we will say that "The command C-n (next-line) moves point vertically down," meaning that next-line is a command that moves vertically down, and C-n is a key that is normally bound to it.

While we are on the subject of information for customization only, 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. Most of the variables documented in this manual exist just to facilitate customization: some command or other part of Emacs examines the variable and behaves differently according to the value that you set. Until you are interested in customizing, you can ignore the information about variables. 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 AD.2 Variables.

B.8 Character Set for Text

Text in Emacs buffers is a sequence of 8-bit bytes. Each byte can hold a single ASCII character. Both ASCII control characters (octal codes 000 through 037, and 0177) and ASCII printing characters (codes 040 through 0176) are allowed; however, non-ASCII control characters cannot appear in a buffer. The other modifier flags used in keyboard input, such as Meta, are not allowed in buffers either.

Some ASCII control characters serve special purposes in text, and have special names. For example, the newline character (octal code 012) is used in the buffer to end a line, and the tab character (octal code 011) is used for indenting to the next tab stop column (normally every 8 columns). See section J.11 How Text Is Displayed.

Non-ASCII printing characters can also appear in buffers. When multibyte characters are enabled, you can use any of the non-ASCII printing characters that Emacs supports. They have character codes starting at 256, octal 0400, and each one is represented as a sequence of two or more bytes. See section Q. International Character Set Support. Single-byte characters with codes 128 through 255 can also appear in multibyte buffers.

If you disable multibyte characters, then you can use only one alphabet of non-ASCII characters, but they all fit in one byte. They use codes 0200 through 0377. See section Q.13 Single-byte Character Set Support.

C. Entering and Exiting Emacs

The usual way to invoke Emacs is with the shell command emacs. Emacs clears the screen and then displays an initial help message and copyright notice. Some operating systems discard all type-ahead when Emacs starts up; they give Emacs no way to prevent this. Therefore, it is advisable to wait until Emacs clears the screen before typing your first editing command.

If you run Emacs from a shell window under the X Window System, run it in the background with emacs&. This way, Emacs does not tie up the shell window, so you can use that to run other shell commands while Emacs operates its own X windows. You can begin typing Emacs commands as soon as you direct your keyboard input to the Emacs frame.

When Emacs starts up, it creates a buffer named `*scratch*'. That's the buffer you start out in. The `*scratch*' buffer uses Lisp Interaction mode; you can use it to type Lisp expressions and evaluate them, or you can ignore that capability and simply doodle. (You can specify a different major mode for this buffer by setting the variable initial-major-mode in your init file. See section AD.7 The Init File, `~/.emacs'.)

It is possible to specify files to be visited, Lisp files to be loaded, and functions to be called, by giving Emacs arguments in the shell command line. See section AE. Command Line Arguments. But we don't recommend doing this. The feature exists mainly for compatibility with other editors.

Many other editors are designed to be started afresh each time you want to edit. You edit one file and then exit the editor. The next time you want to edit either another file or the same one, you must run the editor again. With these editors, it makes sense to use a command-line argument to say which file to edit.

But starting a new Emacs each time you want to edit a different file does not make sense. For one thing, this would be annoyingly slow. For another, this would fail to take advantage of Emacs's ability to visit more than one file in a single editing session. And it would lose the other accumulated context, such as the kill ring, registers, undo history, and mark ring.

The recommended way to use GNU Emacs is to start it only once, just after you log in, and do all your editing in the same Emacs session. Each time you want to edit a different file, you visit it with the existing Emacs, which eventually comes to have many files in it ready for editing. Usually you do not kill the Emacs until you are about to log out. See section M. File Handling, for more information on visiting more than one file.

C.1 Exiting Emacs

There are two commands for exiting Emacs because there are two kinds of exiting: suspending Emacs and killing Emacs.

Suspending means stopping Emacs temporarily and returning control to its parent process (usually a shell), allowing you to resume editing later in the same Emacs job, with the same buffers, same kill ring, same undo history, and so on. This is the usual way to exit.

Killing Emacs means destroying the Emacs job. You can run Emacs again later, but you will get a fresh Emacs; there is no way to resume the same editing session after it has been killed.

C-z

Suspend Emacs (suspend-emacs) or iconify a frame (iconify-or-deiconify-frame).

C-x C-c

Kill Emacs (save-buffers-kill-emacs).

To suspend Emacs, type C-z (suspend-emacs). This takes you back to the shell from which you invoked Emacs. You can resume Emacs with the shell command %emacs in most common shells.

On systems that do not support suspending programs, C-z starts an inferior shell that communicates directly with the terminal. Emacs waits until you exit the subshell. (The way to do that is probably with C-d or exit, but it depends on which shell you use.) The only way on these systems to get back to the shell from which Emacs was run (to log out, for example) is to kill Emacs.

Suspending also fails if you run Emacs under a shell that doesn't support suspending programs, even if the system itself does support it. In such a case, you can set the variable cannot-suspend to a non-nil value to force C-z to start an inferior shell. (One might also describe Emacs's parent shell as "inferior" for failing to support job control properly, but that is a matter of taste.)

When Emacs communicates directly with an X server and creates its own dedicated X windows, C-z has a different meaning. Suspending an application that uses its own X windows is not meaningful or useful. Instead, C-z runs the command iconify-or-deiconify-frame, which temporarily iconifies (or "minimizes") the selected Emacs frame (see section P. Frames and X Windows). Then you can use the window manager to get back to a shell window.

To exit and kill Emacs, type C-x C-c (save-buffers-kill-emacs). A two-character key is used for this to make it harder to type by accident. This command first offers to save any modified file-visiting buffers. If you do not save them all, it asks for reconfirmation with yes before killing Emacs, since any changes not saved will be lost forever. Also, if any subprocesses are still running, C-x C-c asks for confirmation about them, since killing Emacs will also kill the subprocesses.

If the value of the variable confirm-kill-emacs is non-nil, C-x C-c assumes that its value is a predicate function, and calls that function. If the result is non-nil, the session is killed, otherwise Emacs continues to run. One convenient function to use as the value of confirm-kill-emacs is the function yes-or-no-p. The default value of confirm-kill-emacs is nil.

There is no way to resume an Emacs session once you have killed it. You can, however, arrange for Emacs to record certain session information when you kill it, such as which files are visited, so that the next time you start Emacs it will try to visit the same files and so on. See section AC.25 Saving Emacs Sessions.

The operating system usually listens for certain special characters whose meaning is to kill or suspend the program you are running. This operating system feature is turned off while you are in Emacs. The meanings of C-z and C-x C-c as keys in Emacs were inspired by the use of C-z and C-c on several operating systems as the characters for stopping or killing a program, but that is their only relationship with the operating system. You can customize these keys to run any commands of your choice (see section AD.4.1 Keymaps).

D. 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 Emacs learn-by-doing tutorial. To use the tutorial, run Emacs and type Control-h t (help-with-tutorial).

To clear the screen and redisplay, type C-l (recenter).

D.1 Inserting Text		Inserting text by simply typing it.
D.2 Changing the Location of Point		How to move the cursor to the place where you want to change something.
D.3 Erasing Text		Deleting and killing text.
D.4 Undoing Changes		Undoing recent changes in the text.
D.5 Files		Visiting, creating, and saving files.
D.6 Help		Asking what a character does.
D.7 Blank Lines		Commands to make or delete blank lines.
D.8 Continuation Lines		Lines too wide for the screen.
D.9 Cursor Position Information		What page, line, row, or column is point on?
D.10 Numeric Arguments		Numeric arguments for repeating a command.
D.11 Repeating a Command		A short-cut for repeating the previous command.

D.1 Inserting Text

To insert printing characters into the text you are editing, just type them. This inserts the characters you type into the buffer at the cursor (that is, at point; see section B.1 Point). The cursor moves forward, and any text after the cursor moves 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 delete text you have just inserted, use the large key labeled DEL, BACKSPACE or DELETE which is a short distance above the RET or ENTER key. This is the key you normally use, outside Emacs, for erasing the last character that you typed. Regardless of the label on that key, Emacs thinks of it as DEL, and that's what we call it in this manual.

The DEL key deletes the character before the cursor. As a consequence, the cursor and all the characters after it move backwards. If you type a printing character and then type DEL, they cancel out.

On most computers, Emacs recognizes automatically which key ought to be DEL, and sets it up that way. But in some cases, especially with text-only terminals, you will need to tell Emacs which key to use for that purpose. If the large key not far above the RET or ENTER key doesn't delete backwards, you need to do this. See section AD.9.1 If DEL Fails to Delete, for an explanation of how.

Most PC keyboards have both a BACKSPACE key a short ways above RET or ENTER, and a DELETE key elsewhere. On these keyboards, Emacs supports when possible the usual convention that the BACKSPACE key deletes backwards (it is DEL), while the DELETE key deletes "forwards," deleting the character after point, the one underneath the cursor, like C-d (see below).

To end a line and start typing a new one, type RET. This inserts a newline character in the buffer. If point is in the middle of a line, RET splits the line. Typing DEL when the cursor is at the beginning of a line deletes the preceding newline, thus joining the line with the preceding line.

Emacs can split lines automatically when they become too long, if you turn on a special minor mode called Auto Fill mode. See section T.5 Filling Text, for how to use Auto Fill mode.

If you prefer to have text characters replace (overwrite) existing text rather than shove it to the right, you can enable Overwrite mode, a minor mode. See section AD.1 Minor Modes.

Direct insertion works for printing characters and SPC, but other characters act as editing commands and do not insert themselves. If you need to insert a control character or a character whose code is above 200 octal, you must quote it by typing the character Control-q (quoted-insert) first. (This character's name is normally written C-q for short.) There are two ways to use C-q:

• C-q followed by any non-graphic character (even C-g) inserts that character.

• C-q followed by a sequence of octal digits inserts the character with the specified octal character code. You can use any number of octal digits; any non-digit terminates the sequence. If the terminating character is RET, it serves only to terminate the sequence. Any other non-digit terminates the sequence and then acts as normal input--thus, C-q 1 0 1 B inserts `AB'.

  The use of octal sequences is disabled in ordinary non-binary Overwrite mode, to give you a convenient way to insert a digit instead of overwriting with it.

When multibyte characters are enabled, if you specify a code in the range 0200 through 0377 octal, C-q assumes that you intend to use some ISO 8859-n character set, and converts the specified code to the corresponding Emacs character code. See section Q.2 Enabling Multibyte Characters. You select which of the ISO 8859 character sets to use through your choice of language environment (see section Q.3 Language Environments).

To use decimal or hexadecimal instead of octal, set the variable read-quoted-char-radix to 10 or 16. If the radix is greater than 10, some letters starting with a serve as part of a character code, just like digits.

A numeric argument to C-q specifies how many copies of the quoted character should be inserted (see section D.10 Numeric Arguments).

Customization information: DEL in most modes runs the command delete-backward-char; RET runs the command newline, and self-inserting printing characters run the command self-insert, which inserts whatever character was typed to invoke it. Some major modes rebind DEL to other commands.

D.2 Changing the Location of Point

To do more than insert characters, you have to know how to move point (see section B.1 Point). The simplest way to do this is with arrow keys, or by clicking the left mouse button where you want to move to.

There are also control and meta characters for cursor motion. Some are equivalent to the arrow keys (these date back to the days before terminals had arrow keys, and are usable on terminals which don't have them). Others do more sophisticated things.

C-a

Move to the beginning of the line (beginning-of-line).

C-e

Move to the end of the line (end-of-line).

C-f

Move forward one character (forward-char). The right-arrow key does the same thing.

C-b

Move backward one character (backward-char). The left-arrow key has the same effect.

M-f

Move forward one word (forward-word).

M-b

Move backward one word (backward-word).

C-n

Move down one line, vertically (next-line). This command attempts to keep the horizontal position unchanged, so if you start in the middle of one line, you end in the middle of the next. The down-arrow key does the same thing.

C-p

Move up one line, vertically (previous-line). The up-arrow key has the same effect.

M-r

Move point to left margin, vertically centered in the window (move-to-window-line). Text does not move on the screen.

A numeric argument says which screen line to place point on. It counts screen lines down from the top of the window (zero for the top line). A negative argument counts lines from the bottom (-1 for the bottom line).

M-<

Move to the top of the buffer (beginning-of-buffer). With numeric argument n, move to n/10 of the way from the top. See section D.10 Numeric Arguments, for more information on numeric arguments.

M->

Move to the end of the buffer (end-of-buffer).

C-v

Scroll the display one screen forward, and move point if necessary to put it on the screen (scroll-up). This doesn't always move point, but it is commonly used to do so. If your keyboard has a PAGEDOWN key, it does the same thing.

Scrolling commands are further described in J.6 Scrolling.

M-v

Scroll one screen backward, and move point if necessary to put it on the screen (scroll-down). This doesn't always move point, but it is commonly used to do so. The PAGEUP key has the same effect.

M-x goto-char

Read a number n and move point to buffer position n. Position 1 is the beginning of the buffer.

M-x goto-line

Read a number n and move point to line number n. Line 1 is the beginning of the buffer.

C-x C-n

Use the current column of point as the semipermanent goal column for C-n and C-p (set-goal-column). Henceforth, those commands always move to this column in each line moved into, or as close as possible given the contents of the line. This goal column remains in effect until canceled.

C-u C-x C-n

Cancel the goal column. Henceforth, C-n and C-p once again try to stick to a fixed horizontal position, as usual.

If you set the variable track-eol to a non-nil value, then C-n and C-p, when starting at the end of the line, move to the end of another line. Normally, track-eol is nil. See section AD.2 Variables, for how to set variables such as track-eol.

C-n normally gets an error when you use it on the last line of the buffer (just as C-p gets an error on the first line). But if you set the variable next-line-add-newlines to a non-nil value, C-n on the last line of a buffer creates an additional line at the end and moves down onto it.

D.3 Erasing Text

DEL

Delete the character before point (delete-backward-char).

C-d

Delete the character after point (delete-char).

DELETE

BACKSPACE

One of these keys, whichever is the large key above the RET or ENTER key, deletes the character before point, like DEL. If that is BACKSPACE, and your keyboard also has DELETE, then DELETE deletes forwards, like C-d.

C-k

Kill to the end of the line (kill-line).

M-d

Kill forward to the end of the next word (kill-word).

M-DEL

Kill back to the beginning of the previous word (backward-kill-word).

You already know about the DEL key which deletes the character before point (that is, before the cursor). Another key, Control-d (C-d for short), deletes the character after point (that is, the character that the cursor is on). This shifts the rest of the text on the line to the left. If you type C-d at the end of a line, it joins together that line and the next line.

To erase a larger amount of text, use the C-k key, which kills a line at a time. If you type C-k at the beginning or middle of a line, it kills all the text up to the end of the line. If you type C-k at the end of a line, it joins that line and the next line.

See section H.7 Deletion and Killing, for more flexible ways of killing text.

D.4 Undoing Changes

You can undo all the recent changes in the buffer text, up to a certain point. Each buffer records changes individually, and the undo command always applies to the current buffer. Usually each editing command makes a separate entry in the undo records, but some commands such as query-replace make many entries, and very simple commands such as self-inserting characters are often grouped to make undoing less tedious.

C-x u

Undo one batch of changes--usually, one command worth (undo).

C-_

The same.

C-u C-x u

Undo one batch of changes in the region.

The command C-x u or C-_ is how you undo. The first time you give this command, it undoes the last change. Point moves back to where it was before the command that made the change.

Consecutive repetitions of C-_ or C-x u undo earlier and earlier changes, back to the limit of the undo information available. If all recorded changes have already been undone, the undo command displays an error message and does nothing.

Any command other than an undo command breaks the sequence of undo commands. Starting from that moment, the previous undo commands become ordinary changes that you can undo. Thus, to redo changes you have undone, type C-f or any other command that will harmlessly break the sequence of undoing, then type more undo commands.

Ordinary undo applies to all changes made in the current buffer. You can also perform selective undo, limited to the current region. To do this, specify the region you want, then run the undo command with a prefix argument (the value does not matter): C-u C-x u or C-u C-_. This undoes the most recent change in the region. To undo further changes in the same region, repeat the undo command (no prefix argument is needed). In Transient Mark mode, any use of undo when there is an active region performs selective undo; you do not need a prefix argument.

If you notice that a buffer has been modified accidentally, the easiest way to recover is to type C-_ repeatedly until the stars disappear from the front of the mode line. At this time, all the modifications you made have been canceled. Whenever an undo command makes the stars disappear from the mode line, it means that the buffer contents are the same as they were when the file was last read in or saved.

If you do not remember whether you changed the buffer deliberately, type C-_ once. When you see the last change you made undone, you will see whether it was an intentional change. If it was an accident, leave it undone. If it was deliberate, redo the change as described above.

Not all buffers record undo information. Buffers whose names start with spaces don't; these buffers are used internally by Emacs and its extensions to hold text that users don't normally look at or edit.

You cannot undo mere cursor motion; only changes in the buffer contents save undo information. However, some cursor motion commands set the mark, so if you use these commands from time to time, you can move back to the neighborhoods you have moved through by popping the mark ring (see section H.5 The Mark Ring).

When the undo information for a buffer becomes too large, Emacs discards the oldest undo information from time to time (during garbage collection). You can specify how much undo information to keep by setting two variables: undo-limit and undo-strong-limit. Their values are expressed in units of bytes of space.

The variable undo-limit sets a soft limit: Emacs keeps undo data for enough commands to reach this size, and perhaps exceed it, but does not keep data for any earlier commands beyond that. Its default value is 20000. The variable undo-strong-limit sets a stricter limit: the command which pushes the size past this amount is itself forgotten. Its default value is 30000.

Regardless of the values of those variables, the most recent change is never discarded, so there is no danger that garbage collection occurring right after an unintentional large change might prevent you from undoing it.

The reason the undo command has two keys, C-x u and C-_, set up to run it is that it is worthy of a single-character key, but on some keyboards it is not obvious how to type C-_. C-x u is an alternative you can type straightforwardly on any terminal.

D.5 Files

The commands described above are sufficient for creating and altering text in an 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 named units of text which are stored by the operating system for you to retrieve later by name. To look at or use the contents of a file in any way, including editing the file with Emacs, you must specify the file name.

Consider a file named `/usr/rms/foo.c'. In Emacs, to begin editing this file, type

C-x C-f /usr/rms/foo.c RET

Here the file name is given as an argument to the command C-x C-f (find-file). That command uses the minibuffer to read the argument, and you type RET to terminate the argument (see section E. The Minibuffer).

Emacs obeys the command by visiting the file: creating a buffer, copying the contents of the file into the buffer, and then displaying the buffer for you to edit. If you alter the text, you can save the new text in the file by typing C-x C-s (save-buffer). This makes the changes permanent by copying the altered buffer contents back into the file `/usr/rms/foo.c'. Until you save, the changes exist only inside Emacs, and the file `foo.c' is unaltered.

To create a file, just visit the file with C-x C-f as if it already existed. This creates an empty buffer in which you can insert the text you want to put in the file. The file is actually created when you save this buffer with C-x C-s.

Of course, there is a lot more to learn about using files. See section M. File Handling.

D.6 Help

If you forget what a key does, you can find out with the Help character, which is C-h (or F1, which is an alias for C-h). Type C-h k followed by the key you want to know about; for example, C-h k C-n tells you all about what C-n does. C-h is a prefix key; C-h k is just one of its subcommands (the command describe-key). The other subcommands of C-h provide different kinds of help. Type C-h twice to get a description of all the help facilities. See section G. Help.

D.7 Blank Lines

Here are special commands and techniques for putting in and taking out blank lines.

C-o

Insert one or more blank lines after the cursor (open-line).

C-x C-o

Delete all but one of many consecutive blank lines (delete-blank-lines).

When you want to insert a new line of text before an existing line, you can do it by typing the new line of text, followed by RET. However, it may be easier to see what you are doing if you first make a blank line and then insert the desired text into it. This is easy to do using the key C-o (open-line), which inserts a newline after point but leaves point in front of the newline. After C-o, type the text for the new line. C-o F O O has the same effect as F O O RET, except for the final location of point.

You can make several blank lines by typing C-o several times, or by giving it a numeric argument to tell it how many blank lines to make. See section D.10 Numeric Arguments, for how. If you have a fill prefix, then C-o command inserts the fill prefix on the new line, when you use it at the beginning of a line. See section T.5.4 The Fill Prefix.

The easy way to get rid of extra blank lines is with the command C-x C-o (delete-blank-lines). C-x C-o in a run of several blank lines deletes all but one of them. C-x C-o on a solitary blank line deletes that blank line. When point is on a nonblank line, C-x C-o deletes any blank lines following that nonblank line.

D.8 Continuation Lines

If you add too many characters to one line without breaking it with RET, the line grows to occupy two (or more) lines on the screen. On graphical displays, Emacs indicates line wrapping with small bent arrows in the fringes to the left and right of the window. On text-only terminals, Emacs displays a `\' character at the right margin of a screen line if it is not the last in its text line. This `\' character says that the following screen line is not really a distinct line in the text, just a continuation of a line too long to fit the screen. Continuation is also called line wrapping.

When line wrapping occurs before a character that is wider than one column, some columns at the end of the previous screen line may be "empty." In this case, Emacs displays additional `\' characters in the "empty" columns, just before the `\' character that indicates continuation.

Sometimes it is nice to have Emacs insert newlines automatically when a line gets too long. Continuation on the screen does not do that. Use Auto Fill mode (see section T.5 Filling Text) if that's what you want.

As an alternative to continuation, Emacs can display long lines by truncation. This means that all the characters that do not fit in the width of the screen or window do not appear at all. They remain in the buffer, temporarily invisible. On terminals, `$' in the last column informs you that the line has been truncated on the display. On window systems, a small straight arrow in the fringe to the right of the window indicates a truncated line.

Truncation instead of continuation happens whenever horizontal scrolling is in use, and optionally in all side-by-side windows (see section O. Multiple Windows). You can enable or disable truncation for a particular buffer with the command M-x toggle-truncate-lines.

See section J.12 Customization of Display, for additional variables that affect how text is displayed.

D.9 Cursor Position Information

Here are commands to get information about the size and position of parts of the buffer, and to count lines.

M-x what-page

Display the page number of point, and the line number within the page.

M-x what-line

Display the line number of point in the buffer.

M-x line-number-mode

M-x column-number-mode

Toggle automatic display of current line number or column number. See section J.10 Optional Mode Line Features.

M-=

Display the number of lines in the current region (count-lines-region). See section H. The Mark and the Region, for information about the region.

C-x =

Display the character code of character after point, character position of point, and column of point (what-cursor-position).

M-x hl-line-mode

Enable or disable highlighting of the current line. See section J.13 Displaying the Cursor.

There are two commands for working with line numbers. M-x what-line computes the current line number and displays it in the echo area. To go to a given line by number, use M-x goto-line; it prompts you for the number. These line numbers count from one at the beginning of the buffer.

You can also see the current line number in the mode line; see B.3 The Mode Line. If you narrow the buffer, then the line number in the mode line is relative to the accessible portion (see section AC.22 Narrowing). By contrast, what-line shows both the line number relative to the narrowed region and the line number relative to the whole buffer.

M-x what-page counts pages from the beginning of the file, and counts lines within the page, showing both numbers in the echo area. See section T.4 Pages.

While on this subject, we might as well mention M-= (count-lines-region), which displays the number of lines in the region (see section H. The Mark and the Region). See section T.4 Pages, for the command C-x l which counts the lines in the current page.

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. It displays a line in the echo area that looks like this:

Char: c (0143, 99, 0x63) point=21044 of 26883(78%) column 53

(In fact, this is the output produced when point is before the `column' in the example.)

The four values after `Char:' describe the character that follows point, first by showing it and then by giving its character code in octal, decimal and hex. For a non-ASCII multibyte character, these are followed by `ext' and the character's representation, in hex, in the buffer's coding system, if that coding system encodes the character safely and with a single byte (see section Q.7 Coding Systems). If the character's encoding is longer than one byte, Emacs shows `ext ...'.

`point=' is followed by the position of point expressed as a character count. The front of the buffer counts as position 1, one character later as 2, and so on. The next, larger, number is the total number of characters in the buffer. Afterward in parentheses comes the position expressed as a percentage of the total size.

`column' is followed by the horizontal position of point, in columns from the left edge of the window.

If the buffer has been narrowed, making some of the text at the beginning and the end temporarily inaccessible, C-x = displays additional text describing the currently accessible range. For example, it might display this:

Char: C (0103, 67, 0x43) point=252 of 889(28%) <231 - 599> column 0

where the two extra numbers give the smallest and largest character position that point is allowed to assume. The characters between those two positions are the accessible ones. See section AC.22 Narrowing.

If point is at the end of the buffer (or the end of the accessible part), the C-x = output does not describe a character after point. The output might look like this:

point=26957 of 26956(100%) column 0

C-u C-x = displays additional information about a character, in place of the buffer coordinates and column: the character set name and the codes that identify the character within that character set; ASCII characters are identified as belonging to the ASCII character set. In addition, the full character encoding, even if it takes more than a single byte, is shown after `ext'. Here's an example for a Latin-1 character A with a grave accent in a buffer whose coding system is iso-2022-7bit(1):

Char: À (04300, 2240, 0x8c0, ext ESC , A @) (latin-iso8859-1 64)

D.10 Numeric Arguments

In mathematics and computer usage, the word argument means "data provided to a function or operation." You can give any Emacs command a numeric argument (also called a prefix argument). Some commands interpret the argument as a repetition count. For example, C-f with an argument of ten moves forward ten characters instead of one. With these commands, no argument is equivalent to an argument of one. Negative arguments tell most such commands to move or act in the opposite direction.

If your terminal keyboard has a META key, the easiest way to specify a numeric argument is to type digits and/or a minus sign while holding down the META key. For example,

M-5 C-n

would move down five lines. The characters Meta-1, Meta-2, and so on, as well as Meta--, do this because they are keys bound to commands (digit-argument and negative-argument) that are defined to contribute to an argument for the next command. Meta-- without digits normally means -1. Digits and - modified with Control, or Control and Meta, also specify numeric arguments.

Another way of specifying an argument is to use the C-u (universal-argument) command followed by the digits of the argument. With C-u, you can type the argument digits without holding down modifier keys; C-u works on all terminals. To type a negative argument, type a minus sign after C-u. Just a minus sign without digits normally means -1.

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. C-u twice multiplies 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/5 of a line in the usual size screen. 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).

Some commands care only about whether there is an argument, and not about its value. For example, the command M-q (fill-paragraph) with no argument fills text; with an argument, it justifies the text as well. (See section T.5 Filling Text, for more information on M-q.) Plain C-u is a handy way of providing an argument for such commands.

Some commands use the value of the argument as a repeat count, but do something peculiar when there is no argument. For example, the command C-k (kill-line) with argument n kills n lines, including their terminating newlines. But C-k with no argument is special: it kills the text up to the next newline, or, if point is right at the end of the line, it kills the newline itself. Thus, two C-k commands with no arguments can kill a nonblank line, just like C-k with an argument of one. (See section H.7 Deletion and Killing, for more information on C-k.)

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 are described when they come up; they are always for reasons of convenience of use of the individual command.

You can use a numeric argument to insert multiple copies of a character. This is straightforward unless the character is a digit; for example, C-u 6 4 a inserts 64 copies of the character `a'. But this does not work for inserting digits; C-u 6 4 1 specifies an argument of 641, rather than inserting anything. To separate the digit to insert from the argument, type another C-u; for example, C-u 6 4 C-u 1 does insert 64 copies of the character `1'.

We use the term "prefix argument" as well as "numeric argument" to emphasize that you type the argument before the command, and to distinguish these arguments from minibuffer arguments that come after the command.

D.11 Repeating a Command

Many simple commands, such as those invoked with a single key or with M-x command-name RET, can be repeated by invoking them with a numeric argument that serves as a repeat count (see section D.10 Numeric Arguments). However, if the command you want to repeat prompts for some input, or uses a numeric argument in another way, repetition using a numeric argument might be problematical.

The command C-x z (repeat) provides another way to repeat an Emacs command many times. This command repeats the previous Emacs command, whatever that was. Repeating a command uses the same arguments that were used before; it does not read new arguments each time.

To repeat the command more than once, type additional z's: each z repeats the command one more time. Repetition ends when you type a character other than z, or press a mouse button.

For example, suppose you type C-u 2 0 C-d to delete 20 characters. You can repeat that command (including its argument) three additional times, to delete a total of 80 characters, by typing C-x z z z. The first C-x z repeats the command once, and each subsequent z repeats it once again.

E. The Minibuffer

The minibuffer is the facility used by Emacs commands to read arguments more complicated than a single number. Minibuffer arguments can be file names, buffer names, Lisp function names, Emacs command names, Lisp expressions, and many other things, depending on the command reading the argument. You can use the usual Emacs editing commands in the minibuffer to edit the argument text.

When the minibuffer is in use, it appears in the echo area, and the terminal's cursor moves there. The beginning of the minibuffer line displays a prompt which says what kind of input you should supply and how it will be used. Often this prompt is derived from the name of the command that the argument is for. The prompt normally ends with a colon.

Sometimes a default argument appears in parentheses after the colon; it too is part of the prompt. The default will be used as the argument value if you enter an empty argument (that is, just type RET). For example, commands that read buffer names always show a default, which is the name of the buffer that will be used if you type just RET.

The simplest way to enter a minibuffer argument is to type the text you want, terminated by RET which exits the minibuffer. You can cancel the command that wants the argument, and get out of the minibuffer, by typing C-g.

Since the minibuffer uses the screen space of the echo area, it can conflict with other ways Emacs customarily uses the echo area. Here is how Emacs handles such conflicts:

• If a command gets an error while you are in the minibuffer, this does not cancel the minibuffer. However, the echo area is needed for the error message and therefore the minibuffer itself is hidden for a while. It comes back after a few seconds, or as soon as you type anything.

• If in the minibuffer you use a command whose purpose is to display a message in the echo area, such as C-x =, the message hides the minibuffer for a while. The minibuffer contents come back after a few seconds, or as soon as you type anything.

• Echoing of keystrokes does not take place while the minibuffer is in use.

E.1 Minibuffers for File Names		Entering file names with the minibuffer.
E.2 Editing in the Minibuffer		How to edit in the minibuffer.
E.3 Completion		An abbreviation facility for minibuffer input.
E.4 Minibuffer History		Reusing recent minibuffer arguments.
E.5 Repeating Minibuffer Commands		Re-executing commands that used the minibuffer.

E.1 Minibuffers for File Names

Sometimes the minibuffer starts out with text in it. For example, when you are supposed to give a file name, the minibuffer starts out containing the default directory, which ends with a slash. This is to inform you which directory the file will be found in if you do not specify a directory.

For example, the minibuffer might start out with these contents:

Find File: /u2/emacs/src/

where `Find File: ' is the prompt. Typing buffer.c specifies the file `/u2/emacs/src/buffer.c'. To find files in nearby directories, use ..; thus, if you type ../lisp/simple.el, you will get the file named `/u2/emacs/lisp/simple.el'. Alternatively, you can kill with M-DEL the directory names you don't want (see section T.1 Words).

If you don't want any of the default, you can kill it with C-a C-k. But you don't need to kill the default; you can simply ignore it. Insert an absolute file name, one starting with a slash or a tilde, after the default directory. For example, to specify the file `/etc/termcap', just insert that name, giving these minibuffer contents:

Find File: /u2/emacs/src//etc/termcap

GNU Emacs gives a special meaning to a double slash (which is not normally a useful thing to write): it means, "ignore everything before the second slash in the pair." Thus, `/u2/emacs/src/' is ignored in the example above, and you get the file `/etc/termcap'.

If you set insert-default-directory to nil, the default directory is not inserted in the minibuffer. This way, the minibuffer starts out empty. But the name you type, if relative, is still interpreted with respect to the same default directory.

E.2 Editing in the Minibuffer

The minibuffer is an Emacs buffer (albeit a peculiar one), and the usual Emacs commands are available for editing the text of an argument you are entering.

Since RET in the minibuffer is defined to exit the minibuffer, you can't use it to insert a newline in the minibuffer. To do that, type C-o or C-q C-j. (Recall that a newline is really the character control-J.)

The minibuffer has its own window which always has space on the screen but acts as if it were not there when the minibuffer is not in use. When the minibuffer is in use, its window is just like the others; you can switch to another window with C-x o, edit text in other windows and perhaps even visit more files, before returning to the minibuffer to submit the argument. You can kill text in another window, return to the minibuffer window, and then yank the text to use it in the argument. See section O. Multiple Windows.

There are some restrictions on the use of the minibuffer window, however. You cannot switch buffers in it--the minibuffer and its window are permanently attached. Also, you cannot split or kill the minibuffer window. But you can make it taller in the normal fashion with C-x ^.

The minibuffer window expands vertically as necessary to hold the text that you put in the minibuffer, if resize-mini-windows is non-nil. If resize-mini-windows is t, the window is always resized to fit the size of the text it displays. If resize-mini-windows is the symbol grow-only, the window grows when the size of displayed text increases, but shrinks (back to the normal size) only when the minibuffer becomes inactive.

The variable max-mini-window-height controls the maximum height for resizing the minibuffer window: a floating-point number specifies a fraction of the frame's height; an integer specifies the maximum number of lines; nil means do not resize the minibuffer window automatically. The default value is 0.25.

If while in the minibuffer you issue a command that displays help text of any sort in another window, you can use the C-M-v command while in the minibuffer to scroll the help text. This lasts until you exit the minibuffer. This feature is especially useful when you display a buffer listing possible completions. See section O.3 Using Other Windows.

Emacs normally disallows most commands that use the minibuffer while the minibuffer is active. This rule is to prevent recursive minibuffers from confusing novice users. If you want to be able to use such commands in the minibuffer, set the variable enable-recursive-minibuffers to a non-nil value.

E.3 Completion

For certain kinds of arguments, you can use completion to enter the argument value. Completion means that you type part of the argument, then Emacs visibly fills in the rest, or as much as can be determined from the part you have typed.

When completion is available, certain keys---TAB, RET, and SPC---are rebound to complete the text present in the minibuffer into a longer string that it stands for, by matching it against a set of completion alternatives provided by the command reading the argument. ? is defined to display a list of possible completions of what you have inserted.

For example, when M-x uses the minibuffer to read the name of a command, it provides a list of all available Emacs command names to complete against. The completion keys match the text in the minibuffer against all the command names, find any additional name characters implied by the ones already present in the minibuffer, and add those characters to the ones you have given. This is what makes it possible to type M-x ins SPC b RET instead of M-x insert-buffer RET (for example).

Case is normally significant in completion, because it is significant in most of the names that you can complete (buffer names, file names and command names). Thus, `fo' does not complete to `Foo'. Completion does ignore case distinctions for certain arguments in which case does not matter.

E.3.1 Completion Example
E.3.2 Completion Commands
E.3.3 Strict Completion
E.3.4 Completion Options

E.3.1 Completion Example

A concrete example may help here. If you type M-x au TAB, the TAB looks for alternatives (in this case, command names) that start with `au'. There are several, including auto-fill-mode and auto-save-mode---but they are all the same as far as auto-, so the `au' in the minibuffer changes to `auto-'.

If you type TAB again immediately, there are multiple possibilities for the very next character--it could be any of `cfilrs'---so no more characters are added; instead, TAB displays a list of all possible completions in another window.

If you go on to type f TAB, this TAB sees `auto-f'. The only command name starting this way is auto-fill-mode, so completion fills in the rest of that. You now have `auto-fill-mode' in the minibuffer after typing just au TAB f TAB. Note that TAB has this effect because in the minibuffer it is bound to the command minibuffer-complete when completion is available.

E.3.2 Completion Commands

Here is a list of the completion commands defined in the minibuffer when completion is available.

TAB

Complete the text in the minibuffer as much as possible (minibuffer-complete).

SPC

Complete the minibuffer text, but don't go beyond one word (minibuffer-complete-word).

RET

Submit the text in the minibuffer as the argument, possibly completing first as described below (minibuffer-complete-and-exit).

?

Display a list of all possible completions of the text in the minibuffer (minibuffer-list-completions).

SPC completes much like TAB, but never goes beyond the next hyphen or space. If you have `auto-f' in the minibuffer and type SPC, it finds that the completion is `auto-fill-mode', but it stops completing after `fill-'. This gives `auto-fill-'. Another SPC at this point completes all the way to `auto-fill-mode'. The command that implements this behavior is called minibuffer-complete-word.

Here are some commands you can use to choose a completion from a window that displays a list of completions:

Mouse-2

Clicking mouse button 2 on a completion in the list of possible completions chooses that completion (mouse-choose-completion). You normally use this command while point is in the minibuffer, but you must click in the list of completions, not in the minibuffer itself.

PRIOR

M-v

Typing PRIOR or PAGE-UP, or M-v, while in the minibuffer, selects the window showing the completion list buffer (switch-to-completions). This paves the way for using the commands below. (Selecting that window in the usual ways has the same effect, but this way is more convenient.)

RET

Typing RET in the completion list buffer chooses the completion that point is in or next to (choose-completion). To use this command, you must first switch windows to the window that shows the list of completions.

RIGHT

Typing the right-arrow key RIGHT in the completion list buffer moves point to the following completion (next-completion).

LEFT

Typing the left-arrow key LEFT in the completion list buffer moves point toward the beginning of the buffer, to the previous completion (previous-completion).

E.3.3 Strict Completion

There are three different ways that RET can work in completing minibuffers, depending on how the argument will be used.

• Strict completion is used when it is meaningless to give any argument except one of the known alternatives. For example, when C-x k reads the name of a buffer to kill, it is meaningless to give anything but the name of an existing buffer. In strict completion, RET refuses to exit if the text in the minibuffer does not complete to an exact match.

• Cautious completion is similar to strict completion, except that RET exits only if the text was an exact match already, not needing completion. If the text is not an exact match, RET does not exit, but it does complete the text. If it completes to an exact match, a second RET will exit.

  Cautious completion is used for reading file names for files that must already exist.

• Permissive completion is used when any string whatever is meaningful, and the list of completion alternatives is just a guide. For example, when C-x C-f reads the name of a file to visit, any file name is allowed, in case you want to create a file. In permissive completion, RET takes the text in the minibuffer exactly as given, without completing it.

The completion commands display a list of all possible completions in a window whenever there is more than one possibility for the very next character. Also, typing ? explicitly requests such a list. If the list of completions is long, you can scroll it with C-M-v (see section O.3 Using Other Windows).

E.3.4 Completion Options

When completion is done on file names, certain file names are usually ignored. The variable completion-ignored-extensions contains a list of strings; a file whose name ends in any of those strings is ignored as a possible completion. The standard value of this variable has several elements including ".o", ".elc", ".dvi" and "~". The effect is that, for example, `foo' can complete to `foo.c' even though `foo.o' exists as well. However, if all the possible completions end in "ignored" strings, then they are not ignored. Ignored extensions do not apply to lists of completions--those always mention all possible completions.

Normally, a completion command that cannot determine even one additional character automatically displays a list of all possible completions. If the variable completion-auto-help is set to nil, this automatic display is disabled, so you must type ? to display the list of completions.

Partial Completion mode implements a more powerful kind of completion that can complete multiple words in parallel. For example, it can complete the command name abbreviation p-b into print-buffer, because no other command starts with two words whose initials are `p' and `b'.

Partial completion of directories in file names uses `*' to indicate the places for completion; thus, `/u*/b*/f*' might complete to `/usr/bin/foo'.

To enable this mode, use the command M-x partial-completion-mode, or customize the option partial-completion-mode. This binds the partial completion commands to TAB, SPC, RET, and ?. The usual completion commands are available on M-TAB, M-SPC, M-RET and M-?.

Another feature of Partial Completion mode is to extend find-file so that the `<include>' stands for the file named include in some directory in the path PC-include-file-path. If you set PC-disable-includes to non-nil, this feature is disabled.

Icomplete mode presents a constantly-updated display that tells you what completions are available for the text you've entered so far. The command to enable or disable this minor mode is M-x icomplete-mode.

E.4 Minibuffer History

Every argument that you enter with the minibuffer is saved on a minibuffer history list so that you can use it again later in another argument. Special commands load the text of an earlier argument in the minibuffer. They discard the old minibuffer contents, so you can think of them as moving through the history of previous arguments.

UP

M-p

Move to the next earlier argument string saved in the minibuffer history (previous-history-element).

DOWN

M-n

Move to the next later argument string saved in the minibuffer history (next-history-element).

M-r regexp RET

Move to an earlier saved argument in the minibuffer history that has a match for regexp (previous-matching-history-element).

M-s regexp RET

Move to a later saved argument in the minibuffer history that has a match for regexp (next-matching-history-element).

The simplest way to reuse the saved arguments in the history list is to move through the history list one element at a time. While in the minibuffer, use M-p or up-arrow (previous-history-element) to "move to" the next earlier minibuffer input, and use M-n or down-arrow (next-history-element) to "move to" the next later input.

The previous input that you fetch from the history entirely replaces the contents of the minibuffer. To use it as the argument, exit the minibuffer as usual with RET. You can also edit the text before you reuse it; this does not change the history element that you "moved" to, but your new argument does go at the end of the history list in its own right.

For many minibuffer arguments there is a "default" value. In some cases, the minibuffer history commands know the default value. Then you can insert the default value into the minibuffer as text by using M-n to move "into the future" in the history. Eventually we hope to make this feature available whenever the minibuffer has a default value.

There are also commands to search forward or backward through the history; they search for history elements that match a regular expression that you specify with the minibuffer. M-r (previous-matching-history-element) searches older elements in the history, while M-s (next-matching-history-element) searches newer elements. By special dispensation, these commands can use the minibuffer to read their arguments even though you are already in the minibuffer when you issue them. As with incremental searching, an upper-case letter in the regular expression makes the search case-sensitive (see section K.6 Searching and Case).

All uses of the minibuffer record your input on a history list, but there are separate history lists for different kinds of arguments. For example, there is a list for file names, used by all the commands that read file names. (As a special feature, this history list records the absolute file name, no more and no less, even if that is not how you entered the file name.)

There are several other very specific history lists, including one for command names read by M-x, one for buffer names, one for arguments of commands like query-replace, and one for compilation commands read by compile. Finally, there is one "miscellaneous" history list that most minibuffer arguments use.

The variable history-length specifies the maximum length of a minibuffer history list; once a list gets that long, the oldest element is deleted each time an element is added. If the value of history-length is t, though, there is no maximum length and elements are never deleted.

E.5 Repeating Minibuffer Commands

Every command that uses the minibuffer at least once is recorded on a special history list, together with the values of its arguments, so that you can repeat the entire command. In particular, every use of M-x is recorded there, since M-x uses the minibuffer to read the command name.

C-x ESC ESC

Re-execute a recent minibuffer command (repeat-complex-command).

M-x list-command-history

Display the entire command history, showing all the commands C-x ESC ESC can repeat, most recent first.

C-x ESC ESC is used to re-execute a recent minibuffer-using command. With no argument, it repeats the last such command. A numeric argument specifies which command to repeat; one means the last one, and larger numbers specify earlier ones.

C-x ESC ESC works by turning the previous command into a Lisp expression and then entering a minibuffer initialized with the text for that expression. If you type just RET, the command is repeated as before. You can also change the command by editing the Lisp expression. Whatever expression you finally submit is what will be executed. The repeated command is added to the front of the command history unless it is identical to the most recently executed command already there.

Even if you don't understand Lisp syntax, it will probably be obvious which command is displayed for repetition. If you do not change the text, it will repeat exactly as before.

Once inside the minibuffer for C-x ESC ESC, you can use the minibuffer history commands (M-p, M-n, M-r, M-s; see section E.4 Minibuffer History) to move through the history list of saved entire commands. After finding the desired previous command, you can edit its expression as usual and then resubmit it by typing RET as usual.

The list of previous minibuffer-using commands is stored as a Lisp list in the variable command-history. Each element is a Lisp expression which describes one command and its arguments. Lisp programs can re-execute a command by calling eval with the command-history element.

F. Running Commands by Name

Every Emacs command has a name that you can use to run it. Commands that are used often, or that must be quick to type, are also bound to keys--short sequences of characters--for convenient use. You can run them by name if you don't remember the keys. Other Emacs commands that do not need to be quick are not bound to keys; the only way to run them is by name. See section AD.4 Customizing Key Bindings, for the description of how to bind commands to keys.

By convention, a command name consists of one or more words, separated by hyphens; for example, auto-fill-mode or manual-entry. The use of English words makes the command name easier to remember than a key made up of obscure characters, even though it is more characters to type.

The way to run a command by name is to start with M-x, type the command name, and finish it with RET. M-x uses the minibuffer to read the command name. RET exits the minibuffer and runs the command. The string `M-x' appears at the beginning of the minibuffer as a prompt to remind you to enter the name of a command to be run. See section E. The Minibuffer, for full information on the features of the minibuffer.

You can use completion to enter the command name. For example, you can invoke the command forward-char by name by typing either

M-x forward-char RET

or

M-x forw TAB c RET

Note that forward-char is the same command that you invoke with the key C-f. You can run any Emacs command by name using M-x, whether or not any keys are bound to it.

If you type C-g while the command name is being read, you cancel the M-x command and get out of the minibuffer, ending up at top level.

To pass a numeric argument to the command you are invoking with M-x, specify the numeric argument before the M-x. M-x passes the argument along to the command it runs. The argument value appears in the prompt while the command name is being read.

If the command you type has a key binding of its own, Emacs mentions this in the echo area, two seconds after the command finishes (if you don't type anything else first). For example, if you type M-x forward-word, the message says that you can run the same command more easily by typing M-f. You can turn off these messages by setting suggest-key-bindings to nil.

Normally, when describing in this manual a command that is run by name, we omit the RET that is needed to terminate the name. Thus we might speak of M-x auto-fill-mode rather than M-x auto-fill-mode RET. We mention the RET only when there is a need to emphasize its presence, such as when we show the command together with following arguments.

M-x works by running the command execute-extended-command, which is responsible for reading the name of another command and invoking it.

G. Help

Emacs provides extensive help features accessible through a single character, C-h. C-h is a prefix key that is used for commands that display documentation. The characters that you can type after C-h are called help options. One help option is C-h; that is how you ask for help about using C-h. To cancel, type C-g. The function key F1 is equivalent to C-h.

C-h C-h (help-for-help) displays a list of the possible help options, each with a brief description. Before you type a help option, you can use SPC or DEL to scroll through the list.

C-h or F1 means "help" in various other contexts as well. For example, in the middle of query-replace, it describes the options available for how to operate on the current match. After a prefix key, it displays a list of the alternatives that can follow the prefix key. (A few prefix keys don't support C-h, because they define other meanings for it, but they all support F1.)

Most help buffers use a special major mode, Help mode, which lets you scroll conveniently with SPC and DEL. It also offers hyperlinks to further help regarding cross-referenced names, Info nodes, customization buffers and the like. See section G.7 Help Mode Commands.

If you are looking for a certain feature, but don't know where exactly it is documented, and aren't sure of the name of a related command or option, we recommend trying these methods. Usually it is best to start with an apropos command, then try searching the manual index, then finally look in the FAQ and the package keywords.

C-h a topic RET

This searches for commands whose names match topic, which should be a regular expression (see section K.5 Syntax of Regular Expressions). Browse the buffer that this command displays to find what you are looking for. See section G.4 Apropos.

M-x apropos RET topic RET

This works like C-h a, but it also searches for user options and other variables, in case the feature you are looking for is controlled by an option, not a command. See section G.4 Apropos.

M-x apropos-documentation RET topic RET

This searches the documentation strings (the built-in short descriptions) of all variables and functions (not their names) for a match for topic, a regular expression. See section G.4 Apropos.

C-h i d m emacs RET i topic RET

This looks up topic in the indices of the Emacs on-line manual. If there are several matches, Emacs displays the first one. You can then press , to move to other matches, until you find what you are looking for.

C-h i d m emacs RET s topic RET

Similar, but searches for topic (which can be a regular expression) in the text of the manual rather than in its indices.

C-h F

This brings up the Emacs FAQ, where you can use the usual search commands (see section K. Searching and Replacement) to find the information.

C-h p

Finally, you can try looking up a suitable package using keywords pertinent to the feature you need. See section G.5 Keyword Search for Lisp Libraries.

To find the documentation of a key sequence or a menu item, type C-h C-k and then type that key sequence or select the menu item. This looks up the description of the command invoked by the key or the menu in the appropriate manual (not necessarily the Emacs manual). Likewise, use C-h C-f for reading documentation of a command.

G.1 Help Summary		Brief list of all Help commands.
G.2 Documentation for a Key		Asking what a key does in Emacs.
G.3 Help by Command or Variable Name		Asking about a command, variable or function name.
G.4 Apropos		Asking what pertains to a given topic.
G.5 Keyword Search for Lisp Libraries		Finding Lisp libraries by keywords (topics).
G.6 Help for International Language Support		Help relating to international language support.
G.7 Help Mode Commands		Special features of Help mode and Help buffers.
G.8 Other Help Commands		Other help commands.
G.9 Help on Active Text and Tooltips		Help on active text and tooltips (`balloon help')

G.1 Help Summary

Here is a summary of the defined help commands.

C-h a regexp RET

Display a list of commands whose names match regexp (apropos-command).

C-h b

Display a table of all key bindings in effect now, in this order: minor mode bindings, major mode bindings, and global bindings (describe-bindings).

C-h c key

Show the name of the command that key runs (describe-key-briefly). Here c stands for "character." For more extensive information on key, use C-h k.

C-h f function RET

Display documentation on the Lisp function named function (describe-function). Since commands are Lisp functions, a command name may be used.

C-h h

Display the `HELLO' file, which shows examples of various character sets.

C-h i

Run Info, the program for browsing documentation files (info). The complete Emacs manual is available on-line in Info.

C-h k key

Display the name and documentation of the command that key runs (describe-key).

C-h l

Display a description of the last 100 characters you typed (view-lossage).

C-h m

Display documentation of the current major mode (describe-mode).

C-h n

Display documentation of Emacs changes, most recent first (view-emacs-news).

C-h P

Display info on known problems with Emacs and possible workarounds (view-emacs-problems).

C-h p

Find packages by topic keyword (finder-by-keyword).

C-h s

Display the current contents of the syntax table, plus an explanation of what they mean (describe-syntax). See section AD.6 The Syntax Table.

C-h t

Enter the Emacs interactive tutorial (help-with-tutorial).

C-h v var RET

Display the documentation of the Lisp variable var (describe-variable).

C-h w command RET

Show which keys run the command named command (where-is).

C-h C coding RET

Describe coding system coding (describe-coding-system).

C-h C RET

Describe the coding systems currently in use.

C-h I method RET

Describe an input method (describe-input-method).

C-h L language-env RET

Display information on the character sets, coding systems, and input methods used for language environment language-env (describe-language-environment).

C-h C-c

Display the copying conditions for GNU Emacs.

C-h C-d

Display information about getting new versions of GNU Emacs.

C-h C-f function RET

Enter Info and go to the node documenting the Emacs function function (Info-goto-emacs-command-node).

C-h C-k key

Enter Info and go to the node where the key sequence key is documented (Info-goto-emacs-key-command-node).

C-h C-p

Display information about the GNU Project.

C-h TAB symbol RET

Display the Info documentation on symbol symbol according to the programming language you are editing (info-lookup-symbol).

G.2 Documentation for a Key

The most basic C-h options are C-h c (describe-key-briefly) and C-h k (describe-key). C-h c key displays in the echo area the name of the command that key is bound to. For example, C-h c C-f displays `forward-char'. Since command names are chosen to describe what the commands do, this is a good way to get a very brief description of what key does.

C-h k key is similar but gives more information: it displays the documentation string of the command as well as its name. This is too big for the echo area, so a window is used for the display.

C-h c and C-h k work for any sort of key sequences, including function keys and mouse events.

G.3 Help by Command or Variable Name

C-h f (describe-function) reads the name of a Lisp function using the minibuffer, then displays that function's documentation string in a window. Since commands are Lisp functions, you can use this to get the documentation of a command that you know by name. For example,

C-h f auto-fill-mode RET

displays the documentation of auto-fill-mode. This is the only way to get the documentation of a command that is not bound to any key (one which you would normally run using M-x).

C-h f is also useful for Lisp functions that you are planning to use in a Lisp program. For example, if you have just written the expression (make-vector len) and want to check that you are using make-vector properly, type C-h f make-vector RET. Because C-h f allows all function names, not just command names, you may find that some of your favorite abbreviations that work in M-x don't work in C-h f. An abbreviation may be unique among command names yet fail to be unique when other function names are allowed.

The default function name for C-h f to describe, if you type just RET, is the name of the function called by the innermost Lisp expression in the buffer around point, provided that is a valid, defined Lisp function name. For example, if point is located following the text `(make-vector (car x)', the innermost list containing point is the one that starts with `(make-vector', so the default is to describe the function make-vector.

C-h f is often useful just to verify that you have the right spelling for the function name. If C-h f mentions a name from the buffer as the default, that name must be defined as a Lisp function. If that is all you want to know, just type C-g to cancel the C-h f command, then go on editing.

C-h w command RET tells you what keys are bound to command. It displays a list of the keys in the echo area. If it says the command is not on any key, you must use M-x to run it. C-h w runs the command where-is.

C-h v (describe-variable) is like C-h f but describes Lisp variables instead of Lisp functions. Its default is the Lisp symbol around or before point, but only if that is the name of a known Lisp variable. See section AD.2 Variables.

Help buffers describing variables or functions defined in Lisp normally have hyperlinks to the Lisp definition, if you have the Lisp source files installed. If you know Lisp, this provides the ultimate documentation. If you don't know Lisp, you should learn it. If you are treating Emacs as an object file, then you are just using Emacs. For real intimacy with Emacs, you must read the source code.

G.4 Apropos

A more sophisticated sort of question to ask is, "What are the commands for working with files?" To ask this question, type C-h a file RET, which displays a list of all command names that contain `file', including copy-file, find-file, and so on. With each command name appears a brief description of how to use the command, and what keys you can currently invoke it with. For example, it would say that you can invoke find-file by typing C-x C-f. The a in C-h a stands for "Apropos"; C-h a runs the command apropos-command. This command normally checks only commands (interactive functions); if you specify a prefix argument, it checks noninteractive functions as well.

Because C-h a looks only for functions whose names contain the string you specify, you must use ingenuity in choosing the string. If you are looking for commands for killing backwards and C-h a kill-backwards RET doesn't reveal any, don't give up. Try just kill, or just backwards, or just back. Be persistent. Also note that you can use a regular expression as the argument, for more flexibility (see section K.5 Syntax of Regular Expressions).

Here is a set of arguments to give to C-h a 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.

char, line, word, sentence, paragraph, region, page, sexp, list, defun, rect, buffer, frame, window, face, file, dir, register, mode, beginning, end, forward, backward, next, previous, up, down, search, goto, kill, delete, mark, insert, yank, fill, indent, case, change, set, what, list, find, view, describe, default.

To list all user variables that match a regexp, use the command M-x apropos-variable. This command shows only user variables and customization options by default; if you specify a prefix argument, it checks all variables.

To list all Lisp symbols that contain a match for a regexp, not just the ones that are defined as commands, use the command M-x apropos instead of C-h a. This command does not check key bindings by default; specify a numeric argument if you want it to check them.

The apropos-documentation command is like apropos except that it searches documentation strings as well as symbol names for matches for the specified regular expression.

The apropos-value command is like apropos except that it searches symbols' values for matches for the specified regular expression. This command does not check function definitions or property lists by default; specify a numeric argument if you want it to check them.

If the variable apropos-do-all is non-nil, the commands above all behave as if they had been given a prefix argument.

If you want more information about a function definition, variable or symbol property listed in the Apropos buffer, you can click on it with Mouse-2 or move there and type RET.

G.5 Keyword Search for Lisp Libraries

The C-h p command lets you search the standard Emacs Lisp libraries by topic keywords. Here is a partial list of keywords you can use:

abbrev --- abbreviation handling, typing shortcuts, macros. bib --- support for the bibliography processor bib. c --- C and C++ language support. calendar --- calendar and time management support. comm --- communications, networking, remote access to files. data --- support for editing files of data. docs --- support for Emacs documentation. emulations --- emulations of other editors. extensions --- Emacs Lisp language extensions. faces --- support for using faces (fonts and colors; see section J.1 Using Multiple Typefaces). frames --- support for Emacs frames and window systems. games --- games, jokes and amusements. hardware --- support for interfacing with exotic hardware. help --- support for on-line help systems. hypermedia --- support for links within text, or other media types. i18n --- internationalization and alternate character-set support. internal --- code for Emacs internals, build process, defaults. languages --- specialized modes for editing programming languages. lisp --- support for using Lisp (including Emacs Lisp). local --- libraries local to your site. maint --- maintenance aids for the Emacs development group. mail --- modes for electronic-mail handling. matching --- searching and matching. news --- support for netnews reading and posting. non-text --- support for editing files that are not ordinary text. oop --- support for object-oriented programming. outlines --- hierarchical outlining. processes --- process, subshell, compilation, and job control support. terminals --- support for terminal types. tex --- support for the TeX formatter. tools --- programming tools. unix --- front-ends/assistants for, or emulators of, system features. vms --- support code for VMS. wp --- word processing.

G.6 Help for International Language Support

You can use the command C-h L (describe-language-environment) to find out information about the support for a specific language environment. See section Q.3 Language Environments. This tells you which languages this language environment is useful for, and lists the character sets, coding systems, and input methods that go with it. It also shows some sample text to illustrate scripts.

The command C-h h (view-hello-file) displays the file `etc/HELLO', which shows how to say "hello" in many languages.

The command C-h I (describe-input-method) describes information about input methods--either a specified input method, or by default the input method in use. See section Q.4 Input Methods.

The command C-h C (describe-coding-system) describes information about coding systems--either a specified coding system, or the ones currently in use. See section Q.7 Coding Systems.

G.7 Help Mode Commands

Help buffers provide the same commands as View mode (see section M.10 Miscellaneous File Operations), plus a few special commands of their own.

SPC

Scroll forward.

DEL

BS

Scroll backward. On some keyboards, this key is known as BS or backspace.

RET

Follow a cross reference at point.

TAB

Move point forward to the next cross reference.

S-TAB

Move point back to the previous cross reference.

Mouse-2

Follow a cross reference that you click on.

When a command name (see section Running Commands by Name) or variable name (see section AD.2 Variables) appears in the documentation, it normally appears inside paired single-quotes. You can click on the name with Mouse-2, or move point there and type RET, to view the documentation of that command or variable. Use C-c C-b to retrace your steps.

There are convenient commands for moving point to cross references in the help text. TAB (help-next-ref) moves point down to the next cross reference. Use S-TAB to move point up to the previous cross reference (help-previous-ref).

G.8 Other Help Commands

C-h i (info) runs the Info program, which is used for browsing through structured documentation files. The entire Emacs manual is available within Info. Eventually all the documentation of the GNU system will be available. Type h after entering Info to run a tutorial on using Info.

If you specify a numeric argument, C-h i prompts for the name of a documentation file. This way, you can browse a file which doesn't have an entry in the top-level Info menu. It is also handy when you need to get to the documentation quickly, and you know the exact name of the file.

There are two special help commands for accessing Emacs documentation through Info. C-h C-f function RET enters Info and goes straight to the documentation of the Emacs function function. C-h C-k key enters Info and goes straight to the documentation of the key key. These two keys run the commands Info-goto-emacs-command-node and Info-goto-emacs-key-command-node. You can use C-h C-k to find the documentation of a menu item: just select that menu item when C-h C-k prompts for a key.

C-h C-f and C-h C-k know about commands and keys described in manuals other than the Emacs manual. Thus, they make it easier to find the documentation of commands and keys when you are not sure which manual describes them, like when using some specialized mode.

When editing a program, if you have an Info version of the manual for the programming language, you can use the command C-h C-i to refer to the manual documentation for a symbol (keyword, function or variable). The details of how this command works depend on the major mode.

If something surprising happens, and you are not sure what commands you typed, use C-h l (view-lossage). C-h l displays the last 100 command characters you typed in. If you see commands that you don't know, you can use C-h c to find out what they do.

Emacs has numerous major modes, each of which redefines a few keys and makes a few other changes in how editing works. C-h m (describe-mode) displays documentation on the current major mode, which normally describes all the commands that are changed in this mode.

C-h b (describe-bindings) and C-h s (describe-syntax) present other information about the current Emacs mode. C-h b displays a list of all the key bindings now in effect, showing the local bindings defined by the current minor modes first, then the local bindings defined by the current major mode, and finally the global bindings (see section AD.4 Customizing Key Bindings). C-h s displays the contents of the syntax table, with explanations of each character's syntax (see section AD.6 The Syntax Table).

You can get a similar list for a particular prefix key by typing C-h after the prefix key. (There are a few prefix keys for which this does not work--those that provide their own bindings for C-h. One of these is ESC, because ESC C-h is actually C-M-h, which marks a defun.)

The other C-h options display various files containing useful information. C-h C-w displays the full details on the complete absence of warranty for GNU Emacs. C-h n (view-emacs-news) displays the file `emacs/etc/NEWS', which contains documentation on Emacs changes arranged chronologically. C-h F (view-emacs-FAQ) displays the Emacs frequently-answered-questions list. C-h t (help-with-tutorial) displays the learn-by-doing Emacs tutorial. C-h C-c (describe-copying) displays the file `emacs/etc/COPYING', which tells you the conditions you must obey in distributing copies of Emacs. C-h C-d (describe-distribution) displays the file `emacs/etc/DISTRIB', which tells you how you can order a copy of the latest version of Emacs. C-h C-p (describe-project) displays general information about the GNU Project. C-h P (view-emacs-problems) displays the file `emacs/etc/PROBLEMS', which lists known problems with Emacs in various situations with solutions or workarounds in many cases.

G.9 Help on Active Text and Tooltips

When a region of text is "active," so that you can select it with the mouse or a key like RET, it often has associated help text. Areas of the mode line are examples. This help will normally be shown in the echo area when you move point into the active text. In a window system you can display the help text as a "tooltip" (sometimes known as "balloon help"). See section P.18 Tooltips (or "Balloon Help").

H. The Mark and the Region

Many Emacs commands operate on an arbitrary contiguous part of the current buffer. To specify the text for such a command to operate on, you set the mark at one end of it, and move point to the other end. The text between point and the mark is called the region. Emacs highlights the region whenever there is one, if you enable Transient Mark mode (see section H.2 Transient Mark Mode).

Certain Emacs commands set the mark; other editing commands do not affect it, so the mark remains where you set it last. Each Emacs buffer has its own mark, and setting the mark in one buffer has no effect on other buffers' marks. When you return to a buffer that was current earlier, its mark is at the same place as before.

The ends of the region are always point and the mark. It doesn't matter which of them was put in its current place first, or which one comes earlier in the text--the region starts from point or the mark (whichever comes first), and ends at point or the mark (whichever comes last). Every time you move point, or set the mark in a new place, the region changes.

Many commands that insert text, such as C-y (yank) and M-x insert-buffer, position point and the mark at opposite ends of the inserted text, so that the region consists of the text just inserted.

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, each buffer remembers 16 previous locations of the mark in the mark ring.

H.1 Setting the Mark		Commands to set the mark.
H.2 Transient Mark Mode		How to make Emacs highlight the region-- when there is one.
H.3 Operating on the Region		Summary of ways to operate on contents of the region.
H.4 Commands to Mark Textual Objects		Commands to put region around textual units.
H.5 The Mark Ring		Previous mark positions saved so you can go back there.
H.6 The Global Mark Ring		Previous mark positions in various buffers.

H.1 Setting the Mark

Here are some commands for setting the mark:

C-SPC

Set the mark where point is (set-mark-command).

C-@

The same.

C-x C-x

Interchange mark and point (exchange-point-and-mark).

Drag-Mouse-1

Set point and the mark around the text you drag across.

Mouse-3

Set the mark where point is, then move point to where you click (mouse-save-then-kill).

For example, suppose you wish to convert part of the buffer to upper case, using the C-x C-u (upcase-region) command, which operates on the text in the region. You can first go to the beginning of the text to be capitalized, type C-SPC to 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.

The most common way to set the mark is with the C-SPC command (set-mark-command). This sets the mark where point is. Then you can move point away, leaving the mark behind.

There are two ways to set the mark with the mouse. You can drag mouse button one across a range of text; that puts point where you release the mouse button, and sets the mark at the other end of that range. Or you can click mouse button three, which sets the mark at point (like C-SPC) and then moves point (like Mouse-1). Both of these methods copy the region into the kill ring in addition to setting the mark; that gives behavior consistent with other window-driven applications, but if you don't want to modify the kill ring, you must use keyboard commands to set the mark. See section P.1 Mouse Commands for Editing.

Ordinary terminals have only one cursor, so 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. Alternatively, you can see where the mark is with the command C-x C-x (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 position of the mark. In Transient Mark mode, this command reactivates the mark.

C-x C-x is also useful when you are satisfied with the position of point but want to move the other end of the region (where the mark is); do C-x C-x to put point at that end of the region, and then move it. Using C-x C-x a second time, if necessary, puts the mark at the new position with point back at its original position.

For more facilities that allow you to go to previously set marks, see H.5 The Mark Ring.

There is no such character as C-SPC in ASCII; when you type SPC while holding down CTRL, what you get on most ordinary terminals is the character C-@. This key is actually bound to set-mark-command. But unless you are unlucky enough to have a terminal where typing C-SPC does not produce C-@, you might as well think of this character as C-SPC. Under X, C-SPC is actually a distinct character, but its binding is still set-mark-command.

H.2 Transient Mark Mode

On a terminal that supports colors, Emacs can highlight the current region. But normally it does not. Why not?

Highlighting the region whenever it exists would not be desirable in Emacs, because once you have set a mark, there is always a region (in that buffer). And highlighting the region all the time would be a nuisance. So normally Emacs highlights the region only immediately after you have selected one with the mouse.

You can turn on region highlighting by enabling Transient Mark mode. This is a more rigid mode of operation in which the region "lasts" only temporarily, so you must set up a region for each command that uses one. In Transient Mark mode, most of the time there is no region; therefore, highlighting the region when it exists is useful and not annoying.

To enable Transient Mark mode, type M-x transient-mark-mode. This command toggles the mode, so you can repeat the command to turn off the mode.

Here are the details of Transient Mark mode:

• To set the mark, type C-SPC (set-mark-command). This makes the mark active and thus begins highlighting of the region. As you move point, you will see the highlighted region grow and shrink.

• The mouse commands for specifying the mark also make it active. So do keyboard commands whose purpose is to specify a region, including M-@, C-M-@, M-h, C-M-h, C-x C-p, and C-x h.

• When the mark is active, you can execute commands that operate on the region, such as killing, indenting, or writing to a file.

• Any change to the buffer, such as inserting or deleting a character, deactivates the mark. This means any subsequent command that operates on a region will get an error and refuse to operate. You can make the region active again by typing C-x C-x.

• Commands like M-> and C-s, that "leave the mark behind" in addition to some other primary purpose, do not activate the new mark. You can activate the new region by executing C-x C-x (exchange-point-and-mark).

• C-s when the mark is active does not alter the mark.

• Quitting with C-g deactivates the mark.

• Some commands operate on the region whenever it is active. For instance, C-x u in Transient Mark mode operates on the region when there is a region. Outside Transient Mark mode, you must type C-u C-x u if you want it to operate on the region. See section D.4 Undoing Changes. Other commands that act this way are identified in their own documentation.

The highlighting of the region uses the region face; you can customize the appearance of the highlighted region by changing this face. See section AD.2.2.3 Customizing Faces.

When multiple windows show the same buffer, they can have different regions, because they can have different values of point (though they all share one common mark position). Ordinarily, only the selected window highlights its region (see section O. Multiple Windows). However, if the variable highlight-nonselected-windows is non-nil, then each window highlights its own region (provided that Transient Mark mode is enabled and the mark in the window's buffer is active).

When Transient Mark mode is not enabled, every command that sets the mark also activates it, and nothing ever deactivates it.

If the variable mark-even-if-inactive is non-nil in Transient Mark mode, then commands can use the mark and the region even when it is inactive. Region highlighting appears and disappears just as it normally does in Transient Mark mode, but the mark doesn't really go away when the highlighting disappears.

Transient Mark mode is also sometimes known as "Zmacs mode" because the Zmacs editor on the MIT Lisp Machine handled the mark in a similar way.

H.3 Operating on the Region

Once you have a region and the mark is active, here are some of the ways you can operate on the region:

• Kill it with C-w (see section H.7 Deletion and Killing).
• Save it in a register with C-x r s (see section I. Registers).
• Save it in a buffer or a file (see section H.9 Accumulating Text).
• Convert case with C-x C-l or C-x C-u (see section T.6 Case Conversion Commands).
• Indent it with C-x TAB or C-M-\ (see section S. Indentation).
• Fill it as text with M-x fill-region (see section T.5 Filling Text).
• Print hardcopy with M-x print-region (see section AC.18 Hardcopy Output).
• Evaluate it as Lisp code with M-x eval-region (see section V.8 Evaluating Emacs-Lisp Expressions).

Most commands that operate on the text in the region have the word region in their names.

H.4 Commands to Mark Textual Objects

Here are the commands for placing point and the mark around a textual object such as a word, list, paragraph or page.

M-@

Set mark after end of next word (mark-word). This command and the following one do not move point.

C-M-@

Set mark after end of following balanced expression (mark-sexp).

M-h

Put region around current paragraph (mark-paragraph).

C-M-h

Put region around current defun (mark-defun).

C-x h

Put region around the entire buffer (mark-whole-buffer).

C-x C-p

Put region around current page (mark-page).

M-@ (mark-word) puts the mark at the end of the next word, while C-M-@ (mark-sexp) puts it at the end of the next balanced expression (see section U.4.1 Expressions with Balanced Parentheses). These commands handle arguments just like M-f and C-M-f.

Other commands set both point and mark, to delimit an object in the buffer. For example, M-h (mark-paragraph) moves point to the beginning of the paragraph that surrounds or follows point, and puts the mark at the end of that paragraph (see section T.3 Paragraphs). It prepares the region so you can indent, case-convert, or kill a whole paragraph.

C-M-h (mark-defun) similarly puts point before, and the mark after, the current (or following) major top-level definition, or defun (see section U.2.2 Moving by Defuns). C-x C-p (mark-page) puts point before the current page, and mark at the end (see section T.4 Pages). The mark goes after the terminating page delimiter (to include it in the region), while point goes after the preceding page delimiter (to exclude it). A numeric argument specifies a later page (if positive) or an earlier page (if negative) instead of the current page.

Finally, C-x h (mark-whole-buffer) sets up the entire buffer as the region, by putting point at the beginning and the mark at the end.

In Transient Mark mode, all of these commands activate the mark.

H.5 The Mark Ring

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, each buffer remembers 16 previous locations of the mark, in the mark ring. Commands that set the mark also push the old mark onto this ring. To return to a marked location, use C-u C-SPC (or C-u C-@); this is the command set-mark-command given a numeric argument. It moves point to where the mark was, and restores the mark from the ring of former marks. Thus, repeated use of this command moves point to all of the old marks on the ring, one by one. The mark positions you move through in this way are not lost; they go to the end of the ring.

Each buffer has its own mark ring. All editing commands use the current buffer's mark ring. In particular, C-u C-SPC always stays in the same buffer.

Many commands that can move long distances, such as M-< (beginning-of-buffer), start by setting the mark and saving the old mark on the mark ring. This is to make it easier for you to move back later. Searches set the mark if they move point. You can tell when a command sets the mark because it displays `Mark set' in the echo area.

If you want to move back to the same place over and over, the mark ring may not be convenient enough. If so, you can record the position in a register for later retrieval (see section Saving Positions in Registers).

The variable mark-ring-max specifies the maximum number of entries to keep in the mark ring. If that many entries exist and another one is pushed, the earliest one in the list is discarded. Repeating C-u C-SPC cycles through the positions currently in the ring.

The variable mark-ring holds the mark ring itself, as a list of marker objects, with the most recent first. This variable is local in every buffer.

H.6 The Global Mark Ring

In addition to the ordinary mark ring that belongs to each buffer, Emacs has a single global mark ring. It records a sequence of buffers in which you have recently set the mark, so you can go back to those buffers.

Setting the mark always makes an entry on the current buffer's mark ring. If you have switched buffers since the previous mark setting, the new mark position makes an entry on the global mark ring also. The result is that the global mark ring records a sequence of buffers that you have been in, and, for each buffer, a place where you set the mark.

The command C-x C-SPC (pop-global-mark) jumps to the buffer and position of the latest entry in the global ring. It also rotates the ring, so that successive uses of C-x C-SPC take you to earlier and earlier buffers.

H.7 Deletion and Killing

Most commands which erase text from the buffer save it in the kill ring so that you can 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 in the kill ring; they are known as delete commands. (This distinction is made only for erasure of text in the buffer.) If you do a kill or delete command by mistake, you can use the C-x u (undo) command to undo it (see section D.4 Undoing Changes).

You cannot kill read-only text, since such text does not allow any kind of modification. But some users like to use the kill commands to copy read-only text into the kill ring, without actually changing it. If you set the variable kill-read-only-ok to a non-nil value, the kill commands work specially in a read-only buffer: they move over text, and copy it to the kill ring, without actually deleting it from the buffer. When this happens, a message in the echo area tells you what is happening.

The delete commands include C-d (delete-char) and DEL (delete-backward-char), which delete only one character at a time, and those commands that delete only spaces or newlines. Commands that can destroy significant amounts of nontrivial data generally do a kill operation instead. The commands' names and individual descriptions use the words `kill' and `delete' to say which kind of operation they perform.

Many window systems follow the convention that insertion while text is selected deletes the selected text. You can make Emacs behave this way by enabling Delete Selection mode, with M-x delete-selection-mode, or using Custom. Another effect of this mode is that DEL, C-d and some other keys, when a selection exists, will kill the whole selection. It also enables Transient Mark mode (see section H.2 Transient Mark Mode).

H.7.1 Deletion		Commands for deleting small amounts of text and blank areas.
H.7.2 Killing by Lines		How to kill entire lines of text at one time.
H.7.3 Other Kill Commands		Commands to kill large regions of text and syntactic units such as words and sentences.

H.7.1 Deletion

Deletion means erasing text and not saving it in the kill ring. For the most part, the Emacs commands that delete text are those that erase just one character or only whitespace.

C-d

Delete

Delete next character (delete-char). If your keyboard has a Delete function key (usually located in the edit keypad), Emacs binds it to delete-char as well.

DEL

BS

Delete previous character (delete-backward-char). Some keyboards refer to this key as a "backspace key" and label it with a left arrow.

M-\

Delete spaces and tabs around point (delete-horizontal-space).

M-SPC

Delete spaces and tabs around point, leaving one space (just-one-space).

C-x C-o

Delete blank lines around the current line (delete-blank-lines).

M-^

Join two lines by deleting the intervening newline, along with any indentation following it (delete-indentation).

The most basic delete commands are C-d (delete-char) and DEL (delete-backward-char). C-d deletes the character after point, the one the cursor is "on top of." This doesn't move point. DEL deletes the character before the cursor, and moves point back. You can delete newlines like any other characters in the buffer; deleting a newline joins two lines. Actually, C-d and DEL aren't always delete commands; when given arguments, they kill instead, since they can erase more than one character this way.

Every keyboard has a large key, labeled DEL, BACKSPACE, BS or DELETE, which is a short distance above the RET or ENTER key and is normally used for erasing what you have typed. Regardless of the actual name on the key, in Emacs it is equivalent to DEL---or it should be.

Many keyboards (including standard PC keyboards) have a BACKSPACE key a short ways above RET or ENTER, and a DELETE key elsewhere. In that case, the BACKSPACE key is DEL, and the DELETE key is equivalent to C-d---or it should be.

Why do we say "or it should be"? When Emacs starts up using a window system, it determines automatically which key or keys should be equivalent to DEL. As a result, BACKSPACE and/or DELETE keys normally do the right things. But in some unusual cases Emacs gets the wrong information from the system. If these keys don't do what they ought to do, you need to tell Emacs which key to use for DEL. See section AD.9.1 If DEL Fails to Delete, for how to do this.

On most text-only terminals, Emacs cannot tell which keys the keyboard really has, so it follows a uniform plan which may or may not fit your keyboard. The uniform plan is that the ASCII DEL character deletes, and the ASCII BS (backspace) character asks for help (it is the same as C-h). If this is not right for your keyboard, such as if you find that the key which ought to delete backwards enters Help instead, see AD.9.1 If DEL Fails to Delete.

The other delete commands are those which delete only whitespace characters: spaces, tabs and newlines. M-\ (delete-horizontal-space) deletes all the spaces and tab characters before and after point. M-SPC (just-one-space) does likewise but leaves a single space after point, regardless of the number of spaces that existed previously (even if there were none before).

C-x C-o (delete-blank-lines) deletes all blank lines after the current line. If the current line is blank, it deletes all blank lines preceding the current line as well (leaving one blank line, the current line).

M-^ (delete-indentation) joins the current line and the previous line, by deleting a newline and all surrounding spaces, usually leaving a single space. See section M-^.

H.7.2 Killing by Lines

C-k

Kill rest of line or one or more lines (kill-line).

The simplest kill command is C-k. If given at the beginning of a line, it kills all the text on the line, leaving it blank. When used on a blank line, it kills the whole line including its newline. To kill an entire non-blank line, go to the beginning and type C-k twice.

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 newline following point, thus merging the next line into the current one. Spaces and tabs that you can't see 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 C-k will kill the newline.

When C-k is given a positive argument, it kills that many lines and the newlines that follow them (however, text on the current line before point is not killed). With a negative argument -n, it kills n lines preceding the current line (together with the text on the current line before point). Thus, C-u - 2 C-k at the front of a line kills the two previous lines.

C-k with an argument of zero kills the text before point on the current line.

If the variable kill-whole-line is non-nil, C-k at the very beginning of a line kills the entire line including the following newline. This variable is normally nil.

H.7.3 Other Kill Commands

C-w

Kill region (from point to the mark) (kill-region).

M-d

Kill word (kill-word). See section T.1 Words.

M-DEL

Kill word backwards (backward-kill-word).

C-x DEL

Kill back to beginning of sentence (backward-kill-sentence). See section T.2 Sentences.

M-k

Kill to end of sentence (kill-sentence).

C-M-k

Kill the following balanced expression (kill-sexp). See section U.4.1 Expressions with Balanced Parentheses.

M-z char

Kill through the next occurrence of char (zap-to-char).

A kill command which is very general is C-w (kill-region), which kills everything between point and the mark. With this command, you can kill any contiguous sequence of characters, if you first set the region around them.

A convenient way of killing is combined with searching: M-z (zap-to-char) reads a character and kills from point up to (and including) the next occurrence of that character in the buffer. A numeric argument acts as a repeat count. A negative argument means to search backward and kill text before point.

Other syntactic units can be killed: words, with M-DEL and M-d (see section T.1 Words); balanced expressions, with C-M-k (see section U.4.1 Expressions with Balanced Parentheses); and sentences, with C-x DEL and M-k (see section T.2 Sentences).

You can use kill commands in read-only buffers. They don't actually change the buffer, and they beep to warn you of that, but they do copy the text you tried to kill into the kill ring, so you can yank it into other buffers. Most of the kill commands move point across the text they copy in this way, so that successive kill commands build up a single kill ring entry as usual.

H.8 Yanking

Yanking means reinserting text previously killed. This is what some systems call "pasting." The usual way to move or copy text is to kill it and then yank it elsewhere one or more times.

C-y

Yank last killed text (yank).

M-y

Replace text just yanked with an earlier batch of killed text (yank-pop).

M-w

Save region as last killed text without actually killing it (kill-ring-save).

C-M-w

Append next kill to last batch of killed text (append-next-kill).

H.8.1 The Kill Ring		Where killed text is stored. Basic yanking.
H.8.2 Appending Kills		Several kills in a row all yank together.
H.8.3 Yanking Earlier Kills		Yanking something killed some time ago.

H.8.1 The Kill Ring

All killed text is recorded in the kill ring, a list of blocks of text that have been killed. There is only one kill ring, shared by all buffers, so you can kill text in one buffer and yank it in another buffer. This is the usual way to move text from one file to another. (See section H.9 Accumulating Text, for some other ways.)

The command C-y (yank) reinserts the text of the most recent kill. It leaves the cursor at the end of the text. It sets the mark at the beginning of the text. See section H. The Mark and the Region.

C-u C-y leaves the cursor in front of the text, and sets the mark after it. This happens only if the argument is specified with just a C-u, precisely. Any other sort of argument, including C-u and digits, specifies an earlier kill to yank (see section H.8.3 Yanking Earlier Kills).

To copy a block of text, you can use M-w (kill-ring-save), which copies the region into the kill ring without removing it from the buffer. This is approximately equivalent to C-w followed by C-x u, except that M-w does not alter the undo history and does not temporarily change the screen.

H.8.2 Appending Kills

Normally, each kill command pushes a new entry onto the kill ring. However, two or more kill commands in a row combine their text into a single entry, so that a single C-y yanks all the text as a unit, just as it was before it was killed.

Thus, if you want to yank text as a unit, you need not kill all of it with 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.

Commands that kill forward from point add onto the end of the previous killed text. Commands that kill backward from point add text onto the beginning. This way, any sequence of mixed forward and backward kill commands puts all the killed text into one entry without rearrangement. Numeric arguments do not break the sequence of appending kills. For example, suppose the buffer contains this text:

This is a line -!-of sample text.

with point shown by -!-. If you type M-d M-DEL M-d M-DEL, killing alternately forward and backward, you end up with `a line of sample' as one entry in the kill ring, and `This is text.' in the buffer. (Note the double space between `is' and `text', which you can clean up with M-SPC or M-q.)

Another way to kill the same text is to move back two words with M-b M-b, then kill all four words forward with C-u M-d. This produces exactly the same results in the buffer and in the kill ring. M-f M-f C-u M-DEL kills the same text, all going backward; once again, the result is the same. The text in the kill ring entry always has the same order that it had in the buffer before you killed it.

If a kill command is separated from the last kill command by other commands (not just numeric arguments), it starts a new entry on the kill ring. But you can force it to append by first typing the command C-M-w (append-next-kill) right before 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 several separated pieces of text and accumulate them to be yanked back in one place.

A kill command following M-w does not append to the text that M-w copied into the kill ring.

H.8.3 Yanking Earlier Kills

To recover killed text that is no longer the most recent kill, use the M-y command (yank-pop). It takes the text previously yanked and replaces it with the text from an earlier kill. So, to recover the text of the next-to-the-last kill, first use C-y to yank the last kill, and then use M-y to replace it with the previous kill. M-y is allowed only after a C-y or another M-y.

You can understand M-y in terms of a "last yank" pointer which points at an entry in the kill ring. Each time you kill, the "last yank" pointer moves to the newly made entry at the front of the ring. C-y yanks the entry which the "last yank" pointer points to. M-y moves the "last yank" pointer to a different entry, and the text in the buffer changes to match. Enough M-y commands can move the pointer to any entry in the ring, so you can get any entry into the buffer. Eventually the pointer reaches the end of the ring; the next M-y loops back around to the first entry again.

M-y moves the "last yank" pointer around the ring, but it does not change the order of the entries in the ring, which always runs from the most recent kill at the front to the oldest one still remembered.

M-y can take a numeric argument, which tells it how many entries to advance the "last yank" pointer by. A negative argument moves the pointer toward the front of the ring; from the front of the ring, it moves "around" to the last entry and continues forward from there.

Once the text you are looking for is brought into the buffer, you can stop doing M-y commands and it will stay there. It's just a copy of the kill ring entry, so editing it in the buffer does not change what's in the ring. As long as no new killing is done, the "last yank" pointer remains at the same place in the kill ring, so repeating C-y will yank another copy of the same previous kill.

If you know how many M-y commands it would take to find the text you want, you can yank that text in one step using C-y with a numeric argument. C-y with an argument restores the text from the specified kill ring entry, counting back from the most recent as 1. Thus, C-u 2 C-y gets the next-to-the-last block of killed text--it is equivalent to C-y M-y. C-y with a numeric argument starts counting from the "last yank" pointer, and sets the "last yank" pointer to the entry that it yanks.

The length of the kill ring is controlled by the variable kill-ring-max; no more than that many blocks of killed text are saved.

The actual contents of the kill ring are stored in a variable named kill-ring; you can view the entire contents of the kill ring with the command C-h v kill-ring.

H.9 Accumulating Text

Usually we copy or move text by killing it and yanking it, but there are other methods convenient for copying one block of text in many places, or for copying many scattered blocks of text into one place. To copy one block to many places, store it in a register (see section I. Registers). Here we describe the commands to accumulate scattered pieces of text into a buffer or into a file.

M-x append-to-buffer

Append region to the contents of a specified buffer.

M-x prepend-to-buffer

Prepend region to the contents of a specified buffer.

M-x copy-to-buffer

Copy region into a specified buffer, deleting that buffer's old contents.

M-x insert-buffer

Insert the contents of a specified buffer into current buffer at point.

M-x append-to-file

Append region to the contents of a specified file, at the end.

To accumulate text into a buffer, use M-x append-to-buffer. This reads a buffer name, then inserts a copy of the region into the buffer specified. If you specify a nonexistent buffer, append-to-buffer creates the buffer. The text is inserted wherever point is in that buffer. If you have been using the buffer for editing, the copied text goes into the middle of the text of the buffer, starting from wherever point happens to be at that moment.

Point in that buffer is left at the end of the copied text, so successive uses of append-to-buffer accumulate the text in the specified buffer in the same order as they were copied. Strictly speaking, append-to-buffer does not always append to the text already in the buffer--it appends only if point in that buffer is at the end. However, if append-to-buffer is the only command you use to alter a buffer, then point is always at the end.

M-x prepend-to-buffer is just like append-to-buffer except that point in the other buffer is left before the copied text, so successive prependings add text in reverse order. M-x copy-to-buffer is similar, except that any existing text in the other buffer is deleted, so the buffer is left containing just the text newly copied into it.

To retrieve the accumulated text from another buffer, use the command M-x insert-buffer; this too takes buffername as an argument. It inserts a copy of the whole text in buffer buffername into the current buffer at point, and sets the mark after the inserted text. Alternatively, you can select the other buffer for editing, then copy text from it by killing. See section N. Using Multiple Buffers, for background information on buffers.

Instead of accumulating text within Emacs, in a buffer, you can append text directly into a file with M-x append-to-file, which takes filename as an argument. It adds the text of the region to the end of the specified file. The file is changed immediately on disk.

You should use append-to-file only with files that are not being visited in Emacs. Using it on a file that you are editing in Emacs would change the file behind Emacs's back, which can lead to losing some of your editing.

H.10 Rectangles

The rectangle commands operate on rectangular areas of the text: all the characters between a certain pair of columns, in a certain range of lines. Commands are provided to kill rectangles, yank killed rectangles, clear them out, fill them with blanks or text, or delete them. Rectangle commands are useful with text in multicolumn formats, and for changing text into or out of such formats.

When you must specify a rectangle for a command to work on, you do it by putting the mark at one corner and point at the opposite corner. The rectangle thus specified is called the region-rectangle because you control it in much the same way as the region is controlled. But remember that a given combination of point and mark values can be interpreted either as a region or as a rectangle, depending on the command that uses them.

If point and the mark are in the same column, the rectangle they delimit is empty. If they are in the same line, the rectangle is one line high. This asymmetry between lines and columns comes about because point (and likewise the mark) is between two columns, but within a line.

C-x r k

Kill the text of the region-rectangle, saving its contents as the "last killed rectangle" (kill-rectangle).

C-x r d

Delete the text of the region-rectangle (delete-rectangle).

C-x r y

Yank the last killed rectangle with its upper left corner at point (yank-rectangle).

C-x r o

Insert blank space to fill the space of the region-rectangle (open-rectangle). This pushes the previous contents of the region-rectangle rightward.

M-x clear-rectangle

Clear the region-rectangle by replacing its contents with spaces.

M-x delete-whitespace-rectangle

Delete whitespace in each of the lines on the specified rectangle, starting from the left edge column of the rectangle.

C-x r t string RET

Replace rectangle contents with string on each line. (string-rectangle).

M-x string-insert-rectangle RET string RET

Insert string on each line of the rectangle.

The rectangle operations fall into two classes: commands for deleting and inserting rectangles, and commands for blank rectangles.

There are two ways to get rid of the text in a rectangle: you can discard the text (delete it) or save it as the "last killed" rectangle. The commands for these two ways are C-x r d (delete-rectangle) and C-x r k (kill-rectangle). In either case, the portion of each line that falls inside the rectangle's boundaries is deleted, causing any following text on the line to move left into the gap.

Note that "killing" a rectangle is not killing in the usual sense; the rectangle is not stored in the kill ring, but in a special place that can only record the most recent rectangle killed. This is because yanking a rectangle is so different from yanking linear text that different yank commands have to be used and yank-popping is hard to make sense of.

To yank the last killed rectangle, type C-x r y (yank-rectangle). Yanking a rectangle is the opposite of killing one. Point specifies where to put the rectangle's upper left corner. The rectangle's first line is inserted there, the rectangle's second line is inserted at the same horizontal position, but one line vertically down, and so on. The number of lines affected is determined by the height of the saved rectangle.

You can convert single-column lists into double-column lists using rectangle killing and yanking; kill the second half of the list as a rectangle and then yank it beside the first line of the list. See section AC.23 Two-Column Editing, for another way to edit multi-column text.

You can also copy rectangles into and out of registers with C-x r r r and C-x r i r. See section Rectangle Registers.

There are two commands you can use for making blank rectangles: M-x clear-rectangle which blanks out existing text, and C-x r o (open-rectangle) which inserts a blank rectangle. Clearing a rectangle is equivalent to deleting it and then inserting a blank rectangle of the same size.

The command M-x delete-whitespace-rectangle deletes horizontal whitespace starting from a particular column. This applies to each of the lines in the rectangle, and the column is specified by the left edge of the rectangle. The right edge of the rectangle does not make any difference to this command.