@c This is part of the XEmacs manual.
@c Copyright (C) 1985, 86, 87, 93, 94, 95, 1997 Free Software Foundation, Inc.
@c See file xemacs.texi for copying conditions.
@node Basic, Undo, Packages, 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}).  You can also use @b{Tutorials} item from
the @b{Help} menu.

XEmacs comes with many translations of tutorial.  If your XEmacs is with
MULE and you set up language environment correctly, XEmacs chooses right
tutorial when available (@pxref{Language Environments}).  If you want
specific translation, give @kbd{C-h t} a prefix argument, like @kbd{C-u
C-h t}.

  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.
* 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.
@c * Repeating::           A short-cut for repeating the previous command.
@end menu

@node Inserting Text, Moving Point, , Basic
@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 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}.

@kindex BS
@cindex deletion
   To @dfn{delete} text you have just inserted, use @key{BS}.  @key{BS}
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{BS}, 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}:

@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
A numeric argument to @kbd{C-q} specifies how many copies of the quoted
character should be inserted (@pxref{Arguments}).

@findex backward-or-forward-delete-char
@findex newline
@findex self-insert
  Customization information: @key{DEL}, in most modes, runs the command
@code{backward-or-forward-delete-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, Erasing, Inserting Text, Basic
@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.

  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, 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 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 point to buffer position @var{n}.
Position 1 is the beginning of the buffer.
@item M-g
Read a number @var{n} and move point to line number @var{n}
(@code{goto-line}).  Line 1 is the beginning of the buffer.
@c @item C-x C-n
@item M-x set-goal-column
@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.
@c @item C-u C-x C-n
@item C-u M-x set-goal-column
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,
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, Basic Files, Moving Point, Basic
@section Erasing Text

@table @kbd
@item @key{DEL}
Delete the character before or after point
(@code{backward-or-forward-delete-char}).  You can customize
this behavior by setting the variable @code{delete-key-deletes-forward}.
@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 Basic Files, Basic Help, Erasing, Basic
@section Files

@cindex 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}.  To begin editing
this file from Emacs, 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}).

  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: 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}) or
choosing @b{Save Buffer} from the @b{File} menu.  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, 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.  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, @xref{Files}.

@node Basic Help, Blank Lines, Basic Files, Basic
@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}.

@node Blank Lines, Continuation Lines, Basic Help, Basic
@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, Position Info, Blank Lines, Basic
@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 curved arrow at the extreme right margin of all but the
last of them.  The curved arrow 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
  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.  Right arrow in the last column (instead of the
curved arrow) 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, 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-x line-number-mode
Toggle automatic display of current line number.
@item M-=
Print number of lines and characters 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
@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}).  @xref{Pages}, for the command @kbd{C-x l} which
counts the lines in the
@end itemize

@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:

@example
Char: c (0143, 99, 0x63)  point=18862 of 24800(76%)  column 53 
@end example

@noindent
(In fact, this is the output produced when point is before @samp{column
53} 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. 

  @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: c (0143, 99, 0x63)  point=19674 of 24575(80%) <19591 - 19703>  column 69 
@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

  In mathematics and computer usage, the word @dfn{argument} means
``data provided to a function or operation.''  Any Emacs command can be
given a @dfn{numeric argument} (also called a @dfn{prefix 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  in the opposite direction.

@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
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 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).

  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}.)

  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.

@ignore
@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.

@end ignore