Go to the previous, next section.
There are many Emacs commands which operate on an arbitrary contiguous part of the current buffer. To specify the text for such a command to operate on, you 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 the buffer. Each Emacs buffer has its own mark, so that 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 also useful for remembering
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.
Here are some commands for setting the mark:
set-mark-command).
exchange-point-and-mark).
For example, if you wish 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. You can first go to the beginning of the text
to be capitalized, type C-SPC to put the mark there, move to
the end, and then type C-x C-u. Or, you can 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 sets the mark where point is. Then you
can 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, what you get on most
terminals is the character C-@. This is the key 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
might as well think of this character as C-SPC.
Since terminals have only one cursor, there is no way for Emacs to show
you where the mark is located. You have to remember. The usual solution
to this problem is to set the mark and then use it soon, before you 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.
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.
Once you have created an active region, you can do many things to the text in it:
There are commands for placing point and the mark around a textual object such as a word, list, paragraph or page.
mark-word). This command and
the following one do not move point.
mark-sexp).
mark-paragraph).
mark-defun).
mark-whole-buffer).
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 allow you to save a little typing or
redisplay, sometimes.
Other commands set both point and mark, to 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 section Paragraphs). M-h does all that's
necessary if you wish to indent, case-convert, or kill a whole paragraph.
C-M-h (mark-defun) similarly puts point before and the mark
after the current or following defun (see section Defuns). C-x C-p
(mark-page) puts point before the current page (or the next or
previous, according to the argument), and mark at the end (see section 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.
Aside from delimiting the region, the mark is also useful for remembering
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. It moves
point to where the mark was, and restores the mark from the ring of former
marks. So repeated use of this command moves point to all of the old marks
on the ring, one by one. The marks you see 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 is to make it easier for you to move back
later. Searches do this except when they do not actually move point. You
can tell when a command sets the mark because `Mark Set' is printed in
the echo area.
Another way of remembering positions so you can go back to them is with registers (see section Saving Positions in Registers).
The variable mark-ring-max is the maximum number of entries to
keep in the mark ring. If that many entries exist and another one is
pushed, the last one in the list is discarded. Repeating C-u
C-SPC circulates through the limited number of 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.
Go to the previous, next section.