XEmacs 21.2-b1

[chise/xemacs-chise.git.1] / man / xemacs / basic.texi

@node Basic, Undo, Startup Paths, 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
do this, type @kbd{Control-h t} (@code{help-with-tutorial}).

@section Inserting Text

@cindex insertion
@cindex point
@cindex cursor
@cindex graphic characters
  To insert printing characters into the text you are editing, just type
them.  This inserts the characters into the buffer at the cursor (that
is, at @dfn{point}; @pxref{Point}).  The cursor moves forward.  Any
characters after the cursor move forward too.  If the text in the buffer
is @samp{FOOBAR}, with the cursor before the @samp{B}, and you type
@kbd{XX}, the result is @samp{FOOXXBAR}, with the cursor still before the
@samp{B}.

@kindex DEL
@cindex deletion
   To @dfn{delete} text you have just inserted, use @key{DEL}.
@key{DEL} deletes the character @var{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 rubs out the newline before the line, thus
joining the line with the preceding line.

  Emacs automatically splits lines when they become too long, if you
turn on a special mode called @dfn{Auto Fill} mode.  @xref{Filling}, for
information on using Auto Fill mode.

@findex delete-backward-char
@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.

@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.  There are two ways to use
@kbd{C-q}:@refill

@itemize @bullet
@item
@kbd{Control-q} followed by any non-graphic character (even @kbd{C-g})
inserts that character.
@item
@kbd{Control-q} followed by three octal digits inserts the character
with the specified character code.
@end itemize

@noindent
A numeric argument to @kbd{C-q} specifies how many copies of the quoted
character should be inserted (@pxref{Arguments}).

  If you prefer to have text characters replace (overwrite) existing
text instead of moving it to the right, you can enable Overwrite mode, a
minor mode.  @xref{Minor Modes}.

@section Changing the Location of Point

  To do more than insert characters, you have to know how to move point
(@pxref{Point}).  Here are a few of the available commands.

  NOTE: Many of the following commands have two versions, one that uses
the function keys (e.g. @key{LEFT} or @key{END}) and one that doesn't.
The former versions may only be available on X terminals (i.e. not on
TTY's), but the latter are available on all terminals.

@kindex C-a
@kindex C-e
@kindex C-f
@kindex C-b
@kindex C-n
@kindex C-p
@kindex C-l
@kindex C-t
@kindex C-v
@kindex M-v
@kindex M->
@kindex M-<
@kindex M-r
@kindex LEFT
@kindex RIGHT
@kindex UP
@kindex DOWN
@kindex HOME
@kindex END
@kindex PGUP
@kindex PGDN
@kindex C-LEFT
@kindex C-RIGHT
@kindex C-HOME
@kindex C-END
@findex beginning-of-line
@findex end-of-line
@findex forward-char
@findex backward-char
@findex next-line
@findex previous-line
@findex recenter
@findex transpose-chars
@findex beginning-of-buffer
@findex end-of-buffer
@findex goto-char
@findex goto-line
@findex move-to-window-line
@table @kbd
@item C-a
@itemx HOME
Move to the beginning of the line (@code{beginning-of-line}).
@item C-e
@itemx END
Move to the end of the line (@code{end-of-line}).
@item C-f
@itemx RIGHT
Move forward one character (@code{forward-char}).
@item C-b
@itemx LEFT
Move backward one character (@code{backward-char}).
@item M-f
@itemx C-RIGHT
Move forward one word (@code{forward-word}).
@item M-b
@itemx C-LEFT
Move backward one word (@code{backward-word}).
@item C-n
@itemx DOWN
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
@itemx UP
Move up one line, vertically (@code{previous-line}).
@item C-v
@itemx PGDN
Move down one page, vertically (@code{scroll-up}).
@item M-v
@itemx PGUP
Move up one page, vertically (@code{scroll-down}).
@item C-l
Clear the frame and reprint everything (@code{recenter}).  Text moves
on the frame to bring point to the center of the window.
@item M-r
Move point to left margin on the line halfway down the frame or
window (@code{move-to-window-line}).  Text does not move on the
frame.  A numeric argument says how many screen lines down from the
top of the window (zero for the top).  A negative argument counts from
the bottom (@minus{}1 for the bottom).
@item C-t
Transpose two characters, the ones before and after the cursor
@*(@code{transpose-chars}).
@item M-<
@itemx C-HOME
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->
@itemx C-END
Move to the end of the buffer (@code{end-of-buffer}).
@item M-x goto-char
Read a number @var{n} and move the cursor to character number @var{n}.
Position 1 is the beginning of the buffer.
@item M-g
Read a number @var{n} and move cursor to line number @var{n}
(@code{goto-line}).  Line 1 is the beginning of the buffer.
@item C-x C-n
@findex set-goal-column
Use the current column of point as the @dfn{semi-permanent 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 avoid changing the horizontal position, as usual.
@end table

@vindex track-eol
  If you set the variable @code{track-eol} to a non-@code{nil} value,
@kbd{C-n} and @kbd{C-p} move to the end of the line when at the end of
the starting line.  By default, @code{track-eol} is @code{nil}.

@section Erasing Text

@table @kbd
@item @key{DEL}
Delete the character before the cursor (@code{delete-backward-char}).
@item C-d
Delete the character after the cursor (@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

  In contrast to the @key{DEL} key, which deletes the character before
the cursor, @kbd{Control-d} deletes the character after the cursor,
causing the rest of the text on the line to shift left.  If
@kbd{Control-d} is typed at the end of a line, that line and the next
line are joined.

  To erase a larger amount of text, use @kbd{Control-k}, which kills a
line at a time.  If you use @kbd{C-k} at the beginning or in the middle
of a line, it kills all the text up to the end of the line.  If you use
@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.

@section Files

@cindex files
  The commands above are sufficient for creating and altering text in an
Emacs buffer.  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 and which
you can retrieve 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}.  To begin editing
this file from Emacs, type:

@example
C-x C-f /usr/rms/foo.c @key{RET}
@end example

@noindent
The file name is given as an @dfn{argument} to the command @kbd{C-x
C-f} (@code{find-file}).  The command uses the @dfn{minibuffer} to
read the argument.  You have to type @key{RET} to terminate the argument
(@pxref{Minibuffer}).@refill

  You can also use the @b{Open...} menu item from the @b{File} menu, then
type the name of the file to the prompt.

  Emacs obeys the command by @dfn{visiting} the file: it creates a
buffer, copies the contents of the file into the buffer, and then
displays the buffer for you to edit.  You can make changes in the
buffer, and then @dfn{save} the file by typing @kbd{C-x C-s}
(@code{save-buffer}) or choosing @b{Save Buffer} from the @b{File} menu.
This makes the changes permanent by copying the altered contents of the
buffer back into the file @file{/usr/rms/foo.c}.  Until then, the
changes are only inside your Emacs buffer, and the file @file{foo.c} is
not changed.@refill

  To create a file, visit the file with @kbd{C-x C-f} as if it already
existed or choose @b{Open...} from the @b{File} menu and provide the
name for the new file in the minibuffer.  Emacs will create an empty
buffer in which you can insert the text you want to put in the file.
When you save the buffer with @kbd{C-x C-s}, or by choosing @b{Save
Buffer} from the @b{File} menu, the file is created.

  To learn more about using files, @pxref{Files}.

@section Help

  If you forget what a key does, you can use the Help character
(@kbd{C-h}) to find out: Type @kbd{C-h k} followed by the key you want
to know about.  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} three times
to get a description of all the help facilities.  @xref{Help}.@refill

@menu
* Blank Lines::        Commands to make or delete blank lines.
* Continuation Lines:: Lines too wide for the frame.
* Position Info::      What page, line, row, or column is point on?
* Arguments::          Numeric arguments for repeating a command.
@end menu

@node Blank Lines, Continuation Lines, Basic, Basic
@section Blank Lines

  Here are special commands and techniques for entering and removing
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 just type the new line of text, followed by @key{RET}.  If you
prefer to create a blank line first and then insert the desired text,
use the key @kbd{C-o} (@code{open-line}), which inserts a newline after
point but leaves point in front of the newline.  Then type
the text into the new line.  @kbd{C-o F O O} has the same effect as
@kbd{F O O @key{RET}}, except for the final location of point.

  To create several blank lines, type @kbd{C-o} several times, or
give @kbd{C-o} an argument indicating how many blank lines to create.
@xref{Arguments}, for more information.

  If you have many blank lines in a row and want to get rid of them, use
@kbd{C-x C-o} (@code{delete-blank-lines}).  If point is on a blank
line which is adjacent to at least one other blank line, @kbd{C-x C-o}
deletes all but one of the blank lines.
If point is on a blank line with no other adjacent blank line, the
sole blank line is deleted.  If point is on a non-blank
line, @kbd{C-x C-o} deletes any blank lines following that non-blank
line.

@node Continuation Lines, Position Info, Blank Lines, Basic
@section Continuation Lines

@cindex continuation line
  If you add too many characters to one line without breaking with a
@key{RET}, the line grows to occupy two (or more) screen lines, with a
curved arrow at the extreme right margin of all but the last line.  The
curved arrow indicates 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 frame.  You can use Auto Fill mode (@pxref{Filling})
to have Emacs insert newlines automatically when a line gets too long.


@vindex truncate-lines
@cindex truncation
  Instead of continuation, long lines can be displayed by @dfn{truncation}.
This means that all the characters that do not fit in the width of the
frame or window do not appear at all.  They remain in the buffer,
temporarily invisible.  Three diagonal dots in the last column (instead of
the curved arrow inform you that truncation is in effect.

  To turn off continuation for a particular buffer, set the
variable @code{truncate-lines} to non-@code{nil} in that buffer.
Truncation instead of continuation also happens whenever horizontal
scrolling is in use, and optionally whenever side-by-side windows are in
use (@pxref{Windows}).  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}.@refill

@node Position Info, Arguments, Continuation Lines, Basic
@section Cursor Position Information

  If you are accustomed to other display editors, you may be surprised
that Emacs does not always display the page number or line number of
point in the mode line.  In Emacs, this information is only rarely
needed, and a number of commands are available to compute and print it.
Since text is stored in a way that makes it difficult to compute the
information, it is not displayed all the time.

@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-=
Print number of lines and characters in the current region 
(@code{count-lines-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
@cindex page number
@kindex M-=
@findex count-lines-region

  There are several commands for printing line numbers:
@itemize @bullet
@item
@kbd{M-x what-line} counts lines from the beginning of the file and
prints the line number point is on.  The first line of the file is line
number 1.  You can use these numbers as arguments to @kbd{M-x
goto-line}.
@item
@kbd{M-x what-page} counts pages from the beginning of the file, and
counts lines within the page, printing both of them.  @xref{Pages}, for
the command @kbd{C-x l}, which counts the lines in the current page.
@item
@kbd{M-=} (@code{count-lines-region}) prints the number of lines in
the region (@pxref{Mark}).
@end itemize

@kindex C-x =
@findex what-cursor-position
  The command @kbd{C-x =} (@code{what-cursor-position}) provides
information about point and about the column the cursor is in.
It prints a line in the echo area that looks like this:

@example
Char: x (0170)  point=65986 of 563027(12%)  column 44
@end example

@noindent
(In fact, this is the output produced when point is before @samp{column 44}
in the example.)

  The two values after @samp{Char:} describe the character following point,
first by showing it and second by giving its octal character code.

  @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 invisible, @kbd{C-x =} prints
additional text describing the current visible range.  For example, it
might say:

@smallexample
Char: x (0170)  point=65986 of 563025(12%) <65102 - 68533>  column 44
@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 visible ones.  @xref{Narrowing}.

  If point is at the end of the buffer (or the end of the visible part),
@kbd{C-x =} omits any description of the character after point.
The output looks like

@smallexample
point=563026 of 563025(100%)  column 0
@end smallexample

@node Arguments,, Position Info, Basic
@section Numeric Arguments
@cindex numeric arguments

  Any Emacs command can be given a @dfn{numeric argument}.  Some commands
interpret the argument as a repetition count.  For example, giving an
argument of ten to the key @kbd{C-f} (the command @code{forward-char}, move
forward one character) moves forward ten characters.  With these commands,
no argument is equivalent to an argument of one.  Negative arguments are
allowed.  Often they tell a command to move or act backwards.

@kindex M-1
@kindex M-@t{-}
@findex digit-argument
@findex negative-argument
  If your keyboard has a @key{META} key (labelled with a diamond on
Sun-type keyboards and labelled @samp{Alt} on some other 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
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.

@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 shift keys.  To type a negative argument, start with a minus sign.
Just a minus sign normally means @minus{}1.  @kbd{C-u} works on all terminals.

  @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 frame.  Other useful combinations are @kbd{C-u C-n},
@kbd{C-u C-u C-n} (move down a good fraction of a frame), @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}.)  Just @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 non-blank 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 will be
described when they come up; they are always to make the individual
command more convenient to use.

@c section Autoarg Mode
@ignore
@cindex autoarg mode
  Users of ASCII keyboards may prefer to use Autoarg mode.  Autoarg mode
means that you don't need to type @kbd{C-u} to specify a numeric argument.
Instead, you type just the digits.  Digits followed by an ordinary
inserting character are themselves inserted, but digits followed by an
Escape or Control character serve as an argument to it and are not
inserted.  A minus sign can also be part of an argument, but only at the
beginning.  If you type a minus sign following some digits, both the digits
and the minus sign are inserted.

  To use Autoarg mode, set the variable Autoarg Mode nonzero.
@xref{Variables}.

  Autoargument digits echo at the bottom of the frame; the first
nondigit causes them to be inserted or uses them as an argument.  To
insert some digits and nothing else, you must follow them with a Space
and then rub it out.  @kbd{C-g} cancels the digits, while Delete inserts
them all and then rubs out the last.
@end ignore