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