Go to the first, previous, next, last section, table of contents.

# The Mark and the Region

Many Emacs commands 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. Emacs highlights the region whenever there is one, if you enable Transient Mark mode (see section Transient Mark Mode).

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 where you put it until you set it again at another place. 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 point and the mark at opposite ends of the inserted text, 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, each buffer remembers 16 previous locations of the mark in the mark ring.

- Setting Mark: Commands to set the mark.
- Transient Mark: How to make Emacs highlight the region-- when there is one.
- Using Region: Summary of ways to operate on contents of the region.
- Marking Objects: Commands to put region around textual units.
- Mark Ring: Previous mark positions saved so you can go back there.
- Global Mark Ring: Previous mark positions in various buffers.

## 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`).
`Drag-Mouse-1`
  Set point and the mark around the text you drag across.
`Mouse-3`
  Set the mark where point is, then move point to where you click (`mouse-save-then-kill`).

For example, suppose you wish to convert part of the buffer to all upper-case, using 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`.

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.

There are two ways to set the mark with the mouse. You can drag mouse button one across a range of text; that puts point where you release the mouse button, and sets the mark at the other end of that range. Or you can click mouse button three, which sets the mark at point (like `C-`SPC``) and them moves point (like `Mouse-1`). Both of these methods copy the region into the kill ring in addition to setting the mark; that gives behavior consistent with other window-driven applications, but if you don't want to modify the kill ring, you must use keyboard commands to set the mark. See section Mouse Commands for Editing.

Ordinary terminals have only one cursor, so 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. Alternatively, 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 position of the mark. In Transient Mark mode, this command reactivates the mark.

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

There is no such character as `C-`SPC`` in ASCII; when you type `SPC` while holding down `CTRL`, what you get on most ordinary terminals is the character `C-@`. This key 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 might as well think of this character as `C-`SPC``. Under X, `C-`SPC`` is actually a distinct character, but its binding is still `set-mark-command`.

## Transient Mark Mode

Emacs can highlight the current region, using X Windows. But normally it does not. Why not?

Highlighting the region doesn't work well ordinarily in Emacs, because once you have set a mark, there is always a region (in that buffer). And highlighting the region all the time would be a nuisance.

You can turn on region highlighting by enabling Transient Mark mode. This is a more rigid mode of operation in which the region "lasts" only temporarily, so you must set up a region for each command that uses one. In Transient Mark mode, most of the time there is no region; therefore, highlighting the region when it exists is convenient.

To enable Transient Mark mode, type `M-x transient-mark-mode`. This command toggles the mode, so you can repeat the command to turn off the mode.

Here are the details of Transient Mark mode:

- To set the mark, type `C-`SPC`` (`set-mark-command`). This makes the mark active; as you move point, you will see the region highlighting change in extent.
- The mouse commands for specifying the mark also make it active. So do keyboard commands whose purpose is to specify a region, including `M-@`, `C-M-@`, `M-h`, `C-M-h`, `C-x C-p`, and `C-x h`.
- When the mark is active, you can execute commands that operate on the region, such as killing, indentation, or writing to a file.
- Any change to the buffer, such as inserting or deleting a character, deactivates the mark. This means any subsequent command that operates on a region will get an error and refuse to operate. You can make the region active again by typing `C-x C-x`.
- Commands like `M->` and `C-s` that "leave the mark behind" in addition to some other primary purpose do not activate the new mark. You can activate the new region by executing `C-x C-x` (`exchange-point-and-mark`).
- `C-s` when the mark is active does not alter the mark.
- Quitting with `C-g` deactivates the mark.

Transient Mark mode is also sometimes known as "Zmacs mode" because the Zmacs editor on the MIT Lisp Machine handled the mark in a similar way.

When multiple windows show the same buffer, they can have different regions, because they can have different values of point (though they all share common one mark position). In Transient Mark mode, each window highlights its own region. The part that is highlighted in the selected window is the region that editing commands use. See section Multiple Windows.

When Transient Mark mode is not enabled, every command that sets the mark also activates it, and nothing ever deactivates it.

If the variable `mark-even-if-inactive` is non-`nil` in Transient Mark mode, then commands can use the mark and the region even when it is inactive. Region highlighting appears and disappears just as it normally does in Transient Mark mode, but the mark doesn't really go away when the highlighting disappears.

## Operating on the Region

Once you have a region and the mark is active, here are some of the ways you can operate on the region:

- Kill it with `C-w` (see section Deletion and Killing).
- Save it in a register with `C-x r s` (see section Registers).
- Save it in a buffer or a file (see section Accumulating Text).
- Convert case with `C-x C-l` or `C-x C-u` (see section Case Conversion Commands).
- Indent it with `C-x `TAB`` or `C-M-\` (see section Indentation).
- Fill it as text with `M-x fill-region` (see section Filling Text).
- Print hardcopy with `M-x print-region` (see section Hardcopy Output).
- Evaluate it as Lisp code with `M-x eval-region` (see section Evaluating Emacs-Lisp Expressions).

Most commands that operate on the text in the region have the word `region` in their names.

## Commands to Mark Textual Objects

Here are the 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 commands handle arguments just like `M-f` and `C-M-f`.

Other commands set both point and mark, to delimit an object in the buffer. For example, `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). It prepares the region so you can 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, 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). A numeric argument specifies a later page (if positive) or an earlier page (if negative) instead of the current page.

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.

In Transient Mark mode, all of these commands activate the mark.

## The Mark Ring

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, each buffer remembers 16 previous locations of the mark, in the mark ring. Commands that set the mark also 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. Thus, repeated use of this command moves point to all of the old marks on the ring, one by one. The mark positions you move through in this way are not lost; they go to the end of the ring.

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 set the mark if they move point. You can tell when a command sets the mark because it displays ``Mark Set'` in the echo area.

If you want to move back to the same place over and over, the mark ring may not be convenient enough. If so, you can record the position in a register for later retrieval (see section Saving Positions in Registers).

The variable `mark-ring-max` specifies 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 positions 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.

## The Global Mark Ring

In addition to the ordinary mark ring that belongs to each buffer, Emacs has a single global mark ring. It records a sequence of buffers in which you have recently set the mark, so you can go back to those buffers.

Setting the mark always makes an entry on the current buffer's mark ring. If you have switched buffers since the previous mark setting, the new mark position makes an entry on the global mark ring also. The result is that the global mark ring records a sequence of buffers that you have been in, and, for each buffer, a place where you set the mark.

The command `C-x C-`SPC`` (`pop-global-mark`) jumps to the buffer and position of the latest entry in the global ring. It also rotates the ring, so that successive uses of `C-x C-`SPC`` take you to earlier and earlier buffers.

Go to the first, previous, next, last section, table of contents.