mirror of
https://git.savannah.gnu.org/git/emacs.git
synced 2024-12-12 09:28:24 +00:00
722 lines
30 KiB
Plaintext
722 lines
30 KiB
Plaintext
@c This is part of the Emacs manual.
|
|
@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 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}).
|
|
|
|
To clear the screen and redisplay, 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
|
|
change something.
|
|
* Erasing:: Deleting and killing text.
|
|
* 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.
|
|
* 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.
|
|
@end menu
|
|
|
|
@node Inserting Text
|
|
@section 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}.
|
|
|
|
To @dfn{delete} text you have just inserted, use @key{DEL}. @key{DEL}
|
|
deletes the character @emph{before} the cursor (not the one that the cursor
|
|
is on top of or under; that is the character @var{after} the cursor). The
|
|
cursor and all characters after it move backwards. Therefore, if you type
|
|
a printing character and then type @key{DEL}, they cancel out.
|
|
|
|
@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}.
|
|
|
|
@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
|
|
|
|
@itemize @bullet
|
|
@item
|
|
@kbd{C-q} followed by any non-graphic character (even @kbd{C-g})
|
|
inserts that character.
|
|
|
|
@item
|
|
@kbd{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 @key{RET}, it serves only to terminate the sequence; any
|
|
other non-digit is itself used as input after terminating the sequence.
|
|
(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.)
|
|
@end itemize
|
|
|
|
@noindent
|
|
When multibyte characters are enabled, octal codes 0200 through 0377 are
|
|
not valid as characters; if you specify a code in this range, @kbd{C-q}
|
|
assumes that you intend to use some ISO Latin-@var{n} character set, and
|
|
converts the specified code to the corresponding Emacs character code.
|
|
@xref{Enabling Multibyte}. You select @emph{which} ISO Latin character
|
|
set though your choice of language environment (@pxref{Language
|
|
Environments}).
|
|
|
|
@vindex read-quoted-char-radix
|
|
To use decimal or hexadecimal instead of octal, set the variable
|
|
@code{read-quoted-char-radix} to 10 or 16. If the radix is greater than
|
|
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}).
|
|
|
|
@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.
|
|
|
|
@node Moving Point
|
|
@section Changing the Location of Point
|
|
|
|
@cindex arrow keys
|
|
@kindex LEFT
|
|
@kindex RIGHT
|
|
@kindex UP
|
|
@kindex DOWN
|
|
@cindex moving point
|
|
@cindex movement
|
|
@cindex cursor motion
|
|
@cindex moving the cursor
|
|
To do more than insert characters, you have to know how to move point
|
|
(@pxref{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.
|
|
|
|
@kindex C-a
|
|
@kindex C-e
|
|
@kindex C-f
|
|
@kindex C-b
|
|
@kindex C-n
|
|
@kindex C-p
|
|
@kindex M->
|
|
@kindex M-<
|
|
@kindex M-r
|
|
@findex beginning-of-line
|
|
@findex end-of-line
|
|
@findex forward-char
|
|
@findex backward-char
|
|
@findex next-line
|
|
@findex previous-line
|
|
@findex beginning-of-buffer
|
|
@findex end-of-buffer
|
|
@findex goto-char
|
|
@findex goto-line
|
|
@findex move-to-window-line
|
|
@table @kbd
|
|
@item C-a
|
|
Move to the beginning of the line (@code{beginning-of-line}).
|
|
@item C-e
|
|
Move to the end of the line (@code{end-of-line}).
|
|
@item C-f
|
|
Move forward one character (@code{forward-char}).
|
|
@item C-b
|
|
Move backward one character (@code{backward-char}).
|
|
@item M-f
|
|
Move forward one word (@code{forward-word}).
|
|
@item M-b
|
|
Move backward one word (@code{backward-word}).
|
|
@item C-n
|
|
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. When on
|
|
the last line of text, @kbd{C-n} creates a new line and moves onto it.
|
|
@item C-p
|
|
Move up one line, vertically (@code{previous-line}).
|
|
@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).
|
|
@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.
|
|
@xref{Arguments}, for more information on numeric arguments.@refill
|
|
@item M->
|
|
Move to the end of the buffer (@code{end-of-buffer}).
|
|
@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 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.
|
|
@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.
|
|
@end table
|
|
|
|
@vindex track-eol
|
|
If you set the variable @code{track-eol} to a non-@code{nil} value,
|
|
then @kbd{C-n} and @kbd{C-p} when at the end of the starting line move
|
|
to the end of another line. Normally, @code{track-eol} is @code{nil}.
|
|
@xref{Variables}, for how to set variables such as @code{track-eol}.
|
|
|
|
@vindex next-line-add-newlines
|
|
Normally, @kbd{C-n} on the last line of a buffer appends a newline to
|
|
it. If the variable @code{next-line-add-newlines} is @code{nil}, then
|
|
@kbd{C-n} gets an error instead (like @kbd{C-p} on the first line).
|
|
|
|
@node Erasing
|
|
@section Erasing Text
|
|
|
|
@table @kbd
|
|
@item @key{DEL}
|
|
Delete the character before point (@code{delete-backward-char}).
|
|
@item C-d
|
|
Delete the character after point (@code{delete-char}).
|
|
@item C-k
|
|
Kill to the end of the line (@code{kill-line}).
|
|
@item M-d
|
|
Kill forward to the end of the next word (@code{kill-word}).
|
|
@item M-@key{DEL}
|
|
Kill back to the beginning of the previous word
|
|
(@code{backward-kill-word}).
|
|
@end table
|
|
|
|
@cindex killing characters and lines
|
|
@cindex deleting characters and lines
|
|
@cindex erasing characters and lines
|
|
You already know about the @key{DEL} key which deletes the character
|
|
before point (that is, before the cursor). Another key, @kbd{Control-d}
|
|
(@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.
|
|
|
|
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.
|
|
|
|
@xref{Killing}, for more flexible ways of killing text.
|
|
|
|
@node 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.
|
|
|
|
@table @kbd
|
|
@item C-x u
|
|
Undo one batch of changes---usually, one command worth (@code{undo}).
|
|
@item 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
|
|
prints 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.
|
|
|
|
@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
|
|
@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.
|
|
|
|
Consider a file named @file{/usr/rms/foo.c}. In Emacs, to begin editing
|
|
this file, type
|
|
|
|
@example
|
|
C-x C-f /usr/rms/foo.c @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
|
|
|
|
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.
|
|
|
|
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}.
|
|
|
|
Of course, there is a lot more to learn about using files. @xref{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
|
|
|
|
@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
|
|
blank lines.
|
|
|
|
@c widecommands
|
|
@table @kbd
|
|
@item C-o
|
|
Insert one or more blank lines after the cursor (@code{open-line}).
|
|
@item C-x C-o
|
|
Delete all but one of many consecutive blank lines
|
|
(@code{delete-blank-lines}).
|
|
@end table
|
|
|
|
@kindex C-o
|
|
@kindex C-x C-o
|
|
@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}.
|
|
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
|
|
after point but leaves point in front of the newline. After @kbd{C-o},
|
|
type the text for the new line. @kbd{C-o F O O} has the same effect as
|
|
@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
|
|
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.
|
|
|
|
@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 will grow to occupy two (or more) lines on the screen,
|
|
with a @samp{\} at the extreme right margin of all but the last of them.
|
|
The @samp{\} says that the following screen line is not really a distinct
|
|
line in the text, but just the @dfn{continuation} of a line too long to fit
|
|
the screen. Continuation is also called @dfn{line wrapping}.
|
|
|
|
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.
|
|
|
|
@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. @samp{$} is used in the last column
|
|
instead of @samp{\} to inform you that truncation is in effect.
|
|
|
|
Truncation instead of continuation happens whenever horizontal
|
|
scrolling is in use, and optionally in all side-by-side windows
|
|
(@pxref{Windows}). You can enable truncation for a particular buffer by
|
|
setting the variable @code{truncate-lines} to non-@code{nil} in that
|
|
buffer. (@xref{Variables}.) Altering the value of
|
|
@code{truncate-lines} makes it local to the current buffer; until that
|
|
time, the default value is in effect. The default is initially
|
|
@code{nil}. @xref{Locals}.
|
|
|
|
@xref{Display Vars}, for additional variables that affect how text is
|
|
displayed.
|
|
|
|
@node Position Info
|
|
@section Cursor Position Information
|
|
|
|
Here are commands to get information about the size and position of
|
|
parts of the buffer, and to count lines.
|
|
|
|
@table @kbd
|
|
@item M-x what-page
|
|
Print page number of point, and line number within page.
|
|
@item M-x what-line
|
|
Print line number of point in the buffer.
|
|
@item M-x line-number-mode
|
|
Toggle automatic display of current line number.
|
|
@item M-=
|
|
Print number of lines in the current region (@code{count-lines-region}).
|
|
@xref{Mark}, for information about the region.
|
|
@item C-x =
|
|
Print character code of character after point, character position of
|
|
point, and column of point (@code{what-cursor-position}).
|
|
@end table
|
|
|
|
@findex what-page
|
|
@findex what-line
|
|
@cindex line number commands
|
|
@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; @xref{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.
|
|
|
|
By contrast, @kbd{M-x what-page} counts pages from the beginning of
|
|
the file, and counts lines within the page, printing both numbers.
|
|
@xref{Pages}.
|
|
|
|
@kindex M-=
|
|
@findex count-lines-region
|
|
While on this subject, we might as well mention @kbd{M-=} (@code{count-lines-region}),
|
|
which prints 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 prints a line in the echo area that looks like this:
|
|
|
|
@smallexample
|
|
Char: c (0143, 99, 0x63) point=21044 of 26883(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
|
|
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
|
|
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, @kbd{C-x =} prints
|
|
additional text describing the currently accessible range. For example, it
|
|
might display this:
|
|
|
|
@smallexample
|
|
Char: C (0103, 67, 0x43) point=252 of 889(28%) <231 - 599> column 0
|
|
@end smallexample
|
|
|
|
@noindent
|
|
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. @xref{Narrowing}.
|
|
|
|
If point is at the end of the buffer (or the end of the accessible
|
|
part), the @w{@kbd{C-x =}} output does not describe a character after
|
|
point. The output might look like this:
|
|
|
|
@smallexample
|
|
point=26957 of 26956(100%) 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.}:
|
|
|
|
@example
|
|
Char: @`A (04300, 2240, 0x8c0, ext ESC , A @@) (latin-iso8859-1 64)
|
|
@end example
|
|
|
|
@node Arguments
|
|
@section Numeric Arguments
|
|
@cindex numeric arguments
|
|
@cindex prefix arguments
|
|
@cindex arguments, numeric
|
|
@cindex arguments, prefix
|
|
|
|
In mathematics and computer usage, the word @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
|
|
example, @kbd{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.
|
|
|
|
@kindex M-1
|
|
@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,
|
|
@example
|
|
M-5 C-n
|
|
@end example
|
|
@noindent
|
|
would move 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. 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.
|
|
|
|
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
|
|
@kbd{C-k} (@code{kill-line}) with argument @var{n} kills @var{n} lines,
|
|
including their terminating newlines. But @kbd{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 @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
|
|
|
|
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.
|
|
|
|
@node Repeating
|
|
@section Repeating a Command
|
|
@cindex repeating a command
|
|
|
|
@kindex C-x z
|
|
@findex repeat
|
|
The command @kbd{C-x z} (@code{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 @kbd{z}'s: each
|
|
@kbd{z} repeats the command one more time. Repetition ends when you
|
|
type a character other than @kbd{z}, or press a mouse button.
|
|
|
|
For example, suppose you type @kbd{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 @kbd{C-x
|
|
z z z}. The first @kbd{C-x z} repeats the command once, and each
|
|
subsequent @kbd{z} repeats it once again.
|
|
|