@c This is part of the Emacs manual.
-@c Copyright (C) 1985,86,87,93,94,95,97,00,2001 Free Software Foundation, Inc.
+@c Copyright (C) 1985,86,87,93,94,95,97,2000,2001,2004
+@c Free Software Foundation, Inc.
@c See file emacs.texi for copying conditions.
@iftex
@chapter Killing and Moving Text
ring}, from which it can be retrieved by @dfn{yanking} it. Some systems
use the terms ``cutting'' and ``pasting'' for these operations.
- The commonest way of moving or copying text within Emacs is to kill it
+ The most common way of moving or copying text within Emacs is to kill it
and later yank it elsewhere in one or more places. This is very safe
because Emacs remembers several recent kills, not just the last one. It
is versatile, because the many commands for killing syntactic units can
also be used for moving those units. But there are other ways of
copying text for special purposes.
+ On terminals that support multiple windows for multiple applications,
+the kill commands also provide a way to select text for other applications
+to copy, and the Emacs yank commands can access selections made by
+other programs.
+
Emacs has only one kill ring for all buffers, so you can kill text in
one buffer and yank it in another buffer.
@end iftex
+@ifnottex
+@raisesections
+@end ifnottex
+
@node Killing, Yanking, Mark, Top
@section Deletion and Killing
@cindex killing text
@cindex cutting text
@cindex deletion
- Most commands which erase text from the buffer save it in the kill
-ring so that you can move or copy it to other parts of the buffer.
+ Most commands which erase text from the buffer save it in the @dfn{kill
+ring} so that you can move or copy it to other parts of the buffer.
These commands are known as @dfn{kill} commands. The rest of the
commands that erase text do not save it in the kill ring; they are known
as @dfn{delete} commands. (This distinction is made only for erasure of
You cannot kill read-only text, since such text does not allow any
kind of modification. But some users like to use the kill commands to
copy read-only text into the kill ring, without actually changing it.
-If you set the variable @code{kill-read-only-ok} to a non-@code{nil}
-value, the kill commands work specially in a read-only buffer: they
-move over text, and copy it to the kill ring, without actually
-deleting it from the buffer. When this happens, a message in the echo
-area tells you what is happening.
+Therefore, the kill commands work specially in a read-only buffer:
+they move over text, and copy it to the kill ring, without actually
+deleting it from the buffer. Normally, Emacs beeps and prints an
+error message when this happens. But if you set the variable
+@code{kill-read-only-ok} to a non-@code{nil} value, it just prints a
+message in the echo area, telling you what is happening.
The delete commands include @kbd{C-d} (@code{delete-char}) and
@key{DEL} (@code{delete-backward-char}), which delete only one
individual descriptions use the words @samp{kill} and @samp{delete} to
say which kind of operation they perform.
+ On window systems, the most recent kill done in Emacs is also the
+primary selection, if it is more recent than any selection you made in
+another program. This means that the paste commands of other window
+applications copy the text that you killed in Emacs.
+
@cindex Delete Selection mode
@cindex mode, Delete Selection
@findex delete-selection-mode
blank areas.
* Killing by Lines:: How to kill entire lines of text at one time.
* Other Kill Commands:: Commands to kill large regions of text and
- syntactic units such as words and sentences.
+ syntactic units such as words and sentences.
@end menu
@need 1500
keys normally do the right things. But in some unusual cases Emacs
gets the wrong information from the system. If these keys don't do
what they ought to do, you need to tell Emacs which key to use for
-@key{DEL}. @xref{DEL Gets Help}, for how to do this.
+@key{DEL}. @xref{DEL Does Not Delete}, for how to do this.
@findex normal-erase-is-backspace-mode
On most text-only terminals, Emacs cannot tell which keys the
keyboard really has, so it follows a uniform plan which may or may not
-fit your keyboard. The uniform plan is that the ASCII @key{DEL}
-character deletes, and the ASCII @key{BS} (backspace) character asks
+fit your keyboard. The uniform plan is that the @acronym{ASCII} @key{DEL}
+character deletes, and the @acronym{ASCII} @key{BS} (backspace) character asks
for help (it is the same as @kbd{C-h}). If this is not right for your
-keyboard, i.e.@: if you find that the key which ought to delete backwards
-enters Help instead, see @ref{DEL Gets Help}.
+keyboard, such as if you find that the key which ought to delete backwards
+enters Help instead, see @ref{DEL Does Not Delete}.
@kindex M-\
@findex delete-horizontal-space
@findex kill-region
@kindex C-w
-@c DoubleWideCommands
@table @kbd
@item C-w
Kill region (from point to the mark) (@code{kill-region}).
@dfn{Yanking} means reinserting text previously killed. This is what
some systems call ``pasting.'' The usual way to move or copy text is to
-kill it and then yank it elsewhere one or more times.
+kill it and then yank it elsewhere one or more times. This is very safe
+because Emacs remembers many recent kills, not just the last one.
@table @kbd
@item C-y
Append next kill to last batch of killed text (@code{append-next-kill}).
@end table
+ On window systems, if there is a current selection in some other
+application, and you selected it more recently than you killed any
+text in Emacs, @kbd{C-y} copies the selection instead of text
+killed within Emacs.
+
@menu
* Kill Ring:: Where killed text is stored. Basic yanking.
* Appending Kills:: Several kills in a row all yank together.
a @kbd{C-u}, precisely. Any other sort of argument, including @kbd{C-u}
and digits, specifies an earlier kill to yank (@pxref{Earlier Kills}).
+@cindex yanking and text properties
+@vindex yank-excluded-properties
+ The yank commands discard certain text properties from the text that
+is yanked, those that might lead to annoying results. For instance,
+they discard text properties that respond to the mouse or specify key
+bindings. The variable @code{yank-excluded-properties} specifies the
+properties to discard. Yanking of register contents and rectangles
+also discard these properties.
+
@kindex M-w
@findex kill-ring-save
To copy a block of text, you can use @kbd{M-w}
yank'' pointer remains at the same place in the kill ring, so repeating
@kbd{C-y} will yank another copy of the same previous kill.
- If you know how many @kbd{M-y} commands it would take to find the text
-you want, you can yank that text in one step using @kbd{C-y} with a
-numeric argument. @kbd{C-y} with an argument restores the text the
-specified number of entries back in the kill ring. Thus, @kbd{C-u 2
-C-y} gets the next-to-the-last block of killed text. It is equivalent
-to @kbd{C-y M-y}. @kbd{C-y} with a numeric argument starts counting
-from the ``last yank'' pointer, and sets the ``last yank'' pointer to
-the entry that it yanks.
+ If you know how many @kbd{M-y} commands it would take to find the
+text you want, you can yank that text in one step using @kbd{C-y} with
+a numeric argument. @kbd{C-y} with an argument restores the text from
+the specified kill ring entry, counting back from the most recent as
+1. Thus, @kbd{C-u 2 C-y} gets the next-to-the-last block of killed
+text---it is equivalent to @kbd{C-y M-y}. @kbd{C-y} with a numeric
+argument starts counting from the ``last yank'' pointer, and sets the
+``last yank'' pointer to the entry that it yanks.
@vindex kill-ring-max
The length of the kill ring is controlled by the variable
@table @kbd
@item M-x append-to-buffer
-Append region to the contents of specified buffer.
+Append region to the contents of a specified buffer.
@item M-x prepend-to-buffer
-Prepend region to the contents of specified buffer.
+Prepend region to the contents of a specified buffer.
@item M-x copy-to-buffer
Copy region into a specified buffer, deleting that buffer's old contents.
@item M-x insert-buffer
-Insert the contents of specified buffer into current buffer at point.
+Insert the contents of a specified buffer into current buffer at point.
@item M-x append-to-file
-Append region to the contents of specified file, at the end.
+Append region to the contents of a specified file, at the end.
@end table
To accumulate text into a buffer, use @kbd{M-x append-to-buffer}.
To retrieve the accumulated text from another buffer, use the
command @kbd{M-x insert-buffer}; this too takes @var{buffername} as an
argument. It inserts a copy of the whole text in buffer
-@var{buffername} into the selected buffer at point, and sets the mark
+@var{buffername} into the current buffer at point, and sets the mark
after the inserted text. Alternatively, you can select the other
buffer for editing, then copy text from it by killing.
@xref{Buffers}, for background information on buffers.
@table @kbd
@item C-x r k
-Kill the text of the region-rectangle, saving its contents as the
+Kill the text of the region-rectangle, saving its contents as the
``last killed rectangle'' (@code{kill-rectangle}).
@item C-x r d
Delete the text of the region-rectangle (@code{delete-rectangle}).
Insert blank space to fill the space of the region-rectangle
(@code{open-rectangle}). This pushes the previous contents of the
region-rectangle rightward.
-@item M-x clear-rectangle
-Clear the region-rectangle by replacing its contents with spaces.
+@item C-x r c
+Clear the region-rectangle by replacing its contents with spaces
+(@code{clear-rectangle}).
@item M-x delete-whitespace-rectangle
Delete whitespace in each of the lines on the specified rectangle,
starting from the left edge column of the rectangle.
(@code{yank-rectangle}). Yanking a rectangle is the opposite of killing
one. Point specifies where to put the rectangle's upper left corner.
The rectangle's first line is inserted there, the rectangle's second
-line is inserted at the same horizontal, but one line vertically down,
-and so on. The number of lines affected is determined by the height of
-the saved rectangle.
+line is inserted at the same horizontal position, but one line
+vertically down, and so on. The number of lines affected is determined
+by the height of the saved rectangle.
You can convert single-column lists into double-column lists using
rectangle killing and yanking; kill the second half of the list as a
@kindex C-x r o
@findex open-rectangle
+@kindex C-x r c
@findex clear-rectangle
There are two commands you can use for making blank rectangles:
-@kbd{M-x clear-rectangle} which blanks out existing text, and @kbd{C-x r
-o} (@code{open-rectangle}) which inserts a blank rectangle. Clearing a
-rectangle is equivalent to deleting it and then inserting a blank
-rectangle of the same size.
+@kbd{C-x r c} (@code{clear-rectangle}) which blanks out existing text,
+and @kbd{C-x r o} (@code{open-rectangle}) which inserts a blank
+rectangle. Clearing a rectangle is equivalent to deleting it and then
+inserting a blank rectangle of the same size.
@findex delete-whitespace-rectangle
The command @kbd{M-x delete-whitespace-rectangle} deletes horizontal
rectangle shifts right.
@findex string-insert-rectangle
- The command @kbd{M-x string-insert-rectangle} is similar to
-@code{string-rectangle}, but inserts the string on each line,
+ The command @kbd{M-x string-insert-rectangle} is similar to
+@code{string-rectangle}, but inserts the string on each line,
shifting the original text to the right.
+
+@ifnottex
+@lowersections
+@end ifnottex
+
+@ignore
+ arch-tag: d8da8f96-0928-449a-816e-ff2d3497866c
+@end ignore