Mercurial > emacs
annotate man/killing.texi @ 36720:d587de1b655a
(Deletion): Fix last change.
author | Eli Zaretskii <eliz@gnu.org> |
---|---|
date | Sun, 11 Mar 2001 17:55:15 +0000 |
parents | 0ee33338bb24 |
children | 640fb21a2098 |
rev | line source |
---|---|
25829 | 1 @c This is part of the Emacs manual. |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
2 @c Copyright (C) 1985,86,87,93,94,95,97,00,2001 Free Software Foundation, Inc. |
25829 | 3 @c See file emacs.texi for copying conditions. |
4 @iftex | |
5 @chapter Killing and Moving Text | |
6 | |
7 @dfn{Killing} means erasing text and copying it into the @dfn{kill | |
8 ring}, from which it can be retrieved by @dfn{yanking} it. Some systems | |
9 use the terms ``cutting'' and ``pasting'' for these operations. | |
10 | |
11 The commonest way of moving or copying text within Emacs is to kill it | |
12 and later yank it elsewhere in one or more places. This is very safe | |
13 because Emacs remembers several recent kills, not just the last one. It | |
14 is versatile, because the many commands for killing syntactic units can | |
15 also be used for moving those units. But there are other ways of | |
16 copying text for special purposes. | |
17 | |
18 Emacs has only one kill ring for all buffers, so you can kill text in | |
19 one buffer and yank it in another buffer. | |
20 | |
21 @end iftex | |
22 | |
23 @node Killing, Yanking, Mark, Top | |
24 @section Deletion and Killing | |
25 | |
26 @cindex killing text | |
27 @cindex cutting text | |
28 @cindex deletion | |
29 Most commands which erase text from the buffer save it in the kill | |
30 ring so that you can move or copy it to other parts of the buffer. | |
31 These commands are known as @dfn{kill} commands. The rest of the | |
32 commands that erase text do not save it in the kill ring; they are known | |
33 as @dfn{delete} commands. (This distinction is made only for erasure of | |
34 text in the buffer.) If you do a kill or delete command by mistake, you | |
35 can use the @kbd{C-x u} (@code{undo}) command to undo it | |
36 (@pxref{Undo}). | |
37 | |
30771
e9948dd313fa
(Killing): Document kill-read-only-ok.
Eli Zaretskii <eliz@gnu.org>
parents:
27749
diff
changeset
|
38 @vindex kill-read-only-ok |
e9948dd313fa
(Killing): Document kill-read-only-ok.
Eli Zaretskii <eliz@gnu.org>
parents:
27749
diff
changeset
|
39 @cindex read-only text, killing |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
40 You cannot kill read-only text, since such text does not allow any |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
41 kind of modification. But some users like to use the kill commands to |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
42 copy read-only text into the kill ring, without actually changing it. |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
43 If you set the variable @code{kill-read-only-ok} to a non-@code{nil} |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
44 value, the kill commands work specially in a read-only buffer: they |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
45 move over text, and copy it to the kill ring, without actually |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
46 deleting it from the buffer. When this happens, a message in the echo |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
47 area tells you what is happening. |
35918
89bf4e8936b6
(Killing): Document that kill commands in a read-only buffer do
Eli Zaretskii <eliz@gnu.org>
parents:
33805
diff
changeset
|
48 |
25829 | 49 The delete commands include @kbd{C-d} (@code{delete-char}) and |
50 @key{DEL} (@code{delete-backward-char}), which delete only one character at | |
51 a time, and those commands that delete only spaces or newlines. Commands | |
52 that can destroy significant amounts of nontrivial data generally kill. | |
53 The commands' names and individual descriptions use the words @samp{kill} | |
54 and @samp{delete} to say which they do. | |
55 | |
30865 | 56 @cindex Delete Selection mode |
57 @cindex mode, Delete Selection | |
58 @findex delete-selection-mode | |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
59 Many window systems follow the convention that insertion while text |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
60 is selected deletes the selected text. You can make Emacs behave this |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
61 way by enabling Delete Selection mode, with @kbd{M-x |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
62 delete-selection-mode}, or using Custom. Another effect of this mode |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
63 is that @key{DEL}, @kbd{C-d} and some other keys, when a selection |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
64 exists, will kill the whole selection. It also enables Transient Mark |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
65 mode (@pxref{Transient Mark}). |
30865 | 66 |
25829 | 67 @menu |
68 * Deletion:: Commands for deleting small amounts of text and | |
69 blank areas. | |
70 * Killing by Lines:: How to kill entire lines of text at one time. | |
71 * Other Kill Commands:: Commands to kill large regions of text and | |
72 syntactic units such as words and sentences. | |
73 @end menu | |
74 | |
75 @node Deletion | |
76 @subsection Deletion | |
77 @c ??? Should be backward-delete-char | |
78 @findex delete-backward-char | |
79 @findex delete-char | |
80 @kindex DEL | |
81 @kindex C-d | |
82 | |
83 @table @kbd | |
84 @item C-d | |
36657
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
85 @itemx @key{Delete} |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
86 Delete next character (@code{delete-char}). If your keyboard has a |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
87 @key{Delete} function key (usually located in the edit keypad), Emacs |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
88 binds it to @code{delete-char} as well. |
25829 | 89 @item @key{DEL} |
36657
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
90 @itemx @key{BS} |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
91 Delete previous character (@code{delete-backward-char}). Some keyboards |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
92 refer to this key as a ``backspace key'' and label it with a left arrow: |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
93 @key{<-}. |
25829 | 94 @item M-\ |
95 Delete spaces and tabs around point (@code{delete-horizontal-space}). | |
96 @item M-@key{SPC} | |
97 Delete spaces and tabs around point, leaving one space | |
98 (@code{just-one-space}). | |
99 @item C-x C-o | |
100 Delete blank lines around the current line (@code{delete-blank-lines}). | |
101 @item M-^ | |
102 Join two lines by deleting the intervening newline, along with any | |
103 indentation following it (@code{delete-indentation}). | |
104 @end table | |
105 | |
106 The most basic delete commands are @kbd{C-d} (@code{delete-char}) and | |
107 @key{DEL} (@code{delete-backward-char}). @kbd{C-d} deletes the | |
108 character after point, the one the cursor is ``on top of.'' This | |
109 doesn't move point. @key{DEL} deletes the character before the cursor, | |
110 and moves point back. You can delete newlines like any other characters | |
111 in the buffer; deleting a newline joins two lines. Actually, @kbd{C-d} | |
112 and @key{DEL} aren't always delete commands; when given arguments, they | |
113 kill instead, since they can erase more than one character this way. | |
114 | |
36657
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
115 @findex delete-key-deletes-forward-mode |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
116 Some keyboards have both @key{Delete} and @key{DEL} keys, while others |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
117 have just @key{DEL}. (The former variety usually labels the @key{DEL} |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
118 key as @key{BS} or @key{<-} and refers to it as a ``backspace key''.) |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
119 When Emacs starts, it tries to detect keyboards with both @key{BS} and |
36720
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
120 @key{Delete} keys, and if it finds your keyboard to have both keys, it |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
121 binds them to the commands users expect: @key{Delete} deletes forward, |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
122 like @kbd{C-d} does, and @key{BS} deletes backwards. However, some |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
123 systems don't report the keyboard configuration. If your keyboard has |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
124 these two keys, and if they are both reported to Emacs, but Emacs is |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
125 unable to establish that, you can use the |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
126 @code{delete-key-deletes-forward-mode} command to force Emacs to treat |
d587de1b655a
(Deletion): Fix last change.
Eli Zaretskii <eliz@gnu.org>
parents:
36657
diff
changeset
|
127 @key{BS} and @key{Delete} differently. Either type @kbd{C-u 1 M-x |
36657
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
128 delete-key-deletes-forward-mode @key{RET}} or put the following line |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
129 into your @file{.emacs} init file (@pxref{Init File}): |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
130 |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
131 @lisp |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
132 (delete-key-deletes-forward-mode 1) |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
133 @end lisp |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
134 |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
135 @noindent |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
136 @vindex delete-key-deletes-forward |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
137 The variable @code{delete-key-deletes-forward}, if set to @code{t}, |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
138 tells Emacs that the @key{Delete} key deletes the character after the |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
139 cursor. |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
140 |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
141 @noindent |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
142 To find out whether the @key{BS} and @key{Delete} keys are reported to |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
143 Emacs, type @kbd{C-h c @key{BS} C-h c @key{Delete}}, and then type |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
144 @kbd{C-h l}. If the text in the window popped up by Emacs after the |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
145 last command includes ``C-h c backspace'' and ``C-h c delete'', you know |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
146 that these keys are reported to Emacs. |
0ee33338bb24
(Deletion): Mention the Delete vs Backspace keys. Document
Eli Zaretskii <eliz@gnu.org>
parents:
36162
diff
changeset
|
147 |
25829 | 148 @kindex M-\ |
149 @findex delete-horizontal-space | |
150 @kindex M-SPC | |
151 @findex just-one-space | |
152 The other delete commands are those which delete only whitespace | |
153 characters: spaces, tabs and newlines. @kbd{M-\} | |
154 (@code{delete-horizontal-space}) deletes all the spaces and tab | |
155 characters before and after point. @kbd{M-@key{SPC}} | |
156 (@code{just-one-space}) does likewise but leaves a single space after | |
157 point, regardless of the number of spaces that existed previously (even | |
158 zero). | |
159 | |
160 @kbd{C-x C-o} (@code{delete-blank-lines}) deletes all blank lines | |
161 after the current line. If the current line is blank, it deletes all | |
162 blank lines preceding the current line as well (leaving one blank line, | |
163 the current line). | |
164 | |
165 @kbd{M-^} (@code{delete-indentation}) joins the current line and the | |
166 previous line, by deleting a newline and all surrounding spaces, usually | |
167 leaving a single space. @xref{Indentation,M-^}. | |
168 | |
169 @node Killing by Lines | |
170 @subsection Killing by Lines | |
171 | |
172 @table @kbd | |
173 @item C-k | |
174 Kill rest of line or one or more lines (@code{kill-line}). | |
175 @end table | |
176 | |
177 @kindex C-k | |
178 @findex kill-line | |
179 The simplest kill command is @kbd{C-k}. If given at the beginning of | |
180 a line, it kills all the text on the line, leaving it blank. When used | |
181 on a blank line, it kills the whole line including its newline. To kill | |
182 an entire non-blank line, go to the beginning and type @kbd{C-k} twice. | |
183 | |
184 More generally, @kbd{C-k} kills from point up to the end of the line, | |
185 unless it is at the end of a line. In that case it kills the newline | |
186 following point, thus merging the next line into the current one. | |
187 Spaces and tabs that you can't see at the end of the line are ignored | |
188 when deciding which case applies, so if point appears to be at the end | |
189 of the line, you can be sure @kbd{C-k} will kill the newline. | |
190 | |
191 When @kbd{C-k} is given a positive argument, it kills that many lines | |
192 and the newlines that follow them (however, text on the current line | |
193 before point is spared). With a negative argument @minus{}@var{n}, it | |
194 kills @var{n} lines preceding the current line (together with the text | |
195 on the current line before point). Thus, @kbd{C-u - 2 C-k} at the front | |
196 of a line kills the two previous lines. | |
197 | |
198 @kbd{C-k} with an argument of zero kills the text before point on the | |
199 current line. | |
200 | |
201 @vindex kill-whole-line | |
202 If the variable @code{kill-whole-line} is non-@code{nil}, @kbd{C-k} at | |
203 the very beginning of a line kills the entire line including the | |
204 following newline. This variable is normally @code{nil}. | |
205 | |
206 @node Other Kill Commands | |
207 @subsection Other Kill Commands | |
208 @findex kill-region | |
209 @kindex C-w | |
210 | |
211 @c DoubleWideCommands | |
212 @table @kbd | |
213 @item C-w | |
214 Kill region (from point to the mark) (@code{kill-region}). | |
215 @item M-d | |
216 Kill word (@code{kill-word}). @xref{Words}. | |
217 @item M-@key{DEL} | |
218 Kill word backwards (@code{backward-kill-word}). | |
219 @item C-x @key{DEL} | |
220 Kill back to beginning of sentence (@code{backward-kill-sentence}). | |
221 @xref{Sentences}. | |
222 @item M-k | |
223 Kill to end of sentence (@code{kill-sentence}). | |
224 @item C-M-k | |
225 Kill sexp (@code{kill-sexp}). @xref{Lists}. | |
226 @item M-z @var{char} | |
227 Kill through the next occurrence of @var{char} (@code{zap-to-char}). | |
228 @end table | |
229 | |
230 A kill command which is very general is @kbd{C-w} | |
231 (@code{kill-region}), which kills everything between point and the | |
232 mark. With this command, you can kill any contiguous sequence of | |
233 characters, if you first set the region around them. | |
234 | |
235 @kindex M-z | |
236 @findex zap-to-char | |
237 A convenient way of killing is combined with searching: @kbd{M-z} | |
238 (@code{zap-to-char}) reads a character and kills from point up to (and | |
239 including) the next occurrence of that character in the buffer. A | |
240 numeric argument acts as a repeat count. A negative argument means to | |
241 search backward and kill text before point. | |
242 | |
243 Other syntactic units can be killed: words, with @kbd{M-@key{DEL}} and | |
244 @kbd{M-d} (@pxref{Words}); sexps, with @kbd{C-M-k} (@pxref{Lists}); and | |
245 sentences, with @kbd{C-x @key{DEL}} and @kbd{M-k} | |
246 (@pxref{Sentences}).@refill | |
247 | |
248 You can use kill commands in read-only buffers. They don't actually | |
249 change the buffer, and they beep to warn you of that, but they do copy | |
250 the text you tried to kill into the kill ring, so you can yank it into | |
251 other buffers. Most of the kill commands move point across the text | |
252 they copy in this way, so that successive kill commands build up a | |
253 single kill ring entry as usual. | |
254 | |
255 @node Yanking, Accumulating Text, Killing, Top | |
256 @section Yanking | |
257 @cindex moving text | |
258 @cindex copying text | |
259 @cindex kill ring | |
260 @cindex yanking | |
261 @cindex pasting | |
262 | |
263 @dfn{Yanking} means reinserting text previously killed. This is what | |
264 some systems call ``pasting.'' The usual way to move or copy text is to | |
265 kill it and then yank it elsewhere one or more times. | |
266 | |
267 @table @kbd | |
268 @item C-y | |
269 Yank last killed text (@code{yank}). | |
270 @item M-y | |
271 Replace text just yanked with an earlier batch of killed text | |
272 (@code{yank-pop}). | |
273 @item M-w | |
274 Save region as last killed text without actually killing it | |
275 (@code{kill-ring-save}). | |
276 @item C-M-w | |
277 Append next kill to last batch of killed text (@code{append-next-kill}). | |
278 @end table | |
279 | |
280 @menu | |
281 * Kill Ring:: Where killed text is stored. Basic yanking. | |
282 * Appending Kills:: Several kills in a row all yank together. | |
283 * Earlier Kills:: Yanking something killed some time ago. | |
284 @end menu | |
285 | |
286 @node Kill Ring | |
287 @subsection The Kill Ring | |
288 | |
289 All killed text is recorded in the @dfn{kill ring}, a list of blocks of | |
290 text that have been killed. There is only one kill ring, shared by all | |
291 buffers, so you can kill text in one buffer and yank it in another buffer. | |
292 This is the usual way to move text from one file to another. | |
293 (@xref{Accumulating Text}, for some other ways.) | |
294 | |
295 @kindex C-y | |
296 @findex yank | |
297 The command @kbd{C-y} (@code{yank}) reinserts the text of the most recent | |
298 kill. It leaves the cursor at the end of the text. It sets the mark at | |
299 the beginning of the text. @xref{Mark}. | |
300 | |
301 @kbd{C-u C-y} leaves the cursor in front of the text, and sets the | |
302 mark after it. This happens only if the argument is specified with just | |
303 a @kbd{C-u}, precisely. Any other sort of argument, including @kbd{C-u} | |
304 and digits, specifies an earlier kill to yank (@pxref{Earlier Kills}). | |
305 | |
306 @kindex M-w | |
307 @findex kill-ring-save | |
308 To copy a block of text, you can use @kbd{M-w} | |
309 (@code{kill-ring-save}), which copies the region into the kill ring | |
310 without removing it from the buffer. This is approximately equivalent | |
311 to @kbd{C-w} followed by @kbd{C-x u}, except that @kbd{M-w} does not | |
312 alter the undo history and does not temporarily change the screen. | |
313 | |
314 @node Appending Kills | |
315 @subsection Appending Kills | |
316 | |
317 @cindex appending kills in the ring | |
318 @cindex television | |
319 Normally, each kill command pushes a new entry onto the kill ring. | |
320 However, two or more kill commands in a row combine their text into a | |
321 single entry, so that a single @kbd{C-y} yanks all the text as a unit, | |
322 just as it was before it was killed. | |
323 | |
324 Thus, if you want to yank text as a unit, you need not kill all of it | |
325 with one command; you can keep killing line after line, or word after | |
326 word, until you have killed it all, and you can still get it all back at | |
327 once. | |
328 | |
329 Commands that kill forward from point add onto the end of the previous | |
330 killed text. Commands that kill backward from point add text onto the | |
331 beginning. This way, any sequence of mixed forward and backward kill | |
332 commands puts all the killed text into one entry without rearrangement. | |
333 Numeric arguments do not break the sequence of appending kills. For | |
334 example, suppose the buffer contains this text: | |
335 | |
336 @example | |
337 This is a line @point{}of sample text. | |
338 @end example | |
339 | |
340 @noindent | |
341 with point shown by @point{}. If you type @kbd{M-d M-@key{DEL} M-d | |
342 M-@key{DEL}}, killing alternately forward and backward, you end up with | |
343 @samp{a line of sample} as one entry in the kill ring, and @samp{This | |
344 is@ @ text.} in the buffer. (Note the double space, which you can clean | |
345 up with @kbd{M-@key{SPC}} or @kbd{M-q}.) | |
346 | |
347 Another way to kill the same text is to move back two words with | |
348 @kbd{M-b M-b}, then kill all four words forward with @kbd{C-u M-d}. | |
349 This produces exactly the same results in the buffer and in the kill | |
350 ring. @kbd{M-f M-f C-u M-@key{DEL}} kills the same text, all going | |
351 backward; once again, the result is the same. The text in the kill ring | |
352 entry always has the same order that it had in the buffer before you | |
353 killed it. | |
354 | |
355 @kindex C-M-w | |
356 @findex append-next-kill | |
357 If a kill command is separated from the last kill command by other | |
358 commands (not just numeric arguments), it starts a new entry on the kill | |
359 ring. But you can force it to append by first typing the command | |
360 @kbd{C-M-w} (@code{append-next-kill}) right before it. The @kbd{C-M-w} | |
361 tells the following command, if it is a kill command, to append the text | |
362 it kills to the last killed text, instead of starting a new entry. With | |
363 @kbd{C-M-w}, you can kill several separated pieces of text and | |
364 accumulate them to be yanked back in one place.@refill | |
365 | |
366 A kill command following @kbd{M-w} does not append to the text that | |
367 @kbd{M-w} copied into the kill ring. | |
368 | |
369 @node Earlier Kills | |
370 @subsection Yanking Earlier Kills | |
371 | |
372 @cindex yanking previous kills | |
373 @kindex M-y | |
374 @findex yank-pop | |
375 To recover killed text that is no longer the most recent kill, use the | |
376 @kbd{M-y} command (@code{yank-pop}). It takes the text previously | |
377 yanked and replaces it with the text from an earlier kill. So, to | |
378 recover the text of the next-to-the-last kill, first use @kbd{C-y} to | |
379 yank the last kill, and then use @kbd{M-y} to replace it with the | |
380 previous kill. @kbd{M-y} is allowed only after a @kbd{C-y} or another | |
381 @kbd{M-y}. | |
382 | |
383 You can understand @kbd{M-y} in terms of a ``last yank'' pointer which | |
384 points at an entry in the kill ring. Each time you kill, the ``last | |
385 yank'' pointer moves to the newly made entry at the front of the ring. | |
386 @kbd{C-y} yanks the entry which the ``last yank'' pointer points to. | |
387 @kbd{M-y} moves the ``last yank'' pointer to a different entry, and the | |
388 text in the buffer changes to match. Enough @kbd{M-y} commands can move | |
389 the pointer to any entry in the ring, so you can get any entry into the | |
390 buffer. Eventually the pointer reaches the end of the ring; the next | |
391 @kbd{M-y} moves it to the first entry again. | |
392 | |
393 @kbd{M-y} moves the ``last yank'' pointer around the ring, but it does | |
394 not change the order of the entries in the ring, which always runs from | |
395 the most recent kill at the front to the oldest one still remembered. | |
396 | |
397 @kbd{M-y} can take a numeric argument, which tells it how many entries | |
398 to advance the ``last yank'' pointer by. A negative argument moves the | |
399 pointer toward the front of the ring; from the front of the ring, it | |
400 moves ``around'' to the last entry and continues forward from there. | |
401 | |
402 Once the text you are looking for is brought into the buffer, you can | |
403 stop doing @kbd{M-y} commands and it will stay there. It's just a copy | |
404 of the kill ring entry, so editing it in the buffer does not change | |
405 what's in the ring. As long as no new killing is done, the ``last | |
406 yank'' pointer remains at the same place in the kill ring, so repeating | |
407 @kbd{C-y} will yank another copy of the same previous kill. | |
408 | |
409 If you know how many @kbd{M-y} commands it would take to find the text | |
410 you want, you can yank that text in one step using @kbd{C-y} with a | |
411 numeric argument. @kbd{C-y} with an argument restores the text the | |
412 specified number of entries back in the kill ring. Thus, @kbd{C-u 2 | |
413 C-y} gets the next-to-the-last block of killed text. It is equivalent | |
414 to @kbd{C-y M-y}. @kbd{C-y} with a numeric argument starts counting | |
415 from the ``last yank'' pointer, and sets the ``last yank'' pointer to | |
416 the entry that it yanks. | |
417 | |
418 @vindex kill-ring-max | |
419 The length of the kill ring is controlled by the variable | |
420 @code{kill-ring-max}; no more than that many blocks of killed text are | |
421 saved. | |
422 | |
423 @vindex kill-ring | |
424 The actual contents of the kill ring are stored in a variable named | |
425 @code{kill-ring}; you can view the entire contents of the kill ring with | |
426 the command @kbd{C-h v kill-ring}. | |
427 | |
428 @node Accumulating Text, Rectangles, Yanking, Top | |
429 @section Accumulating Text | |
430 @findex append-to-buffer | |
431 @findex prepend-to-buffer | |
432 @findex copy-to-buffer | |
433 @findex append-to-file | |
434 | |
435 @cindex accumulating scattered text | |
436 Usually we copy or move text by killing it and yanking it, but there | |
437 are other methods convenient for copying one block of text in many | |
438 places, or for copying many scattered blocks of text into one place. To | |
439 copy one block to many places, store it in a register | |
440 (@pxref{Registers}). Here we describe the commands to accumulate | |
441 scattered pieces of text into a buffer or into a file. | |
442 | |
443 @table @kbd | |
444 @item M-x append-to-buffer | |
445 Append region to contents of specified buffer. | |
446 @item M-x prepend-to-buffer | |
447 Prepend region to contents of specified buffer. | |
448 @item M-x copy-to-buffer | |
449 Copy region into specified buffer, deleting that buffer's old contents. | |
450 @item M-x insert-buffer | |
451 Insert contents of specified buffer into current buffer at point. | |
452 @item M-x append-to-file | |
453 Append region to contents of specified file, at the end. | |
454 @end table | |
455 | |
456 To accumulate text into a buffer, use @kbd{M-x append-to-buffer}. | |
457 This reads a buffer name, then inserts a copy of the region into the | |
458 buffer specified. If you specify a nonexistent buffer, | |
459 @code{append-to-buffer} creates the buffer. The text is inserted | |
460 wherever point is in that buffer. If you have been using the buffer for | |
461 editing, the copied text goes into the middle of the text of the buffer, | |
462 wherever point happens to be in it. | |
463 | |
464 Point in that buffer is left at the end of the copied text, so | |
465 successive uses of @code{append-to-buffer} accumulate the text in the | |
466 specified buffer in the same order as they were copied. Strictly | |
467 speaking, @code{append-to-buffer} does not always append to the text | |
468 already in the buffer---it appends only if point in that buffer is at the end. | |
469 However, if @code{append-to-buffer} is the only command you use to alter | |
470 a buffer, then point is always at the end. | |
471 | |
472 @kbd{M-x prepend-to-buffer} is just like @code{append-to-buffer} | |
473 except that point in the other buffer is left before the copied text, so | |
474 successive prependings add text in reverse order. @kbd{M-x | |
475 copy-to-buffer} is similar except that any existing text in the other | |
476 buffer is deleted, so the buffer is left containing just the text newly | |
477 copied into it. | |
478 | |
479 To retrieve the accumulated text from another buffer, use the command | |
480 @kbd{M-x insert-buffer}; this too takes @var{buffername} as an argument. | |
481 It inserts a copy of the text in buffer @var{buffername} into the | |
482 selected buffer. You can alternatively select the other buffer for | |
483 editing, then optionally move text from it by killing. @xref{Buffers}, | |
484 for background information on buffers. | |
485 | |
486 Instead of accumulating text within Emacs, in a buffer, you can append | |
487 text directly into a file with @kbd{M-x append-to-file}, which takes | |
488 @var{filename} as an argument. It adds the text of the region to the end | |
489 of the specified file. The file is changed immediately on disk. | |
490 | |
491 You should use @code{append-to-file} only with files that are | |
492 @emph{not} being visited in Emacs. Using it on a file that you are | |
493 editing in Emacs would change the file behind Emacs's back, which | |
494 can lead to losing some of your editing. | |
495 | |
496 @node Rectangles, Registers, Accumulating Text, Top | |
497 @section Rectangles | |
498 @cindex rectangle | |
499 @cindex columns (and rectangles) | |
500 @cindex killing rectangular areas of text | |
501 | |
502 The rectangle commands operate on rectangular areas of the text: all | |
503 the characters between a certain pair of columns, in a certain range of | |
504 lines. Commands are provided to kill rectangles, yank killed rectangles, | |
505 clear them out, fill them with blanks or text, or delete them. Rectangle | |
506 commands are useful with text in multicolumn formats, and for changing | |
507 text into or out of such formats. | |
508 | |
509 When you must specify a rectangle for a command to work on, you do it | |
510 by putting the mark at one corner and point at the opposite corner. The | |
511 rectangle thus specified is called the @dfn{region-rectangle} because | |
512 you control it in about the same way the region is controlled. But | |
513 remember that a given combination of point and mark values can be | |
514 interpreted either as a region or as a rectangle, depending on the | |
515 command that uses them. | |
516 | |
517 If point and the mark are in the same column, the rectangle they | |
518 delimit is empty. If they are in the same line, the rectangle is one | |
519 line high. This asymmetry between lines and columns comes about | |
520 because point (and likewise the mark) is between two columns, but within | |
521 a line. | |
522 | |
523 @table @kbd | |
524 @item C-x r k | |
525 Kill the text of the region-rectangle, saving its contents as the | |
526 ``last killed rectangle'' (@code{kill-rectangle}). | |
527 @item C-x r d | |
528 Delete the text of the region-rectangle (@code{delete-rectangle}). | |
529 @item C-x r y | |
530 Yank the last killed rectangle with its upper left corner at point | |
531 (@code{yank-rectangle}). | |
532 @item C-x r o | |
533 Insert blank space to fill the space of the region-rectangle | |
534 (@code{open-rectangle}). This pushes the previous contents of the | |
535 region-rectangle rightward. | |
536 @item M-x clear-rectangle | |
537 Clear the region-rectangle by replacing its contents with spaces. | |
538 @item M-x delete-whitespace-rectangle | |
539 Delete whitespace in each of the lines on the specified rectangle, | |
540 starting from the left edge column of the rectangle. | |
27749 | 541 @item C-x r t @var{string} @key{RET} |
25829 | 542 Insert @var{string} on each line of the region-rectangle |
543 (@code{string-rectangle}). | |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
544 @item M-x replace-rectangle @key{RET} @var{string} @key{RET} |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
545 Replaces each line of the region-rectangle with @var{string} |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
546 (@code{string-rectangle}). |
25829 | 547 @end table |
548 | |
549 The rectangle operations fall into two classes: commands deleting and | |
550 inserting rectangles, and commands for blank rectangles. | |
551 | |
552 @kindex C-x r k | |
553 @kindex C-x r d | |
554 @findex kill-rectangle | |
555 @findex delete-rectangle | |
556 There are two ways to get rid of the text in a rectangle: you can | |
557 discard the text (delete it) or save it as the ``last killed'' | |
558 rectangle. The commands for these two ways are @kbd{C-x r d} | |
559 (@code{delete-rectangle}) and @kbd{C-x r k} (@code{kill-rectangle}). In | |
560 either case, the portion of each line that falls inside the rectangle's | |
561 boundaries is deleted, causing following text (if any) on the line to | |
562 move left into the gap. | |
563 | |
564 Note that ``killing'' a rectangle is not killing in the usual sense; the | |
565 rectangle is not stored in the kill ring, but in a special place that | |
566 can only record the most recent rectangle killed. This is because yanking | |
567 a rectangle is so different from yanking linear text that different yank | |
568 commands have to be used and yank-popping is hard to make sense of. | |
569 | |
570 @kindex C-x r y | |
571 @findex yank-rectangle | |
572 To yank the last killed rectangle, type @kbd{C-x r y} | |
573 (@code{yank-rectangle}). Yanking a rectangle is the opposite of killing | |
574 one. Point specifies where to put the rectangle's upper left corner. | |
575 The rectangle's first line is inserted there, the rectangle's second | |
576 line is inserted at a position one line vertically down, and so on. The | |
577 number of lines affected is determined by the height of the saved | |
578 rectangle. | |
579 | |
580 You can convert single-column lists into double-column lists using | |
581 rectangle killing and yanking; kill the second half of the list as a | |
582 rectangle and then yank it beside the first line of the list. | |
583 @xref{Two-Column}, for another way to edit multi-column text. | |
584 | |
585 You can also copy rectangles into and out of registers with @kbd{C-x r | |
586 r @var{r}} and @kbd{C-x r i @var{r}}. @xref{RegRect,,Rectangle | |
587 Registers}. | |
588 | |
589 @kindex C-x r o | |
590 @findex open-rectangle | |
591 @findex clear-rectangle | |
592 There are two commands you can use for making blank rectangles: | |
593 @kbd{M-x clear-rectangle} which blanks out existing text, and @kbd{C-x r | |
594 o} (@code{open-rectangle}) which inserts a blank rectangle. Clearing a | |
595 rectangle is equivalent to deleting it and then inserting a blank | |
596 rectangle of the same size. | |
597 | |
598 @findex delete-whitespace-rectangle | |
599 The command @kbd{M-x delete-whitespace-rectangle} deletes horizontal | |
600 whitespace starting from a particular column. This applies to each of | |
601 the lines in the rectangle, and the column is specified by the left | |
602 edge of the rectangle. The right edge of the rectangle does not make | |
603 any difference to this command. | |
604 | |
605 @kindex C-x r t | |
606 @findex string-rectangle | |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
607 The command @kbd{C-x r t} (@code{M-x string-rectangle}) inserts a |
33805 | 608 string on each line of the region-rectangle before the rectangle, |
609 shifting text right. | |
610 | |
30895 | 611 @findex replace-rectangle |
36162
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
612 The command @kbd{M-x replace-rectangle} is similar to @kbd{C-x r t}, |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
613 but replaces the original rectangle. The string's width need not be |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
614 the same as the width of the rectangle. If the string's width is |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
615 less, the text after the rectangle shifts left; if the string is wider |
f657bb5a6cf5
Rewrite kill-read-only-ok, Delete Selection mode, replace-rectangle.
Richard M. Stallman <rms@gnu.org>
parents:
35918
diff
changeset
|
616 than the rectangle, the text after the rectangle shifts right. |