Basic Editing Commands
**********************

We now give the basics of how to enter text, make corrections, and save the text in a file.  If this material is new to you, you might learn it more easily by running the Emacs learn-by-doing tutorial.  To use the tutorial, run Emacs and type Control-h t (help-with-tutorial).  You can also use Tutorials item from the Help menu.

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

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

Inserting Text
==============

To insert printing characters into the text you are editing, just type them.  This inserts the characters you type into the buffer at the cursor (that is, at point; see Point).  The cursor moves forward, and any text after the cursor moves forward too.  If the text in the buffer is FOOBAR, with the cursor before the B, then if you type XX, you get FOOXXBAR, with the cursor still before the B.

To delete text you have just inserted, use BS.  BS deletes the character before the cursor (not the one that the cursor is on top of or under; that is the character AFTER the cursor).  The cursor and all characters after it move backwards. Therefore, if you type a printing character and then type BS, they cancel out.

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

Emacs can split lines automatically when they become too long, if you turn on a special minor mode called Auto Fill mode. See 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.  See Minor Modes.

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

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

  * C-q followed by a sequence of octal digits inserts the character with the specified octal character code.  You can use any number of octal digits; any non-digit terminates the sequence.  If the terminating character is RET, it serves only to terminate the sequence; any other non-digit 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.)

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

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

Changing the Location of Point
==============================

To do more than insert characters, you have to know how to move point (see 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. LEFT or 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.

C-a
HOME
     Move to the beginning of the line (beginning-of-line).

C-e
END
     Move to the end of the line (end-of-line).

C-f
RIGHT
     Move forward one character (forward-char).

C-b
LEFT
     Move backward one character (backward-char).

M-f
C-RIGHT
     Move forward one word (forward-word).

M-b
C-LEFT
     Move backward one word (backward-word).

C-n
DOWN
     Move down one line, vertically (next-line).  This command attempts to keep the horizontal position unchanged, so if you start in the middle of one line, you end in the middle of the next.  When on the last line of text, C-n creates a new line and moves onto it.

C-p
UP
     Move up one line, vertically (previous-line).

C-v
PGDN
     Move down one page, vertically (scroll-up).

M-v
PGUP
     Move up one page, vertically (scroll-down).

C-l
     Clear the frame and reprint everything (recenter).  Text moves on the frame to bring point to the center of the window.

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

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

C-t
     Transpose two characters, the ones before and after the cursor (transpose-chars).

M-<
C-HOME
     Move to the top of the buffer (beginning-of-buffer).  With numeric argument N, move to N/10 of the way from the top. See Arguments, for more information on numeric arguments.

M->
C-END
     Move to the end of the buffer (end-of-buffer).

M-x goto-char
     Read a number N and move point to buffer position N. Position 1 is the beginning of the buffer.

M-g
     Read a number N and move point to line number N (goto-line).  Line 1 is the beginning of the buffer.

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

C-u M-x set-goal-column
     Cancel the goal column.  Henceforth, C-n and C-p once again try to avoid changing the horizontal position, as usual.

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

Normally, C-n on the last line of a buffer appends a newline to it.  If the variable next-line-add-newlines is nil, then C-n gets an error instead (like C-p on the first line).

Erasing Text
============

DEL
     Delete the character before or after point (backward-or-forward-delete-char).  You can customize this behavior by setting the variable delete-key-deletes-forward.

C-d
     Delete the character after point (delete-char).

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

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

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

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

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

See Killing, for more flexible ways of killing text.

Files
=====

The commands described above are sufficient for creating and altering text in an Emacs buffer; the more advanced Emacs commands just make things easier.  But to keep any text permanently you must put it in a file.  Files are named units of text which are stored by the operating system for you to retrieve later by name.  To look at or use the contents of a file in any way, including editing the file with Emacs, you must specify the file name.

Consider a file named /usr/rms/foo.c.  To begin editing this file from Emacs, type:

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

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

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

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

To create a file, visit the file with C-x C-f as if it already existed or choose Open... from the 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 C-x C-s, or by choosing Save Buffer from the File menu, the file is created.

To learn more about using files, see Files.

Help
====

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

Blank Lines
===========

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

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

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

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

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

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

Continuation Lines
==================

If you add too many characters to one line without breaking it with 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 continuation of a line too long to fit the screen.  Continuation is also called 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 (see Filling) if that's what you want.

Instead of continuation, long lines can be displayed by 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 (see Windows).  You can enable truncation for a particular buffer by setting the variable truncate-lines to non-nil in that buffer.  (see Variables.)  Altering the value of truncate-lines makes it local to the current buffer; until that time, the default value is in effect.  The default is initially nil.  See Locals.

See Display Vars, for additional variables that affect how text is displayed.

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.

M-x what-page
     Print page number of point, and line number within page.

M-x what-line
     Print line number of point in the buffer.

M-x line-number-mode
     Toggle automatic display of current line number.

M-=
     Print number of lines and characters in the current region (count-lines-region).  See Mark, for information about the region.

C-x =
     Print character code of character after point, character position of point, and column of point (what-cursor-position).

There are several commands for printing line numbers:

  * 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 M-x goto-line.

  * M-x what-page counts pages from the beginning of the file, and counts lines within the page, printing both of them.  See Pages, for the command C-x l, which counts the lines in the current page.

  * M-= (count-lines-region) prints the number of lines in the region (see Mark).  See Pages, for the command C-x l which counts the lines in the

The command C-x = (what-cursor-position) can be used to find out the column that the cursor is in, and other miscellaneous information about point.  It prints a line in the echo area that looks like this:

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

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

The four values after Char: describe the character that follows point, first by showing it and then by giving its character code in octal, decimal and hex.

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

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

If the buffer has been narrowed, making some of the text at the beginning and the end temporarily invisible, C-x = prints additional text describing the current visible range.  For example, it might say:

     Char: c (0143, 99, 0x63)  point=19674 of 24575(80%) <19591 - 19703>  column 69

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.  See Narrowing.

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

     point=563026 of 563025(100%)  column 0

Numeric Arguments
=================

In mathematics and computer usage, the word argument means ``data provided to a function or operation.''  Any Emacs command can be given a numeric argument (also called a prefix argument). Some commands interpret the argument as a repetition count.  For example, giving an argument of ten to the key C-f (the command 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.

If your keyboard has a META key (labelled with a diamond on Sun-type keyboards and labelled 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 META key.  For example,

     M-5 C-n

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

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

C-u followed by a character which is neither a digit nor a minus sign has the special meaning of ``multiply by four''.  It multiplies the argument for the next command by four.  C-u twice multiplies it by sixteen.  Thus, C-u C-u C-f moves forward sixteen characters.  This is a good way to move forward ``fast'', since it moves about 1/5 of a line in the usual size frame.  Other useful combinations are C-u C-n, C-u C-u C-n (move down a good fraction of a frame), C-u C-u C-o (make ``a lot'' of blank lines), and C-u C-k (kill four lines).

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

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

A few commands treat a plain C-u differently from an ordinary argument.  A few others may treat an argument of just a minus sign differently from an argument of -1.  These unusual cases are described when they come up; they are always for reasons of convenience of use of the individual command.

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

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