Selecting Text
**************

Many Emacs commands operate on an arbitrary contiguous part of the current buffer. You can select text in two ways:

  * You use special keys to select text by defining a region between point and the mark.

  * If you are running XEmacs under X, you can also select text with the mouse.

The Mark and the Region
=======================

To specify the text for a command to operate on, set the mark at one end of it, and move point to the other end.  The text between point and the mark is called the region.  You can move point or the mark to adjust the boundaries of the region.  It doesn't matter which one is set first chronologically, or which one comes earlier in the text.

Once the mark has been set, it remains until it is set again at another place.  The mark remains fixed with respect to the preceding character if text is inserted or deleted in a buffer.  Each Emacs buffer has its own mark; when you return to a buffer that had been selected previously, it has the same mark it had before.

Many commands that insert text, such as C-y (yank) and M-x insert-buffer, position the mark at one end of the inserted text---the opposite end from where point is positioned, so that the region contains the text just inserted.

Aside from delimiting the region, the mark is useful for marking a spot that you may want to go back to.  To make this feature more useful, Emacs remembers 16 previous locations of the mark in the mark ring.

Setting the Mark
----------------

Here are some commands for setting the mark:

C-SPC
     Set the mark where point is (set-mark-command).

C-@
     The same.

C-x C-x
     Interchange mark and point (exchange-point-and-mark).

C-<
     Pushes a mark at the beginning of the buffer.

C->
     Pushes a mark at the end of the buffer.

For example, to convert part of the buffer to all upper-case, you can use the C-x C-u (upcase-region) command, which operates on the text in the region.  First go to the beginning of the text you want to capitalize and type C-SPC to put the mark there, then move to the end, and then type C-x C-u to capitalize the selected region.  You can also set the mark at the end of the text, move to the beginning, and then type C-x C-u.  Most commands that operate on the text in the region have the word region in their names.

The most common way to set the mark is with the C-SPC command (set-mark-command).  This command sets the mark where point is. You can then move point away, leaving the mark behind.  It is actually incorrect to speak of the character C-SPC; there is no such character.  When you type SPC while holding down CTRL, you get the character C-@ on most terminals. This character is actually bound to set-mark-command.  But unless you are unlucky enough to have a terminal where typing C-SPC does not produce C-@, you should think of this character as C-SPC.

Since terminals have only one cursor, Emacs cannot show you where the mark is located. Most people use the mark soon after they set it, before they forget where it is. But you can see where the mark is with the command C-x C-x (exchange-point-and-mark) which puts the mark where point was and point where the mark was.  The extent of the region is unchanged, but the cursor and point are now at the previous location of the mark.

Another way to set the mark is to push the mark to the beginning of a buffer while leaving point at its original location. If you supply an argument to C-< (mark-beginning-of-buffer), the mark is pushed N/10 of the way from the true beginning of the buffer. You can also set the mark at the end of a buffer with C-> (mark-end-of-buffer). It pushes the mark to the end of the buffer, leaving point alone. Supplying an argument to the command pushes the mark N/10 of the way from the true end of the buffer.

If you are using XEmacs under the X window system, you can set the variable zmacs-regions to t. This makes the current region (defined by point and mark) highlight and makes it available as the X clipboard selection, which means you can use the menu bar items on it.  See Active Regions, for more information.

C-x C-x is also useful when you are satisfied with the location of point but want to move the mark; do C-x C-x to put point there and then you can move it.  A second use of C-x C-x, if necessary, puts the mark at the new location with point back at its original location.

Operating on the Region
-----------------------

Once you have created an active region, you can do many things to the text in it:

  * Kill it with C-w (see Killing).

  * Save it in a register with C-x r s (see Registers).

  * Save it in a buffer or a file (see Accumulating Text).

  * Convert case with C-x C-l or C-x C-u
     (see Case).

  * Evaluate it as Lisp code with M-x eval-region (see Lisp Eval).

  * Fill it as text with M-q (see Filling).

  * Print hardcopy with M-x print-region (see Hardcopy).

  * Indent it with C-x TAB or C-M-\ (see Indentation).

Commands to Mark Textual Objects
--------------------------------

There are commands for placing point and the mark around a textual object such as a word, list, paragraph or page.

M-@
     Set mark after end of next word (mark-word).  This command and the following one do not move point.

C-M-@
     Set mark after end of next Lisp expression (mark-sexp).

M-h
     Put region around current paragraph (mark-paragraph).

C-M-h
     Put region around current Lisp defun (mark-defun).

C-x h
     Put region around entire buffer (mark-whole-buffer).

C-x C-p
     Put region around current page (mark-page).

M-@ (mark-word) puts the mark at the end of the next word, while C-M-@ (mark-sexp) puts it at the end of the next Lisp expression. These characters sometimes save you some typing.

A number of commands are available that set both point and mark and thus delimit an object in the buffer.  M-h (mark-paragraph) moves point to the beginning of the paragraph that surrounds or follows point, and puts the mark at the end of that paragraph (see Paragraphs).  You can then indent, case-convert, or kill the whole paragraph.  In the same fashion, C-M-h (mark-defun) puts point before and the mark after the current or following defun (see Defuns).  C-x C-p (mark-page) puts point before the current page (or the next or previous, depending on the argument), and mark at the end (see Pages).  The mark goes after the terminating page delimiter (to include it), while point goes after the preceding page delimiter (to exclude it).  Finally, C-x h (mark-whole-buffer) sets up the entire buffer as the region by putting point at the beginning and the mark at the end.

The Mark Ring
-------------

Aside from delimiting the region, the mark is also useful for marking a spot that you may want to go back to.  To make this feature more useful, Emacs remembers 16 previous locations of the mark in the mark ring.  Most commands that set the mark push the old mark onto this ring.  To return to a marked location, use C-u C-SPC (or C-u C-@); this is the command set-mark-command given a numeric argument.  The command moves point to where the mark was, and restores the mark from the ring of former marks. Repeated use of this command moves point to all the old marks on the ring, one by one. The marks you have seen go to the end of the ring, so no marks are lost.

Each buffer has its own mark ring.  All editing commands use the current buffer's mark ring.  In particular, C-u C-SPC always stays in the same buffer.

Many commands that can move long distances, such as M-< (beginning-of-buffer), start by setting the mark and saving the old mark on the mark ring.  This makes it easier for you to move back later.  Searches set the mark, unless they do not actually move point. When a command sets the mark, Mark Set is printed in the echo area.

The variable mark-ring-max is the maximum number of entries to keep in the mark ring.  If that many entries exist and another entry is added, the last entry in the list is discarded.  Repeating C-u C-SPC circulates through the entries that are currently in the ring.

The variable mark-ring holds the mark ring itself, as a list of marker objects in the order most recent first.  This variable is local in every buffer.