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