@c This is part of the Emacs manual.
-@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001 Free Software Foundation, Inc.
+@c Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1997, 2000, 2001,
+@c 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@node Basic, Minibuffer, Exiting, Top
@chapter Basic Editing Commands
@kindex C-h t
@findex help-with-tutorial
- 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 @kbd{Control-h t}
-(@code{help-with-tutorial}).
+ Here we explain the basics of how to enter text, make corrections,
+and save the text in a file. If this material is new to you, we
+suggest you first run the Emacs learn-by-doing tutorial, by typing
+@kbd{Control-h t} inside Emacs. (@code{help-with-tutorial}).
- To clear the screen and redisplay, type @kbd{C-l} (@code{recenter}).
+ To clear and redisplay the screen, type @kbd{C-l} (@code{recenter}).
@menu
* Inserting Text:: Inserting text by simply typing it.
-* Moving Point:: How to move the cursor to the place where you want to
+* Moving Point:: Moving the cursor to the place where you want to
change something.
* Erasing:: Deleting and killing text.
-* Undo:: Undoing recent changes in the text.
+* Basic Undo:: Undoing recent changes in the text.
* Files: Basic Files. Visiting, creating, and saving files.
* Help: Basic Help. Asking what a character does.
-* Blank Lines:: Commands to make or delete blank lines.
-* Continuation Lines:: Lines too wide for the screen.
+* Blank Lines:: Making and deleting blank lines.
+* Continuation Lines:: How Emacs displays lines too wide for the screen.
* Position Info:: What page, line, row, or column is point on?
-* Arguments:: Numeric arguments for repeating a command.
-* Repeating:: A short-cut for repeating the previous command.
+* Arguments:: Numeric arguments for repeating a command N times.
+* Repeating:: Repeating the previous command quickly.
@end menu
@node Inserting Text
@cindex insertion
@cindex graphic characters
- 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 @dfn{point}; @pxref{Point}). The cursor moves
-forward, and any text after the cursor moves forward too. If the text
-in the buffer is @samp{FOOBAR}, with the cursor before the @samp{B},
-then if you type @kbd{XX}, you get @samp{FOOXXBAR}, with the cursor
-still before the @samp{B}.
+ Typing printing characters inserts them into the text you are
+editing. It inserts them into the buffer at the cursor; more
+precisely, it inserts them at @dfn{point}, but the cursor normally
+shows where point is. @xref{Point}.
+
+ Insertion moves the cursor forward, and the following text moves
+forward with the cursor. If the text in the buffer is @samp{FOOBAR},
+with the cursor before the @samp{B}, and you type @kbd{XX}, you get
+@samp{FOOXXBAR}, with the cursor still before the @samp{B}.
To @dfn{delete} text you have just inserted, use the large key
labeled @key{DEL}, @key{BACKSPACE} or @key{DELETE} which is a short
-distance above the @key{RET} or @key{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
-@key{DEL}, and that's what we call it in this manual.
+distance above the @key{RET} or @key{ENTER} key. Regardless of the
+label on that key, Emacs thinks of it as @key{DEL}, and that's what we
+call it in this manual. @key{DEL} is the key you normally use outside
+Emacs to erase the last character that you typed.
The @key{DEL} key deletes the character @emph{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 @key{DEL},
they cancel out.
- On most computers, Emacs recognizes automatically which key ought to
-be @key{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 @key{RET} or
-@key{ENTER} key doesn't delete backwards, you need to do this.
-@xref{DEL Does Not Delete}, for an explanation of how.
+ On most computers, Emacs sets up @key{DEL} automatically. In some
+cases, especially with text-only terminals, Emacs may guess wrong. If
+the key that ought to erase the last character doesn't do it in Emacs,
+see @ref{DEL Does Not Delete}.
- Most PC keyboards have both a @key{BACKSPACE} key a short ways above
-@key{RET} or @key{ENTER}, and a @key{DELETE} key elsewhere. On these
-keyboards, Emacs supports when possible the usual convention that the
-@key{BACKSPACE} key deletes backwards (it is @key{DEL}), while the
-@key{DELETE} key deletes ``forwards,'' deleting the character after
-point, the one underneath the cursor, like @kbd{C-d} (see below).
+ Most PC keyboards have both a @key{BACKSPACE} key a little ways
+above @key{RET} or @key{ENTER}, and a @key{DELETE} key elsewhere. On
+these keyboards, Emacs tries to set up @key{BACKSPACE} as @key{DEL}.
+The @key{DELETE} key deletes ``forwards'' like @kbd{C-d} (see below),
+which means it deletes the character underneath the cursor (after
+point).
@kindex RET
@cindex newline
- To end a line and start typing a new one, type @key{RET}. This
-inserts a newline character in the buffer. If point is in the middle of
-a line, @key{RET} splits the line. Typing @key{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 @dfn{Auto Fill} mode.
-@xref{Filling}, 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. @xref{Minor Modes}.
+ To end a line and start typing a new one, type @key{RET}. (This
+key may be labeled @key{RETURN} or @key{ENTER}, but in Emacs we call
+it @key{RET}.) This inserts a newline character in the buffer. If
+point is at the end of the line, this creates a new blank line after
+it. If point is in the middle of a line, the effect is to split that
+line. Typing @key{DEL} when the cursor is at the beginning of a line
+deletes the preceding newline character, thus joining the line with
+the one before it.
+
+ Emacs can split lines automatically when they become too long, if
+you turn on a special minor mode called @dfn{Auto Fill} mode.
+@xref{Filling}, for Auto Fill mode and other methods of @dfn{filling}
+text.
+
+ If you prefer printing characters to replace (overwrite) existing
+text, rather than shove it to the right, you should enable Overwrite
+mode, a minor mode. @xref{Minor Modes}.
@cindex quoting
@kindex C-q
@findex quoted-insert
- Direct insertion works for printing characters and @key{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 @dfn{quote} it by typing the character @kbd{Control-q}
-(@code{quoted-insert}) first. (This character's name is normally written
-@kbd{C-q} for short.) There are two ways to use @kbd{C-q}:@refill
+ Only printing characters and @key{SPC} insert themselves in Emacs.
+Other characters act as editing commands and do not insert themselves.
+These include control characters, and characters with codes above 200
+octal. If you need to insert one of these characters in the buffer,
+you must @dfn{quote} it by typing the character @kbd{Control-q}
+(@code{quoted-insert}) first. (This character's name is normally
+written @kbd{C-q} for short.) There are two ways to use
+@kbd{C-q}:
@itemize @bullet
@item
10, some letters starting with @kbd{a} serve as part of a character
code, just like digits.
-A numeric argument to @kbd{C-q} specifies how many copies of the
-quoted character should be inserted (@pxref{Arguments}).
+A numeric argument tells @kbd{C-q} how many copies of the quoted
+character to insert (@pxref{Arguments}).
@findex newline
@findex self-insert
Customization information: @key{DEL} in most modes runs the command
-@code{delete-backward-char}; @key{RET} runs the command @code{newline}, and
-self-inserting printing characters run the command @code{self-insert},
-which inserts whatever character was typed to invoke it. Some major modes
-rebind @key{DEL} to other commands.
+@code{delete-backward-char}; @key{RET} runs the command
+@code{newline}, and self-inserting printing characters run the command
+@code{self-insert}, which inserts whatever character you typed. Some
+major modes rebind @key{DEL} to other commands.
@node Moving Point
@section Changing the Location of Point
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.
+are equivalent to the arrow keys (it is faster to use these control
+keys than move your hand over to the arrow keys). Others do more
+sophisticated things.
@kindex C-a
@kindex C-e
@kindex RIGHT
@kindex UP
@kindex DOWN
-@findex beginning-of-line
-@findex end-of-line
+@findex move-beginning-of-line
+@findex move-end-of-line
@findex forward-char
@findex backward-char
@findex next-line
@findex move-to-window-line
@table @kbd
@item C-a
-Move to the beginning of the line (@code{beginning-of-line}).
+Move to the beginning of the line (@code{move-beginning-of-line}).
@item C-e
-Move to the end of the line (@code{end-of-line}).
+Move to the end of the line (@code{move-end-of-line}).
@item C-f
Move forward one character (@code{forward-char}). The right-arrow key
does the same thing.
@item M-b
Move backward one word (@code{backward-word}).
@item C-n
-Move down one line, vertically (@code{next-line}). This command
+Move down one line vertically (@code{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
+the middle of one line, you move to the middle of the next. The
down-arrow key does the same thing.
@item C-p
Move up one line, vertically (@code{previous-line}). The up-arrow key
-has the same effect.
+has the same effect. This command preserves position within the line,
+like @kbd{C-n}.
@item M-r
Move point to left margin, vertically centered in the window
(@code{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 (@minus{}1 for the bottom
-line).
+A numeric argument says which screen line to place point on, counting
+downward from the top of the window (zero means the top line). A
+negative argument counts lines up from the bottom (@minus{}1 means the
+bottom line).
@item M-<
Move to the top of the buffer (@code{beginning-of-buffer}). With
numeric argument @var{n}, move to @var{n}/10 of the way from the top.
@item M->
Move to the end of the buffer (@code{end-of-buffer}).
@item C-v
-Scroll the display one screen forward, and move point if necessary to put
-it on the screen (@code{scroll-up}). This doesn't always
-move point, but it is commonly used to do so.
-If your keyboard has a @key{PAGEDOWN} key, it does the same thing.
-
-Scrolling commands are further described in @ref{Scrolling}.
+@itemx @key{PAGEDOWN}
+@itemx @key{PRIOR}
+Scroll the display one screen forward, and move point if necessary to
+put it on the screen (@code{scroll-up}). This doesn't always move
+point, but it is commonly used to do so. If your keyboard has a
+@key{PAGEDOWN} or @key{PRIOR} key, it does the same thing.
+
+Scrolling commands are described further in @ref{Scrolling}.
@item M-v
+@itemx @key{PAGEUP}
+@itemx @key{NEXT}
Scroll one screen backward, and move point if necessary to put it on
the screen (@code{scroll-down}). This doesn't always move point, but
-it is commonly used to do so. The @key{PAGEUP} key has the same
-effect.
+it is commonly used to do so. If your keyboard has a @key{PAGEUP} or
+@key{NEXT} key, it does the same thing.
@item M-x goto-char
Read a number @var{n} and move point to buffer position @var{n}.
Position 1 is the beginning of the buffer.
-@item M-x goto-line
-Read a number @var{n} and move point to line number @var{n}. Line 1
-is the beginning of the buffer.
+@item M-g M-g
+@itemx M-g g
+@itemx M-x goto-line
+Read a number @var{n} and move point to the beginning of line number
+@var{n}. Line 1 is the beginning of the buffer. If point is on or
+just after a number in the buffer, and you type @key{RET} with the
+minibuffer empty, that number is used for @var{n}.
@item C-x C-n
@findex set-goal-column
@kindex C-x C-n
-Use the current column of point as the @dfn{semipermanent goal column} for
-@kbd{C-n} and @kbd{C-p} (@code{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.
+Use the current column of point as the @dfn{semipermanent goal column}
+for @kbd{C-n} and @kbd{C-p} (@code{set-goal-column}). When a
+semipermanent goal column is in effect, those commands always try to
+move to this column, or as close as possible to it, after moving
+vertically. The goal column remains in effect until canceled.
@item C-u C-x C-n
-Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} once
-again try to stick to a fixed horizontal position, as usual.
+Cancel the goal column. Henceforth, @kbd{C-n} and @kbd{C-p} try to
+preserve the horizontal position, as usual.
@end table
@vindex track-eol
@xref{Variables}, for how to set variables such as @code{track-eol}.
@vindex next-line-add-newlines
- @kbd{C-n} normally gets an error when you use it on the last line of
-the buffer (just as @kbd{C-p} gets an error on the first line). But
-if you set the variable @code{next-line-add-newlines} to a
-non-@code{nil} value, @kbd{C-n} on the last line of a buffer creates
-an additional line at the end and moves down onto it.
+ @kbd{C-n} normally stops at the end of the buffer when you use it on
+the last line of the buffer. However, if you set the variable
+@code{next-line-add-newlines} to a non-@code{nil} value, @kbd{C-n} on
+the last line of a buffer creates an additional line at the end and
+moves down into it.
-@node Erasing
+@node Erasing
@section Erasing Text
@table @kbd
@item @key{DELETE}
@itemx @key{BACKSPACE}
One of these keys, whichever is the large key above the @key{RET} or
-@key{ENTER} key, deletes the character before point, like @key{DEL}.
-If that is @key{BACKSPACE}, and your keyboard also has @key{DELETE},
+@key{ENTER} key, deletes the character before point---it is @key{DEL}.
+If @key{BACKSPACE} is @key{DEL}, and your keyboard also has @key{DELETE},
then @key{DELETE} deletes forwards, like @kbd{C-d}.
@item C-k
Kill to the end of the line (@code{kill-line}).
(@kbd{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 @kbd{C-d} at the end of a line, it
-joins together that line and the next line.
+joins that line with the following line.
- To erase a larger amount of text, use the @kbd{C-k} key, which kills a
-line at a time. If you type @kbd{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
-@kbd{C-k} at the end of a line, it joins that line and the next line.
+ To erase a larger amount of text, use the @kbd{C-k} key, which
+erases (kills) a line at a time. If you type @kbd{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 @kbd{C-k} at the end of a line, it joins that
+line with the following line.
@xref{Killing}, for more flexible ways of killing text.
-@node Undo
+@node Basic Undo
@section Undoing Changes
-@cindex undo
-@cindex changes, undoing
- 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 @code{query-replace} make many entries, and very simple commands
-such as self-inserting characters are often grouped to make undoing less
-tedious.
+ Emacs records a list of changes made in the buffer text, so you can
+you can undo recent changes, as far as the records go.
+Usually each editing command makes a separate entry in the undo
+records, but sometimes an entry covers just part of a command, and
+very simple commands may be grouped.
@table @kbd
@item C-x u
-Undo one batch of changes---usually, one command worth (@code{undo}).
+Undo one entry of the undo records---usually, one command worth
+(@code{undo}).
@item C-_
+@itemx C-/
The same.
-@item C-u C-x u
-Undo one batch of changes in the region.
@end table
-@kindex C-x u
-@kindex C-_
-@findex undo
- The command @kbd{C-x u} or @kbd{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 @kbd{C-_} or @kbd{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 @kbd{C-f} or any other command that will harmlessly break
-the sequence of undoing, then type more undo commands.
-
-@cindex selective undo
-@kindex C-u C-x u
- Ordinary undo applies to all changes made in the current buffer. You
-can also perform @dfn{selective undo}, limited to the current region.
-To do this, specify the region you want, then run the @code{undo}
-command with a prefix argument (the value does not matter): @kbd{C-u C-x
-u} or @kbd{C-u C-_}. This undoes the most recent change in the region.
-To undo further changes in the same region, repeat the @code{undo}
-command (no prefix argument is needed). In Transient Mark mode, any use
-of @code{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 @kbd{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 @kbd{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 (@pxref{Mark Ring}).
-
-@vindex undo-limit
-@vindex undo-strong-limit
-@cindex undo limit
- 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: @code{undo-limit} and @code{undo-strong-limit}.
-Their values are expressed in units of bytes of space.
-
- The variable @code{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 @code{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 @code{undo} command has two keys, @kbd{C-x u} and
-@kbd{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 @kbd{C-_}.
-@kbd{C-x u} is an alternative you can type straightforwardly on any
-terminal.
+ The command @kbd{C-x u} (or @kbd{C-_} or @kbd{C-/}) is how you undo.
+Normally this command undoes the last change, and moves point back to
+where it was before the change.
+
+ If you repeat @kbd{C-x u} (or its aliases), each repetition undoes
+another, earlier change, 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.
+
+ The undo command applies only to changes in the buffer; you can't
+use it to undo mere cursor motion. 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 (@pxref{Mark Ring}).
@node Basic Files
@section 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
+ Text that you insert in an Emacs buffer lasts only as long as the
+Emacs session. To keep any text permanently you must put it in a
@dfn{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.
+operating system for you to retrieve later by name. To use the
+contents of a file in any way, you must specify the file name. That
+includes editing the file with Emacs.
- Consider a file named @file{/usr/rms/foo.c}. In Emacs, to begin editing
-this file, type
+ Suppose there is a file named @file{test.emacs} in your home
+directory. To begin editing this file in Emacs, type
@example
-C-x C-f /usr/rms/foo.c @key{RET}
+C-x C-f test.emacs @key{RET}
@end example
@noindent
Here the file name is given as an @dfn{argument} to the command @kbd{C-x
C-f} (@code{find-file}). That command uses the @dfn{minibuffer} to
read the argument, and you type @key{RET} to terminate the argument
-(@pxref{Minibuffer}).@refill
+(@pxref{Minibuffer}).
- Emacs obeys the command by @dfn{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 @dfn{save}
-the new text in the file by typing @kbd{C-x C-s} (@code{save-buffer}).
-This makes the changes permanent by copying the altered buffer contents
-back into the file @file{/usr/rms/foo.c}. Until you save, the changes
-exist only inside Emacs, and the file @file{foo.c} is unaltered.
+ Emacs obeys this command by @dfn{visiting} the file: it creates a
+buffer, it copies the contents of the file into the buffer, and then
+displays the buffer for editing. If you alter the text, you can
+@dfn{save} the new text in the file by typing @kbd{C-x C-s}
+(@code{save-buffer}). This copies the altered buffer contents back
+into the file @file{test.emacs}, making them permanent. Until you
+save, the changed text exists only inside Emacs, and the file
+@file{test.emacs} is unaltered.
- To create a file, just visit the file with @kbd{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 @kbd{C-x C-s}.
+ To create a file, just visit it with @kbd{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. Emacs actually creates the file the
+first time you save this buffer with @kbd{C-x C-s}.
- Of course, there is a lot more to learn about using files. @xref{Files}.
+ To learn more about using files in Emacs, see @ref{Files}.
@node Basic Help
@section Help
@cindex getting help with keys
If you forget what a key does, you can find out with the Help
character, which is @kbd{C-h} (or @key{F1}, which is an alias for
-@kbd{C-h}). Type @kbd{C-h k} followed by the key you want to know
-about; for example, @kbd{C-h k C-n} tells you all about what @kbd{C-n}
-does. @kbd{C-h} is a prefix key; @kbd{C-h k} is just one of its
-subcommands (the command @code{describe-key}). The other subcommands of
-@kbd{C-h} provide different kinds of help. Type @kbd{C-h} twice to get
-a description of all the help facilities. @xref{Help}.@refill
+@kbd{C-h}). Type @kbd{C-h k} followed by the key of interest; for
+example, @kbd{C-h k C-n} tells you what @kbd{C-n} does. @kbd{C-h} is
+a prefix key; @kbd{C-h k} is just one of its subcommands (the command
+@code{describe-key}). The other subcommands of @kbd{C-h} provide
+different kinds of help. Type @kbd{C-h} twice to get a description of
+all the help facilities. @xref{Help}.
@node Blank Lines
@section Blank Lines
@cindex inserting blank lines
@cindex deleting blank lines
- Here are special commands and techniques for putting in and taking out
+ Here are special commands and techniques for inserting and deleting
blank lines.
@table @kbd
@cindex blank lines
@findex open-line
@findex 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 @key{RET}.
+ To insert a new line of text before an existing line,
+type the new line of text, followed by @key{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 @kbd{C-o} (@code{open-line}), which inserts a newline
@w{@kbd{F O O @key{RET}}}, except for the final location of point.
You can make several blank lines by typing @kbd{C-o} several times, or
-by giving it a numeric argument to tell it how many blank lines to make.
-@xref{Arguments}, for how. If you have a fill prefix, then @kbd{C-o}
-command inserts the fill prefix on the new line, when you use it at the
+by giving it a numeric argument specifying how many blank lines to make.
+@xref{Arguments}, for how. If you have a fill prefix, the @kbd{C-o}
+command inserts the fill prefix on the new line, if typed at the
beginning of a line. @xref{Fill Prefix}.
The easy way to get rid of extra blank lines is with the command
@kbd{C-x C-o} (@code{delete-blank-lines}). @kbd{C-x C-o} in a run of
several blank lines deletes all but one of them. @kbd{C-x C-o} on a
-solitary blank line deletes that blank line. When point is on a
-nonblank line, @kbd{C-x C-o} deletes any blank lines following that
-nonblank line.
+lone blank line deletes that one. When point is on a nonblank line,
+@kbd{C-x C-o} deletes all following blank lines (if any).
@node Continuation Lines
@section Continuation Lines
@cindex continuation line
@cindex wrapping
@cindex line wrapping
- If you add too many characters to one line without breaking it with
-@key{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 @samp{\} character at the right
-margin of a screen line if it is not the last in its text line. This
-@samp{\} character says that the following screen line is not really a
-distinct line in the text, just a @dfn{continuation} of a line too
-long to fit the screen. Continuation is also called @dfn{line
-wrapping}.
-
- When line wrapping occurs before a character that is wider than one
+@cindex fringes, and continuation lines
+ When a text line is too long to fit in one screen line, Emacs
+displays it on two or more screen lines. This is called
+@dfn{continuation} or @dfn{line wrapping}. On graphical displays,
+Emacs indicates line wrapping with small bent arrows in the left and
+right window fringes. On text-only terminals, Emacs displays a
+@samp{\} character at the right margin of a screen line if it is not
+the last in its text line. This @samp{\} character says that the
+following screen line is not really a new text line.
+
+ When line wrapping occurs just 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 @samp{\}
-characters in the ``empty'' columns, just before the @samp{\}
+characters in the ``empty'' columns before the @samp{\}
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 (@pxref{Filling}) if that's what you want.
+ Continued lines can be difficult to read, since lines can break in
+the middle of a word. If you prefer, you can make Emacs insert a
+newline automatically when a line gets too long, by using Auto Fill
+mode. Or enable Long Lines mode, which ensures that wrapping only
+occurs between words. @xref{Filling}.
-@vindex truncate-lines
@cindex truncation
- As an alternative to continuation, Emacs can display long lines by
-@dfn{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, @samp{$}
-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.
-
-@findex toggle-truncate-lines
- Truncation instead of continuation happens whenever horizontal
-scrolling is in use, and optionally in all side-by-side windows
-(@pxref{Windows}). You can enable or disable truncation for a
-particular buffer with the command @kbd{M-x toggle-truncate-lines}.
-
- @xref{Display Custom}, for additional variables that affect how text is
-displayed.
+@cindex line truncation, and fringes
+ Emacs can optionally @dfn{truncate} long lines---this means
+displaying just one screen line worth, and the rest of the long line
+does not appear at all. @samp{$} in the last column or a small
+straight arrow in the window's right fringe indicates a truncated
+line.
+
+ @xref{Display Custom}, for more about line truncation,
+and other variables that control how text is displayed.
@node Position Info
@section Cursor Position Information
@table @kbd
@item M-x what-page
-Display the page number of point, and the line number within the page.
+Display the page number of point, and the line number within that page.
@item M-x what-line
-Display the line number of point in the buffer.
+Display the line number of point in the whole buffer.
@item M-x line-number-mode
@itemx M-x column-number-mode
-Toggle automatic display of current line number or column number.
+Toggle automatic display of the current line number or column number.
@xref{Optional Mode Line}.
@item M-=
Display the number of lines in the current region (@code{count-lines-region}).
@item M-x hl-line-mode
Enable or disable highlighting of the current line. @xref{Cursor
Display}.
+@item M-x size-indication-mode
+Toggle automatic display of the size of the buffer.
+@xref{Optional Mode Line}.
@end table
@findex what-page
@cindex location of point
@cindex cursor location
@cindex point location
- There are two commands for working with line numbers. @kbd{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 @kbd{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 @ref{Mode
-Line}. If you narrow the buffer, then the line number in the mode line
-is relative to the accessible portion (@pxref{Narrowing}). By contrast,
-@code{what-line} shows both the line number relative to the narrowed
-region and the line number relative to the whole buffer.
+ @kbd{M-x what-line} displays the current line number
+in the echo area. You can also see the current line number in the
+mode line; see @ref{Mode Line}; but if you narrow the buffer, the
+line number in the mode line is relative to the accessible portion
+(@pxref{Narrowing}). By contrast, @code{what-line} shows both the
+line number relative to the narrowed region and the line number
+relative to the whole buffer.
@kbd{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.
@kindex M-=
@findex count-lines-region
- While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
-which displays the number of lines in the region (@pxref{Mark}).
-@xref{Pages}, for the command @kbd{C-x l} which counts the lines in the
-current page.
+ Use @kbd{M-=} (@code{count-lines-region}) to displays the number of
+lines in the region (@pxref{Mark}). @xref{Pages}, for the command
+@kbd{C-x l} which counts the lines in the current page.
@kindex C-x =
@findex what-cursor-position
- The command @kbd{C-x =} (@code{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:
+ The command @kbd{C-x =} (@code{what-cursor-position}) shows what
+cursor's column position, and other information about point and the
+character after it. It displays a line in the echo area that looks
+like this:
@smallexample
-Char: c (0143, 99, 0x63) point=21044 of 26883(78%) column 53
+Char: c (99, #o143, #x63) point=28062 of 36168 (78%) column=53
@end smallexample
-@noindent
-(In fact, this is the output produced when point is before the
-@samp{column} in the example.)
-
The four values after @samp{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 @samp{ext} and the character's representation, in hex, in
+decimal, octal and hex. For a non-@acronym{ASCII} multibyte character, these are
+followed by @samp{file} 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 (@pxref{Coding Systems}). If the
-character's encoding is longer than one byte, Emacs shows @samp{ext ...}.
-
- @samp{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.
-
- @samp{column} is followed by the horizontal position of point, in
+character's encoding is longer than one byte, Emacs shows @samp{file ...}.
+
+ However, if the character displayed is in the range 0200 through
+0377 octal, it may actually stand for an invalid UTF-8 byte read from
+a file. In Emacs, that byte is represented as a sequence of 8-bit
+characters, but all of them together display as the original invalid
+byte, in octal code. In this case, @kbd{C-x =} shows @samp{part of
+display ...} instead of @samp{file}.
+
+ @samp{point=} is followed by the position of point expressed as a
+character count. The start of the buffer is position 1, one character
+later is position 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.
+
+ @samp{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
might display this:
@smallexample
-Char: C (0103, 67, 0x43) point=252 of 889(28%) <231 - 599> column 0
+Char: C (67, #o103, #x43) point=252 of 889 (28%) <231-599> column=0
@end smallexample
@noindent
point. The output might look like this:
@smallexample
-point=26957 of 26956(100%) column 0
+point=36169 of 36168 (EOB) column=0
@end smallexample
- @w{@kbd{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 @code{ASCII}
-character set. In addition, the full character encoding, even if it
-takes more than a single byte, is shown after @samp{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@footnote{On terminals that support
-Latin-1 characters, the character shown after @samp{Char:} is displayed
-as the actual glyph of A with grave accent.}:
+@cindex character set of character at point
+@cindex font of character at point
+@cindex text properties at point
+ @w{@kbd{C-u C-x =}} displays the following additional information about a
+character.
+
+@itemize @bullet
+@item
+The character set name, and the codes that identify the character
+within that character set; @acronym{ASCII} characters are identified
+as belonging to the @code{ascii} character set.
+
+@item
+The character's syntax and categories.
+
+@item
+The character's encodings, both internally in the buffer, and externally
+if you were to save the file.
+
+@item
+What keys to type to input the character in the current input method
+(if it supports the character).
+
+@item
+If you are running Emacs on a graphical display, the font name and
+glyph code for the character. If you are running Emacs on a text-only
+terminal, the code(s) sent to the terminal.
+
+@item
+The character's text properties (@pxref{Text Properties,,,
+elisp, the Emacs Lisp Reference Manual}), and any overlays containing it
+(@pxref{Overlays,,, elisp, the same manual}).
+@end itemize
+
+ Here's an example showing the Latin-1 character A with grave accent,
+in a buffer whose coding system is @code{iso-latin-1}, whose
+terminal coding system is @code{iso-latin-1} (so the terminal actually
+displays the character as @samp{@`A}), and which has font-lock-mode
+(@pxref{Font Lock}) enabled:
@smallexample
-Char: @`A (04300, 2240, 0x8c0, ext ESC , A @@) (latin-iso8859-1 64)
+ character: @`A (2240, #o4300, #x8c0, U+00C0)
+ charset: latin-iso8859-1
+ (Right-Hand Part of Latin Alphabet 1@dots{}
+ code point: #x40
+ syntax: w which means: word
+ category: l:Latin
+ to input: type "`A" with latin-1-prefix
+buffer code: #x81 #xC0
+ file code: #xC0 (encoded by coding system iso-latin-1)
+ display: terminal code #xC0
+
+There are text properties here:
+ fontified t
@end smallexample
@node Arguments
@cindex prefix arguments
@cindex arguments to commands
- In mathematics and computer usage, the word @dfn{argument} means
+ In mathematics and computer usage, @dfn{argument} means
``data provided to a function or operation.'' You can give any Emacs
command a @dfn{numeric argument} (also called a @dfn{prefix argument}).
Some commands interpret the argument as a repetition count. For
@kindex M-@t{-}
@findex digit-argument
@findex negative-argument
- If your terminal keyboard has a @key{META} key, the easiest way to
-specify a numeric argument is to type digits and/or a minus sign while
-holding down the @key{META} key. For example,
+ If your terminal keyboard has a @key{META} key (labeled @key{ALT} on
+PC keyboards), the easiest way to specify a numeric argument is to
+type digits and/or a minus sign while holding down the @key{META} key.
+For example,
@example
M-5 C-n
@end example
@noindent
-would move down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2},
+moves down five lines. The characters @kbd{Meta-1}, @kbd{Meta-2},
and so on, as well as @kbd{Meta--}, do this because they are keys bound
to commands (@code{digit-argument} and @code{negative-argument}) that
-are defined to contribute to an argument for the next command.
+are defined to set up an argument for the next command.
@kbd{Meta--} without digits normally means @minus{}1. Digits and
@kbd{-} modified with Control, or Control and Meta, also specify numeric
arguments.
@kindex C-u
@findex universal-argument
- Another way of specifying an argument is to use the @kbd{C-u}
-(@code{universal-argument}) command followed by the digits of the
-argument. With @kbd{C-u}, you can type the argument digits without
-holding down modifier keys; @kbd{C-u} works on all terminals. To type a
-negative argument, type a minus sign after @kbd{C-u}. Just a minus sign
-without digits normally means @minus{}1.
-
- @kbd{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. @kbd{C-u} twice multiplies it by
-sixteen. Thus, @kbd{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 @kbd{C-u C-n},
-@kbd{C-u C-u C-n} (move down a good fraction of a screen), @kbd{C-u C-u
-C-o} (make ``a lot'' of blank lines), and @kbd{C-u C-k} (kill four
-lines).@refill
-
- Some commands care only about whether there is an argument, and not about
-its value. For example, the command @kbd{M-q} (@code{fill-paragraph}) with
-no argument fills text; with an argument, it justifies the text as well.
-(@xref{Filling}, for more information on @kbd{M-q}.) Plain @kbd{C-u} is a
-handy way of providing an argument for such commands.
+ You can also specify a numeric argument by typing @kbd{C-u}
+(@code{universal-argument}) followed by the digits. The advantage of
+@kbd{C-u} is that you can type the digits without modifier keys; thus,
+@kbd{C-u} works on all terminals. For a negative argument, type a
+minus sign after @kbd{C-u}. A minus sign without digits normally
+means @minus{}1.
+
+ @kbd{C-u} alone has the special meaning of
+``four times'': it multiplies the argument for the next command by
+four. @kbd{C-u C-u} multiplies it by sixteen. Thus, @kbd{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 @kbd{C-u C-n}, @kbd{C-u C-u
+C-n} (move down a good fraction of a screen), @kbd{C-u C-u C-o} (make
+``a lot'' of blank lines), and @kbd{C-u C-k} (kill four lines).
+
+ Some commands care whether there is an argument, but ignore its
+value. For example, the command @kbd{M-q} (@code{fill-paragraph})
+fills text; with an argument, it justifies the text as well.
+(@xref{Filling}, for more information on @kbd{M-q}.) Plain @kbd{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
the end of the line, it kills the newline itself. Thus, two @kbd{C-k}
commands with no arguments can kill a nonblank line, just like @kbd{C-k}
with an argument of one. (@xref{Killing}, for more information on
-@kbd{C-k}.)@refill
+@kbd{C-k}.)
A few commands treat a plain @kbd{C-u} differently from an ordinary
argument. A few others may treat an argument of just a minus sign
differently from an argument of @minus{}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, @kbd{C-u 6 4 a} inserts 64 copies of the character @samp{a}.
-But this does not work for inserting digits; @kbd{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 @kbd{C-u}; for example,
-@kbd{C-u 6 4 C-u 1} does insert 64 copies of the character @samp{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.
+described when they come up; they exist to make an individual command
+more convenient, and they are documented in that command's
+documentation string.
+
+ You can use a numeric argument before a self-inserting character to
+insert multiple copies of it. This is straightforward when the
+character is not a digit; for example, @kbd{C-u 6 4 a} inserts 64
+copies of the character @samp{a}. But this does not work for
+inserting digits; @kbd{C-u 6 4 1} specifies an argument of 641. You
+can separate the argument from the digit to insert with another
+@kbd{C-u}; for example, @kbd{C-u 6 4 C-u 1} does insert 64 copies of
+the character @samp{1}.
+
+ We use the term ``prefix argument'' as well as ``numeric argument'',
+to emphasize that you type these argument before the command, and to
+distinguish them from minibuffer arguments that come after the
+command.
@node Repeating
@section Repeating a Command
with @kbd{M-x @var{command-name} @key{RET}}, can be repeated by
invoking them with a numeric argument that serves as a repeat count
(@pxref{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.
+prompts for input, or uses a numeric argument in another way, that
+method won't work.
@kindex C-x z
@findex repeat
z z z}. The first @kbd{C-x z} repeats the command once, and each
subsequent @kbd{z} repeats it once again.
+@ignore
+ arch-tag: cda8952a-c439-41c1-aecf-4bc0d6482956
+@end ignore
HCoop / bpt / emacs.git / blobdiff