text.texi 173 KB
Newer Older
Richard M. Stallman's avatar
Richard M. Stallman committed
1 2
@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
3 4
@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001,
@c   2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Richard M. Stallman's avatar
Richard M. Stallman committed
5 6
@c See the file elisp.texi for copying conditions.
@setfilename ../info/text
7
@node Text, Non-ASCII Characters, Markers, Top
Richard M. Stallman's avatar
Richard M. Stallman committed
8 9 10 11
@chapter Text
@cindex text

  This chapter describes the functions that deal with the text in a
12
buffer.  Most examine, insert, or delete text in the current buffer,
13 14 15
often operating at point or on text adjacent to point.  Many are
interactive.  All the functions that change the text provide for undoing
the changes (@pxref{Undo}).
Richard M. Stallman's avatar
Richard M. Stallman committed
16 17 18 19 20 21 22 23 24 25 26 27 28 29

  Many text-related functions operate on a region of text defined by two
buffer positions passed in arguments named @var{start} and @var{end}.
These arguments should be either markers (@pxref{Markers}) or numeric
character positions (@pxref{Positions}).  The order of these arguments
does not matter; it is all right for @var{start} to be the end of the
region and @var{end} the beginning.  For example, @code{(delete-region 1
10)} and @code{(delete-region 10 1)} are equivalent.  An
@code{args-out-of-range} error is signaled if either @var{start} or
@var{end} is outside the accessible portion of the buffer.  In an
interactive call, point and the mark are used for these arguments.

@cindex buffer contents
  Throughout this chapter, ``text'' refers to the characters in the
30 31 32
buffer, together with their properties (when relevant).  Keep in mind
that point is always between two characters, and the cursor appears on
the character after point.
Richard M. Stallman's avatar
Richard M. Stallman committed
33 34 35 36 37 38 39 40 41 42 43 44 45 46

@menu
* Near Point::       Examining text in the vicinity of point.
* Buffer Contents::  Examining text in a general fashion.
* Comparing Text::   Comparing substrings of buffers.
* Insertion::        Adding new text to a buffer.
* Commands for Insertion::  User-level commands to insert text.
* Deletion::         Removing text from a buffer.
* User-Level Deletion::     User-level commands to delete text.
* The Kill Ring::    Where removed text sometimes is saved for later use.
* Undo::             Undoing changes to the text of a buffer.
* Maintaining Undo:: How to enable and disable undo information.
			How to control how much information is kept.
* Filling::          Functions for explicit filling.
Karl Heuer's avatar
Karl Heuer committed
47
* Margins::          How to specify margins for filling commands.
Karl Heuer's avatar
Karl Heuer committed
48
* Adaptive Fill::    Adaptive Fill mode chooses a fill prefix from context.
Richard M. Stallman's avatar
Richard M. Stallman committed
49 50 51 52 53 54 55
* Auto Filling::     How auto-fill mode is implemented to break lines.
* Sorting::          Functions for sorting parts of the buffer.
* Columns::          Computing horizontal positions, and using them.
* Indentation::      Functions to insert or adjust indentation.
* Case Changes::     Case conversion of parts of the buffer.
* Text Properties::  Assigning Lisp property lists to text characters.
* Substitution::     Replacing a given character wherever it appears.
56
* Transposition::    Swapping two portions of a buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
57 58
* Registers::        How registers are implemented.  Accessing the text or
                       position stored in a register.
59
* Base 64::          Conversion to or from base 64 encoding.
60
* MD5 Checksum::     Compute the MD5 ``message digest''/``checksum''.
61
* Atomic Changes::   Installing several buffer changes ``atomically''.
Richard M. Stallman's avatar
Richard M. Stallman committed
62 63 64 65 66 67 68 69 70 71
* Change Hooks::     Supplying functions to be run when text is changed.
@end menu

@node Near Point
@section Examining Text Near Point

  Many functions are provided to look at the characters around point.
Several simple functions are described here.  See also @code{looking-at}
in @ref{Regexp Search}.

72 73 74
In the following four functions, ``beginning'' or ``end'' of buffer
refers to the beginning or end of the accessible portion.

75
@defun char-after &optional position
Richard M. Stallman's avatar
Richard M. Stallman committed
76 77 78
This function returns the character in the current buffer at (i.e.,
immediately after) position @var{position}.  If @var{position} is out of
range for this purpose, either before the beginning of the buffer, or at
79 80
or beyond the end, then the value is @code{nil}.  The default for
@var{position} is point.
Richard M. Stallman's avatar
Richard M. Stallman committed
81 82 83 84 85 86 87 88 89 90 91 92

In the following example, assume that the first character in the
buffer is @samp{@@}:

@example
@group
(char-to-string (char-after 1))
     @result{} "@@"
@end group
@end example
@end defun

93
@defun char-before &optional position
94 95
This function returns the character in the current buffer immediately
before position @var{position}.  If @var{position} is out of range for
96
this purpose, either at or before the beginning of the buffer, or beyond
97 98
the end, then the value is @code{nil}.  The default for
@var{position} is point.
99 100
@end defun

Richard M. Stallman's avatar
Richard M. Stallman committed
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
@defun following-char
This function returns the character following point in the current
buffer.  This is similar to @code{(char-after (point))}.  However, if
point is at the end of the buffer, then @code{following-char} returns 0.

Remember that point is always between characters, and the terminal
cursor normally appears over the character following point.  Therefore,
the character returned by @code{following-char} is the character the
cursor is over.

In this example, point is between the @samp{a} and the @samp{c}.

@example
@group
---------- Buffer: foo ----------
Gentlemen may cry ``Pea@point{}ce! Peace!,''
but there is no peace.
---------- Buffer: foo ----------
@end group

@group
(char-to-string (preceding-char))
     @result{} "a"
(char-to-string (following-char))
     @result{} "c"
@end group
@end example
@end defun

@defun preceding-char
This function returns the character preceding point in the current
buffer.  See above, under @code{following-char}, for an example.  If
point is at the beginning of the buffer, @code{preceding-char} returns
0.
@end defun

@defun bobp
This function returns @code{t} if point is at the beginning of the
buffer.  If narrowing is in effect, this means the beginning of the
accessible portion of the text.  See also @code{point-min} in
@ref{Point}.
@end defun

@defun eobp
This function returns @code{t} if point is at the end of the buffer.
If narrowing is in effect, this means the end of accessible portion of
the text.  See also @code{point-max} in @xref{Point}.
@end defun

@defun bolp
This function returns @code{t} if point is at the beginning of a line.
152
@xref{Text Lines}.  The beginning of the buffer (or of its accessible
153
portion) always counts as the beginning of a line.
Richard M. Stallman's avatar
Richard M. Stallman committed
154 155 156 157 158 159 160 161 162 163 164
@end defun

@defun eolp
This function returns @code{t} if point is at the end of a line.  The
end of the buffer (or of its accessible portion) is always considered
the end of a line.
@end defun

@node Buffer Contents
@section Examining Buffer Contents

Richard M. Stallman's avatar
Richard M. Stallman committed
165
  This section describes functions that allow a Lisp program to
Richard M. Stallman's avatar
Richard M. Stallman committed
166 167 168 169 170 171 172 173 174 175 176 177 178
convert any portion of the text in the buffer into a string.

@defun buffer-substring start end
This function returns a string containing a copy of the text of the
region defined by positions @var{start} and @var{end} in the current
buffer.  If the arguments are not positions in the accessible portion of
the buffer, @code{buffer-substring} signals an @code{args-out-of-range}
error.

It is not necessary for @var{start} to be less than @var{end}; the
arguments can be given in either order.  But most often the smaller
argument is written first.

Karl Heuer's avatar
Karl Heuer committed
179 180 181 182 183
If the text being copied has any text properties, these are copied into
the string along with the characters they belong to.  @xref{Text
Properties}.  However, overlays (@pxref{Overlays}) in the buffer and
their properties are ignored, not copied.

Richard M. Stallman's avatar
Richard M. Stallman committed
184 185 186 187 188 189 190 191 192 193
@example
@group
---------- Buffer: foo ----------
This is the contents of buffer foo

---------- Buffer: foo ----------
@end group

@group
(buffer-substring 1 10)
194
     @result{} "This is t"
Richard M. Stallman's avatar
Richard M. Stallman committed
195 196 197
@end group
@group
(buffer-substring (point-max) 10)
198
     @result{} "he contents of buffer foo\n"
Richard M. Stallman's avatar
Richard M. Stallman committed
199 200 201 202
@end group
@end example
@end defun

203
@defun buffer-substring-no-properties start end
Karl Heuer's avatar
Karl Heuer committed
204 205 206 207
This is like @code{buffer-substring}, except that it does not copy text
properties, just the characters themselves.  @xref{Text Properties}.
@end defun

208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
@defun filter-buffer-substring start end &optional delete
This function passes the buffer text between @var{start} and @var{end}
through the filter functions specified by the variable
@code{buffer-substring-filters}, and returns the value from the last
filter function.  If @code{buffer-substring-filters} is @code{nil},
the value is the unaltered text from the buffer, what
@code{buffer-substring} would return.

If @var{delete} is non-@code{nil}, this function deletes the text
between @var{start} and @var{end} after copying it, like
@code{delete-and-extract-region}.

Lisp code should use this function instead of @code{buffer-substring}
or @code{delete-and-extract-region} when copying into user-accessible
data structures such as the kill-ring, X clipboard, and registers.
Major and minor modes can add functions to
@code{buffer-substring-filters} to alter such text as it is copied out
of the buffer.
@end defun

@defvar buffer-substring-filters
This variable should be a list of functions that accept a single
argument, a string, and return a string.
@code{filter-buffer-substring} passes the buffer substring to the
first function in this list, and the return value of each function is
passed to the next function.  The return value of the last function is
used as the return value of @code{filter-buffer-substring}.

As a special convention, point is set to the start of the buffer text
being operated on (i.e., the @var{start} argument for
@code{filter-buffer-substring}) before these functions are called.

If this variable is @code{nil}, no filtering is performed.
@end defvar

Richard M. Stallman's avatar
Richard M. Stallman committed
243
@defun buffer-string
244
This function returns the contents of the entire accessible portion of
245 246 247 248 249
the current buffer as a string.  It is equivalent to

@example
(buffer-substring (point-min) (point-max))
@end example
Richard M. Stallman's avatar
Richard M. Stallman committed
250 251 252 253 254 255 256 257 258

@example
@group
---------- Buffer: foo ----------
This is the contents of buffer foo

---------- Buffer: foo ----------

(buffer-string)
259
     @result{} "This is the contents of buffer foo\n"
Richard M. Stallman's avatar
Richard M. Stallman committed
260 261 262 263
@end group
@end example
@end defun

264 265 266 267 268
@tindex current-word
@defun current-word &optional strict really-word
This function returns the symbol (or word) at or near point, as a string.
The return value includes no text properties.

269 270 271
If the optional argument @var{really-word} is non-@code{nil}, it finds a
word; otherwise, it finds a symbol (which includes both word
characters and symbol constituent characters).
272 273 274 275 276 277 278

If the optional argument @var{strict} is non-@code{nil}, then point
must be in or next to the symbol or word---if no symbol or word is
there, the function returns @code{nil}.  Otherwise, a nearby symbol or
word on the same line is acceptable.
@end defun

279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
@defun thing-at-point thing
Return the @var{thing} around or next to point, as a string.

The argument @var{thing} is a symbol which specifies a kind of syntactic
entity.  Possibilities include @code{symbol}, @code{list}, @code{sexp},
@code{defun}, @code{filename}, @code{url}, @code{word}, @code{sentence},
@code{whitespace}, @code{line}, @code{page}, and others.

@example
---------- Buffer: foo ----------
Gentlemen may cry ``Pea@point{}ce! Peace!,''
but there is no peace.
---------- Buffer: foo ----------

(thing-at-point 'word)
     @result{} "Peace"
(thing-at-point 'line)
     @result{} "Gentlemen may cry ``Peace! Peace!,''\n"
(thing-at-point 'whitespace)
     @result{} nil
@end example
@end defun

Richard M. Stallman's avatar
Richard M. Stallman committed
302 303 304 305 306 307 308 309 310 311
@node Comparing Text
@section Comparing Text
@cindex comparing buffer text

  This function lets you compare portions of the text in a buffer, without
copying them into strings first.

@defun compare-buffer-substrings buffer1 start1 end1 buffer2 start2 end2
This function lets you compare two substrings of the same buffer or two
different buffers.  The first three arguments specify one substring,
312 313 314 315
giving a buffer (or a buffer name) and two positions within the
buffer.  The last three arguments specify the other substring in the
same way.  You can use @code{nil} for @var{buffer1}, @var{buffer2}, or
both to stand for the current buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
316 317 318 319 320 321 322

The value is negative if the first substring is less, positive if the
first is greater, and zero if they are equal.  The absolute value of
the result is one plus the index of the first differing characters
within the substrings.

This function ignores case when comparing characters
Karl Heuer's avatar
Karl Heuer committed
323 324
if @code{case-fold-search} is non-@code{nil}.  It always ignores
text properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
325 326 327 328 329 330 331

Suppose the current buffer contains the text @samp{foobarbar
haha!rara!}; then in this example the two substrings are @samp{rbar }
and @samp{rara!}.  The value is 2 because the first substring is greater
at the second character.

@example
332
(compare-buffer-substrings nil 6 11 nil 16 21)
Richard M. Stallman's avatar
Richard M. Stallman committed
333 334 335 336 337
     @result{} 2
@end example
@end defun

@node Insertion
Karl Heuer's avatar
Karl Heuer committed
338
@section Inserting Text
Richard M. Stallman's avatar
Richard M. Stallman committed
339 340 341
@cindex insertion of text
@cindex text insertion

342 343
@cindex insertion before point
@cindex before point, insertion
Richard M. Stallman's avatar
Richard M. Stallman committed
344 345
  @dfn{Insertion} means adding new text to a buffer.  The inserted text
goes at point---between the character before point and the character
346 347 348
after point.  Some insertion functions leave point before the inserted
text, while other functions leave it after.  We call the former
insertion @dfn{after point} and the latter insertion @dfn{before point}.
Richard M. Stallman's avatar
Richard M. Stallman committed
349 350 351 352

  Insertion relocates markers that point at positions after the
insertion point, so that they stay with the surrounding text
(@pxref{Markers}).  When a marker points at the place of insertion,
353 354 355 356 357
insertion may or may not relocate the marker, depending on the marker's
insertion type (@pxref{Marker Insertion Types}).  Certain special
functions such as @code{insert-before-markers} relocate all such markers
to point after the inserted text, regardless of the markers' insertion
type.
Richard M. Stallman's avatar
Richard M. Stallman committed
358 359

  Insertion functions signal an error if the current buffer is
360
read-only or if they insert within read-only text.
Richard M. Stallman's avatar
Richard M. Stallman committed
361

Karl Heuer's avatar
Karl Heuer committed
362 363 364 365 366 367
  These functions copy text characters from strings and buffers along
with their properties.  The inserted characters have exactly the same
properties as the characters they were copied from.  By contrast,
characters specified as separate arguments, not part of a string or
buffer, inherit their text properties from the neighboring text.

368 369 370 371 372 373 374
  The insertion functions convert text from unibyte to multibyte in
order to insert in a multibyte buffer, and vice versa---if the text
comes from a string or from a buffer.  However, they do not convert
unibyte character codes 128 through 255 to multibyte characters, not
even if the current buffer is a multibyte buffer.  @xref{Converting
Representations}.

Richard M. Stallman's avatar
Richard M. Stallman committed
375 376
@defun insert &rest args
This function inserts the strings and/or characters @var{args} into the
377 378 379
current buffer, at point, moving point forward.  In other words, it
inserts the text before point.  An error is signaled unless all
@var{args} are either strings or characters.  The value is @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
380 381 382 383 384 385 386 387 388 389
@end defun

@defun insert-before-markers &rest args
This function inserts the strings and/or characters @var{args} into the
current buffer, at point, moving point forward.  An error is signaled
unless all @var{args} are either strings or characters.  The value is
@code{nil}.

This function is unlike the other insertion functions in that it
relocates markers initially pointing at the insertion point, to point
Richard M. Stallman's avatar
Richard M. Stallman committed
390 391 392 393
after the inserted text.  If an overlay begins at the insertion point,
the inserted text falls outside the overlay; if a nonempty overlay
ends at the insertion point, the inserted text falls inside that
overlay.
Richard M. Stallman's avatar
Richard M. Stallman committed
394 395
@end defun

396
@defun insert-char character count &optional inherit
Richard M. Stallman's avatar
Richard M. Stallman committed
397
This function inserts @var{count} instances of @var{character} into the
398 399
current buffer before point.  The argument @var{count} should be an
integer, and @var{character} must be a character.  The value is @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
400

401 402 403 404
This function does not convert unibyte character codes 128 through 255
to multibyte characters, not even if the current buffer is a multibyte
buffer.  @xref{Converting Representations}.

Richard M. Stallman's avatar
Richard M. Stallman committed
405 406 407
If @var{inherit} is non-@code{nil}, then the inserted characters inherit
sticky text properties from the two characters before and after the
insertion point.  @xref{Sticky Properties}.
Richard M. Stallman's avatar
Richard M. Stallman committed
408 409 410 411 412
@end defun

@defun insert-buffer-substring from-buffer-or-name &optional start end
This function inserts a portion of buffer @var{from-buffer-or-name}
(which must already exist) into the current buffer before point.  The
413
text inserted is the region between @var{start} and @var{end}.  (These
Richard M. Stallman's avatar
Richard M. Stallman committed
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
arguments default to the beginning and end of the accessible portion of
that buffer.)  This function returns @code{nil}.

In this example, the form is executed with buffer @samp{bar} as the
current buffer.  We assume that buffer @samp{bar} is initially empty.

@example
@group
---------- Buffer: foo ----------
We hold these truths to be self-evident, that all
---------- Buffer: foo ----------
@end group

@group
(insert-buffer-substring "foo" 1 20)
     @result{} nil

---------- Buffer: bar ----------
432
We hold these truth@point{}
Richard M. Stallman's avatar
Richard M. Stallman committed
433 434 435
---------- Buffer: bar ----------
@end group
@end example
436 437 438 439 440
@end defun

@defun insert-buffer-substring-no-properties from-buffer-or-name &optional start end
This is like @code{insert-buffer-substring} except that it does not
copy any text properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
441 442 443
@end defun

  @xref{Sticky Properties}, for other insertion functions that inherit
444
text properties from the nearby text in addition to inserting it.
Richard M. Stallman's avatar
Richard M. Stallman committed
445 446
Whitespace inserted by indentation functions also inherits text
properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
447 448 449 450 451 452 453 454 455

@node Commands for Insertion
@section User-Level Insertion Commands

  This section describes higher-level commands for inserting text,
commands intended primarily for the user but useful also in Lisp
programs.

@deffn Command insert-buffer from-buffer-or-name
456 457 458 459
This command inserts the entire accessible contents of
@var{from-buffer-or-name} (which must exist) into the current buffer
after point.  It leaves the mark after the inserted text.  The value
is @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
460 461 462 463 464
@end deffn

@deffn Command self-insert-command count
@cindex character insertion
@cindex self-insertion
465 466 467 468 469
This command inserts the last character typed; it does so @var{count}
times, before point, and returns @code{nil}.  Most printing characters
are bound to this command.  In routine use, @code{self-insert-command}
is the most frequently called function in Emacs, but programs rarely use
it except to install it on a keymap.
Richard M. Stallman's avatar
Richard M. Stallman committed
470 471 472

In an interactive call, @var{count} is the numeric prefix argument.

Karl Heuer's avatar
Karl Heuer committed
473
This command calls @code{auto-fill-function} whenever that is
Dave Love's avatar
Dave Love committed
474 475
non-@code{nil} and the character inserted is in the table
@code{auto-fill-chars} (@pxref{Auto Filling}).
Richard M. Stallman's avatar
Richard M. Stallman committed
476 477

@c Cross refs reworded to prevent overfull hbox.  --rjc 15mar92
Karl Heuer's avatar
Karl Heuer committed
478
This command performs abbrev expansion if Abbrev mode is enabled and
Richard M. Stallman's avatar
Richard M. Stallman committed
479 480 481
the inserted character does not have word-constituent
syntax. (@xref{Abbrevs}, and @ref{Syntax Class Table}.)

Karl Heuer's avatar
Karl Heuer committed
482 483
This is also responsible for calling @code{blink-paren-function} when
the inserted character has close parenthesis syntax (@pxref{Blinking}).
Phillip Rulon's avatar
Phillip Rulon committed
484 485 486 487

Do not try substituting your own definition of
@code{self-insert-command} for the standard one.  The editor command
loop handles this function specially.
Richard M. Stallman's avatar
Richard M. Stallman committed
488 489
@end deffn

490
@deffn Command newline &optional number-of-newlines
Richard M. Stallman's avatar
Richard M. Stallman committed
491 492 493 494 495
This command inserts newlines into the current buffer before point.
If @var{number-of-newlines} is supplied, that many newline characters
are inserted.

@cindex newline and Auto Fill mode
496 497 498 499 500 501 502
This function calls @code{auto-fill-function} if the current column
number is greater than the value of @code{fill-column} and
@var{number-of-newlines} is @code{nil}.  Typically what
@code{auto-fill-function} does is insert a newline; thus, the overall
result in this case is to insert two newlines at different places: one
at point, and another earlier in the line.  @code{newline} does not
auto-fill if @var{number-of-newlines} is non-@code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
503

Karl Heuer's avatar
Karl Heuer committed
504 505 506
This command indents to the left margin if that is not zero.
@xref{Margins}.

Richard M. Stallman's avatar
Richard M. Stallman committed
507 508 509 510 511 512
The value returned is @code{nil}.  In an interactive call, @var{count}
is the numeric prefix argument.
@end deffn

@deffn Command split-line
This command splits the current line, moving the portion of the line
513
after point down vertically so that it is on the next line directly
Richard M. Stallman's avatar
Richard M. Stallman committed
514 515 516 517 518 519 520 521
below where it was before.  Whitespace is inserted as needed at the
beginning of the lower line, using the @code{indent-to} function.
@code{split-line} returns the position of point.

Programs hardly ever use this function.
@end deffn

@defvar overwrite-mode
522 523 524 525 526 527
This variable controls whether overwrite mode is in effect.  The value
should be @code{overwrite-mode-textual}, @code{overwrite-mode-binary},
or @code{nil}.  @code{overwrite-mode-textual} specifies textual
overwrite mode (treats newlines and tabs specially), and
@code{overwrite-mode-binary} specifies binary overwrite mode (treats
newlines and tabs like any other characters).
Richard M. Stallman's avatar
Richard M. Stallman committed
528 529 530
@end defvar

@node Deletion
Karl Heuer's avatar
Karl Heuer committed
531
@section Deleting Text
Richard M. Stallman's avatar
Richard M. Stallman committed
532 533 534 535 536

@cindex deletion vs killing
  Deletion means removing part of the text in a buffer, without saving
it in the kill ring (@pxref{The Kill Ring}).  Deleted text can't be
yanked, but can be reinserted using the undo mechanism (@pxref{Undo}).
537 538
Some deletion functions do save text in the kill ring in some special
cases.
Richard M. Stallman's avatar
Richard M. Stallman committed
539

540
  All of the deletion functions operate on the current buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
541

542
@deffn Command erase-buffer
543 544
This function deletes the entire text of the current buffer
(@emph{not} just the accessible portion), leaving it
Richard M. Stallman's avatar
Richard M. Stallman committed
545
empty.  If the buffer is read-only, it signals a @code{buffer-read-only}
546 547 548
error; if some of the text in it is read-only, it signals a
@code{text-read-only} error.  Otherwise, it deletes the text without
asking for any confirmation.  It returns @code{nil}.
549

Richard M. Stallman's avatar
Richard M. Stallman committed
550 551 552 553 554
Normally, deleting a large amount of text from a buffer inhibits further
auto-saving of that buffer ``because it has shrunk''.  However,
@code{erase-buffer} does not do this, the idea being that the future
text is not really related to the former text, and its size should not
be compared with that of the former text.
555
@end deffn
Richard M. Stallman's avatar
Richard M. Stallman committed
556 557

@deffn Command delete-region start end
558 559 560
This command deletes the text between positions @var{start} and
@var{end} in the current buffer, and returns @code{nil}.  If point was
inside the deleted region, its value afterward is @var{start}.
561
Otherwise, point relocates with the surrounding text, as markers do.
Richard M. Stallman's avatar
Richard M. Stallman committed
562 563
@end deffn

564 565 566 567 568 569 570 571 572 573 574
@defun delete-and-extract-region start end
@tindex delete-and-extract-region
This function deletes the text between positions @var{start} and
@var{end} in the current buffer, and returns a string containing the
text just deleted.

If point was inside the deleted region, its value afterward is
@var{start}.  Otherwise, point relocates with the surrounding text, as
markers do.
@end defun

Richard M. Stallman's avatar
Richard M. Stallman committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
@deffn Command delete-char count &optional killp
This command deletes @var{count} characters directly after point, or
before point if @var{count} is negative.  If @var{killp} is
non-@code{nil}, then it saves the deleted characters in the kill ring.

In an interactive call, @var{count} is the numeric prefix argument, and
@var{killp} is the unprocessed prefix argument.  Therefore, if a prefix
argument is supplied, the text is saved in the kill ring.  If no prefix
argument is supplied, then one character is deleted, but not saved in
the kill ring.

The value returned is always @code{nil}.
@end deffn

@deffn Command delete-backward-char count &optional killp
@cindex delete previous char
This command deletes @var{count} characters directly before point, or
after point if @var{count} is negative.  If @var{killp} is
non-@code{nil}, then it saves the deleted characters in the kill ring.

In an interactive call, @var{count} is the numeric prefix argument, and
@var{killp} is the unprocessed prefix argument.  Therefore, if a prefix
argument is supplied, the text is saved in the kill ring.  If no prefix
argument is supplied, then one character is deleted, but not saved in
the kill ring.

The value returned is always @code{nil}.
@end deffn

@deffn Command backward-delete-char-untabify count &optional killp
@cindex tab deletion
This command deletes @var{count} characters backward, changing tabs
into spaces.  When the next character to be deleted is a tab, it is
first replaced with the proper number of spaces to preserve alignment
and then one of those spaces is deleted instead of the tab.  If
@var{killp} is non-@code{nil}, then the command saves the deleted
characters in the kill ring.

Conversion of tabs to spaces happens only if @var{count} is positive.
If it is negative, exactly @minus{}@var{count} characters after point
are deleted.

In an interactive call, @var{count} is the numeric prefix argument, and
@var{killp} is the unprocessed prefix argument.  Therefore, if a prefix
argument is supplied, the text is saved in the kill ring.  If no prefix
argument is supplied, then one character is deleted, but not saved in
the kill ring.

The value returned is always @code{nil}.
@end deffn

626 627 628 629
@defopt backward-delete-char-untabify-method
This option specifies how @code{backward-delete-char-untabify} should
deal with whitespace.  Possible values include @code{untabify}, the
default, meaning convert a tab to many spaces and delete one;
630 631 632
@code{hungry}, meaning delete all tabs and spaces before point with
one command; @code{all} meaning delete all tabs, spaces and newlines
before point, and @code{nil}, meaning do nothing special for
633 634 635
whitespace characters.
@end defopt

Richard M. Stallman's avatar
Richard M. Stallman committed
636 637 638 639 640 641 642
@node User-Level Deletion
@section User-Level Deletion Commands

  This section describes higher-level commands for deleting text,
commands intended primarily for the user but useful also in Lisp
programs.

643
@deffn Command delete-horizontal-space &optional backward-only
Richard M. Stallman's avatar
Richard M. Stallman committed
644 645 646 647
@cindex deleting whitespace
This function deletes all spaces and tabs around point.  It returns
@code{nil}.

648 649 650
If @var{backward-only} is non-@code{nil}, the function deletes
spaces and tabs before point, but not after point.

Richard M. Stallman's avatar
Richard M. Stallman committed
651 652
In the following examples, we call @code{delete-horizontal-space} four
times, once on each line, with point between the second and third
653
characters on the line each time.
Richard M. Stallman's avatar
Richard M. Stallman committed
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678

@example
@group
---------- Buffer: foo ----------
I @point{}thought
I @point{}     thought
We@point{} thought
Yo@point{}u thought
---------- Buffer: foo ----------
@end group

@group
(delete-horizontal-space)   ; @r{Four times.}
     @result{} nil

---------- Buffer: foo ----------
Ithought
Ithought
Wethought
You thought
---------- Buffer: foo ----------
@end group
@end example
@end deffn

679
@deffn Command delete-indentation &optional join-following-p
Richard M. Stallman's avatar
Richard M. Stallman committed
680 681 682 683
This function joins the line point is on to the previous line, deleting
any whitespace at the join and in some cases replacing it with one
space.  If @var{join-following-p} is non-@code{nil},
@code{delete-indentation} joins this line to the following line
684
instead.  The function returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
685 686 687

If there is a fill prefix, and the second of the lines being joined
starts with the prefix, then @code{delete-indentation} deletes the
Karl Heuer's avatar
Karl Heuer committed
688
fill prefix before joining the lines.  @xref{Margins}.
Richard M. Stallman's avatar
Richard M. Stallman committed
689 690 691 692 693 694

In the example below, point is located on the line starting
@samp{events}, and it makes no difference if there are trailing spaces
in the preceding line.

@smallexample
695
@group
Richard M. Stallman's avatar
Richard M. Stallman committed
696 697 698 699
---------- Buffer: foo ----------
When in the course of human
@point{}    events, it becomes necessary
---------- Buffer: foo ----------
700
@end group
Richard M. Stallman's avatar
Richard M. Stallman committed
701 702 703 704

(delete-indentation)
     @result{} nil

705
@group
Richard M. Stallman's avatar
Richard M. Stallman committed
706 707 708
---------- Buffer: foo ----------
When in the course of human@point{} events, it becomes necessary
---------- Buffer: foo ----------
709
@end group
Richard M. Stallman's avatar
Richard M. Stallman committed
710 711 712 713 714 715
@end smallexample

After the lines are joined, the function @code{fixup-whitespace} is
responsible for deciding whether to leave a space at the junction.
@end deffn

716 717 718 719
@deffn Command fixup-whitespace
This function replaces all the horizontal whitespace surrounding point
with either one space or no space, according to the context.  It
returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
720 721 722 723 724 725 726 727

At the beginning or end of a line, the appropriate amount of space is
none.  Before a character with close parenthesis syntax, or after a
character with open parenthesis or expression-prefix syntax, no space is
also appropriate.  Otherwise, one space is appropriate.  @xref{Syntax
Class Table}.

In the example below, @code{fixup-whitespace} is called the first time
728 729
with point before the word @samp{spaces} in the first line.  For the
second invocation, point is directly after the @samp{(}.
Richard M. Stallman's avatar
Richard M. Stallman committed
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752

@smallexample
@group
---------- Buffer: foo ----------
This has too many     @point{}spaces
This has too many spaces at the start of (@point{}   this list)
---------- Buffer: foo ----------
@end group

@group
(fixup-whitespace)
     @result{} nil
(fixup-whitespace)
     @result{} nil
@end group

@group
---------- Buffer: foo ----------
This has too many spaces
This has too many spaces at the start of (this list)
---------- Buffer: foo ----------
@end group
@end smallexample
753
@end deffn
Richard M. Stallman's avatar
Richard M. Stallman committed
754

755
@deffn Command just-one-space &optional n
Richard M. Stallman's avatar
Richard M. Stallman committed
756 757
@comment !!SourceFile simple.el
This command replaces any spaces and tabs around point with a single
758 759
space, or @var{n} spaces if @var{n} is specified.  It returns
@code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
760 761 762 763 764 765 766
@end deffn

@deffn Command delete-blank-lines
This function deletes blank lines surrounding point.  If point is on a
blank line with one or more blank lines before or after it, then all but
one of them are deleted.  If point is on an isolated blank line, then it
is deleted.  If point is on a nonblank line, the command deletes all
767
blank lines immediately following it.
Richard M. Stallman's avatar
Richard M. Stallman committed
768 769 770 771 772 773 774 775 776 777

A blank line is defined as a line containing only tabs and spaces.

@code{delete-blank-lines} returns @code{nil}.
@end deffn

@node The Kill Ring
@section The Kill Ring
@cindex kill ring

778
  @dfn{Kill functions} delete text like the deletion functions, but save
Richard M. Stallman's avatar
Richard M. Stallman committed
779 780 781 782 783 784 785 786 787
it so that the user can reinsert it by @dfn{yanking}.  Most of these
functions have @samp{kill-} in their name.  By contrast, the functions
whose names start with @samp{delete-} normally do not save text for
yanking (though they can still be undone); these are ``deletion''
functions.

  Most of the kill commands are primarily for interactive use, and are
not described here.  What we do describe are the functions provided for
use in writing such commands.  You can use these functions to write
788
commands for killing text.  When you need to delete text for internal
Richard M. Stallman's avatar
Richard M. Stallman committed
789 790 791 792 793
purposes within a Lisp function, you should normally use deletion
functions, so as not to disturb the kill ring contents.
@xref{Deletion}.

  Killed text is saved for later yanking in the @dfn{kill ring}.  This
794 795 796 797 798 799
is a list that holds a number of recent kills, not just the last text
kill.  We call this a ``ring'' because yanking treats it as having
elements in a cyclic order.  The list is kept in the variable
@code{kill-ring}, and can be operated on with the usual functions for
lists; there are also specialized functions, described in this section,
that treat it as a ring.
Richard M. Stallman's avatar
Richard M. Stallman committed
800 801

  Some people think this use of the word ``kill'' is unfortunate, since
802
it refers to operations that specifically @emph{do not} destroy the
Richard M. Stallman's avatar
Richard M. Stallman committed
803 804 805 806 807 808 809 810 811 812
entities ``killed''.  This is in sharp contrast to ordinary life, in
which death is permanent and ``killed'' entities do not come back to
life.  Therefore, other metaphors have been proposed.  For example, the
term ``cut ring'' makes sense to people who, in pre-computer days, used
scissors and paste to cut up and rearrange manuscripts.  However, it
would be difficult to change the terminology now.

@menu
* Kill Ring Concepts::     What text looks like in the kill ring.
* Kill Functions::         Functions that kill text.
813
* Yanking::                How yanking is done.
Richard M. Stallman's avatar
Richard M. Stallman committed
814
* Yank Commands::          Commands that access the kill ring.
815
* Low-Level Kill Ring::	   Functions and variables for kill ring access.
816
* Internals of Kill Ring:: Variables that hold kill ring data.
Richard M. Stallman's avatar
Richard M. Stallman committed
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
@end menu

@node Kill Ring Concepts
@comment  node-name,  next,  previous,  up
@subsection Kill Ring Concepts

  The kill ring records killed text as strings in a list, most recent
first.  A short kill ring, for example, might look like this:

@example
("some text" "a different piece of text" "even older text")
@end example

@noindent
When the list reaches @code{kill-ring-max} entries in length, adding a
new entry automatically deletes the last entry.

  When kill commands are interwoven with other commands, each kill
command makes a new entry in the kill ring.  Multiple kill commands in
836
succession build up a single kill ring entry, which would be yanked as a
837 838
unit; the second and subsequent consecutive kill commands add text to
the entry made by the first one.
Richard M. Stallman's avatar
Richard M. Stallman committed
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853

  For yanking, one entry in the kill ring is designated the ``front'' of
the ring.  Some yank commands ``rotate'' the ring by designating a
different element as the ``front.''  But this virtual rotation doesn't
change the list itself---the most recent entry always comes first in the
list.

@node Kill Functions
@comment  node-name,  next,  previous,  up
@subsection Functions for Killing

  @code{kill-region} is the usual subroutine for killing text.  Any
command that calls this function is a ``kill command'' (and should
probably have @samp{kill} in its name).  @code{kill-region} puts the
newly killed text in a new element at the beginning of the kill ring or
854 855
adds it to the most recent element.  It determines automatically (using
@code{last-command}) whether the previous command was a kill command,
856
and if so appends the killed text to the most recent entry.
Richard M. Stallman's avatar
Richard M. Stallman committed
857

858
@deffn Command kill-region start end &optional yank-handler
Richard M. Stallman's avatar
Richard M. Stallman committed
859
This function kills the text in the region defined by @var{start} and
Karl Heuer's avatar
Karl Heuer committed
860 861
@var{end}.  The text is deleted but saved in the kill ring, along with
its text properties.  The value is always @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
862 863 864 865 866

In an interactive call, @var{start} and @var{end} are point and
the mark.

@c Emacs 19 feature
867 868 869 870
If the buffer or text is read-only, @code{kill-region} modifies the kill
ring just the same, then signals an error without modifying the buffer.
This is convenient because it lets the user use a series of kill
commands to copy text from a read-only buffer into the kill ring.
871 872

If @var{yank-handler} is non-@code{nil}, this puts that value onto
873 874 875 876
the string of killed text, as a @code{yank-handler} text property.
@xref{Yanking}.  Note that if @var{yank-handler} is @code{nil}, any
@code{yank-handler} properties present on the killed text are copied
onto the kill ring, like other text properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
877 878
@end deffn

879
@defopt kill-read-only-ok
880 881 882
If this option is non-@code{nil}, @code{kill-region} does not signal an
error if the buffer or text is read-only.  Instead, it simply returns,
updating the kill ring but not changing the buffer.
883 884
@end defopt

Richard M. Stallman's avatar
Richard M. Stallman committed
885 886
@deffn Command copy-region-as-kill start end
This command saves the region defined by @var{start} and @var{end} on
Karl Heuer's avatar
Karl Heuer committed
887
the kill ring (including text properties), but does not delete the text
888
from the buffer.  It returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
889

Karl Heuer's avatar
Karl Heuer committed
890 891 892
The command does not set @code{this-command} to @code{kill-region}, so a
subsequent kill command does not append to the same kill ring entry.

Richard M. Stallman's avatar
Richard M. Stallman committed
893
Don't call @code{copy-region-as-kill} in Lisp programs unless you aim to
894 895 896
support Emacs 18.  For newer Emacs versions, it is better to use
@code{kill-new} or @code{kill-append} instead.  @xref{Low-Level Kill
Ring}.
Richard M. Stallman's avatar
Richard M. Stallman committed
897 898
@end deffn

899 900 901 902 903 904 905 906 907 908 909
@node Yanking
@subsection Yanking

  Yanking means inserting text from the kill ring, but it does
not insert the text blindly.  Yank commands and some other commands
use @code{insert-for-yank} to perform special processing on the
text that they copy into the buffer.

@defun insert-for-yank string
This function normally works like @code{insert} except that it doesn't
insert the text properties in the @code{yank-excluded-properties}
910 911 912
list.  However, if any part of @var{string} has a non-@code{nil}
@code{yank-handler} text property, that property can do various
special processing on that part of the text being inserted.
913 914 915 916 917 918 919 920
@end defun

@defun insert-buffer-substring-as-yank buf &optional start end
This function resembles @code{insert-buffer-substring} except that it
doesn't insert the text properties in the
@code{yank-excluded-properties} list.
@end defun

921 922 923 924 925
  You can put a @code{yank-handler} text property on all or part of
the text to control how it will be inserted if it is yanked.  The
@code{insert-for-yank} function looks for that property.  The property
value must be a list of one to four elements, with the following
format (where elements after the first may be omitted):
926 927 928 929 930 931 932 933 934

@example
(@var{function} @var{param} @var{noexclude} @var{undo})
@end example

  Here is what the elements do:

@table @var
@item function
935
When @var{function} is present and non-@code{nil}, it is called instead of
936 937 938 939 940
@code{insert} to insert the string.  @var{function} takes one
argument---the string to insert.

@item param
If @var{param} is present and non-@code{nil}, it replaces @var{string}
941 942 943 944
(or the part of @var{string} being processed) as the object passed to
@var{function} (or @code{insert}); for example, if @var{function} is
@code{yank-rectangle}, @var{param} should be a list of strings to
insert as a rectangle.
945 946 947 948 949 950 951 952

@item noexclude
If @var{noexclude} is present and non-@code{nil}, the normal removal of the
yank-excluded-properties is not performed; instead @var{function} is
responsible for removing those properties.  This may be necessary
if @var{function} adjusts point before or after inserting the object.

@item undo
953
If @var{undo} is present and non-@code{nil}, it is a function that will be
954 955 956 957 958 959
called by @code{yank-pop} to undo the insertion of the current object.
It is called with two arguments, the start and end of the current
region.  @var{function} can set @code{yank-undo-function} to override
the @var{undo} value.
@end table

Richard M. Stallman's avatar
Richard M. Stallman committed
960 961 962 963 964
@node Yank Commands
@comment  node-name,  next,  previous,  up
@subsection Functions for Yanking

  @dfn{Yanking} means reinserting an entry of previously killed text
Karl Heuer's avatar
Karl Heuer committed
965
from the kill ring.  The text properties are copied too.
Richard M. Stallman's avatar
Richard M. Stallman committed
966 967 968

@deffn Command yank &optional arg
@cindex inserting killed text
969
This command inserts before point the text at the front of the
Richard M. Stallman's avatar
Richard M. Stallman committed
970 971 972
kill ring.  It positions the mark at the beginning of that text, and
point at the end.

973 974 975 976
If @var{arg} is a non-@code{nil} list (which occurs interactively when
the user types @kbd{C-u} with no digits), then @code{yank} inserts the
text as described above, but puts point before the yanked text and
puts the mark after it.
Richard M. Stallman's avatar
Richard M. Stallman committed
977

978 979 980 981
If @var{arg} is a number, then @code{yank} inserts the @var{arg}th
most recently killed text---the @var{arg}th element of the kill ring
list, counted cyclically from the front, which is considered the
first element for this purpose.
Richard M. Stallman's avatar
Richard M. Stallman committed
982

983 984 985 986 987 988
@code{yank} does not alter the contents of the kill ring, unless it
used text provided by another program, in which case it pushes that text
onto the kill ring.  However if @var{arg} is an integer different from
one, it rotates the kill ring to place the yanked string at the front.

@code{yank} returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
989 990
@end deffn

991
@deffn Command yank-pop &optional arg
Richard M. Stallman's avatar
Richard M. Stallman committed
992 993 994 995 996 997 998 999
This command replaces the just-yanked entry from the kill ring with a
different entry from the kill ring.

This is allowed only immediately after a @code{yank} or another
@code{yank-pop}.  At such a time, the region contains text that was just
inserted by yanking.  @code{yank-pop} deletes that text and inserts in
its place a different piece of killed text.  It does not add the deleted
text to the kill ring, since it is already in the kill ring somewhere.
1000 1001
It does however rotate the kill ring to place the newly yanked string at
the front.
Richard M. Stallman's avatar
Richard M. Stallman committed
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011

If @var{arg} is @code{nil}, then the replacement text is the previous
element of the kill ring.  If @var{arg} is numeric, the replacement is
the @var{arg}th previous kill.  If @var{arg} is negative, a more recent
kill is the replacement.

The sequence of kills in the kill ring wraps around, so that after the
oldest one comes the newest one, and before the newest one goes the
oldest.

1012
The return value is always @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1013 1014
@end deffn

1015 1016 1017 1018
@defvar yank-undo-function
If this variable is non-@code{nil}, the function @code{yank-pop} uses
its value instead of @code{delete-region} to delete the text
inserted by the previous @code{yank} or
1019 1020
@code{yank-pop} command.  The value must be a function of two
arguments, the start and end of the current region.
1021 1022 1023 1024 1025 1026

The function @code{insert-for-yank} automatically sets this variable
according to the @var{undo} element of the @code{yank-handler}
text property, if there is one.
@end defvar

1027 1028
@node Low-Level Kill Ring
@subsection Low-Level Kill Ring
Richard M. Stallman's avatar
Richard M. Stallman committed
1029

1030 1031 1032 1033
  These functions and variables provide access to the kill ring at a
lower level, but still convenient for use in Lisp programs, because they
take care of interaction with window system selections
(@pxref{Window System Selections}).
Richard M. Stallman's avatar
Richard M. Stallman committed
1034 1035

@defun current-kill n &optional do-not-move
1036 1037
The function @code{current-kill} rotates the yanking pointer, which
designates the ``front'' of the kill ring, by @var{n} places (from newer
1038
kills to older ones), and returns the text at that place in the ring.
Richard M. Stallman's avatar
Richard M. Stallman committed
1039 1040 1041

If the optional second argument @var{do-not-move} is non-@code{nil},
then @code{current-kill} doesn't alter the yanking pointer; it just
1042
returns the @var{n}th kill, counting from the current yanking pointer.
Richard M. Stallman's avatar
Richard M. Stallman committed
1043 1044 1045

If @var{n} is zero, indicating a request for the latest kill,
@code{current-kill} calls the value of
1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
@code{interprogram-paste-function} (documented below) before
consulting the kill ring.  If that value is a function and calling it
returns a string, @code{current-kill} pushes that string onto the kill
ring and returns it.  It also sets the yanking pointer to point to
that new entry, regardless of the value of @var{do-not-move}.
Otherwise, @code{current-kill} does not treat a zero value for @var{n}
specially: it returns the entry pointed at by the yanking pointer and
does not move the yanking pointer.
@end defun

@defun kill-new string &optional replace yank-handler
This function pushes the text @var{string} onto the kill ring and
makes the yanking pointer point to it.  It discards the oldest entry
if appropriate.  It also invokes the value of
Richard M. Stallman's avatar
Richard M. Stallman committed
1060
@code{interprogram-cut-function} (see below).
1061

1062 1063 1064 1065
If @var{replace} is non-@code{nil}, then @code{kill-new} replaces the
first element of the kill ring with @var{string}, rather than pushing
@var{string} onto the kill ring.

1066 1067
If @var{yank-handler} is non-@code{nil}, this puts that value onto
the string of killed text, as a @code{yank-handler} property.
1068 1069 1070
@xref{Yanking}.  Note that if @var{yank-handler} is @code{nil}, then
@code{kill-new} copies any @code{yank-handler} properties present on
@var{string} onto the kill ring, as it does with other text properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
1071 1072
@end defun

1073
@defun kill-append string before-p &optional yank-handler
Richard M. Stallman's avatar
Richard M. Stallman committed
1074
This function appends the text @var{string} to the first entry in the
1075 1076
kill ring and makes the yanking pointer point to the combined entry.
Normally @var{string} goes at the end of the entry, but if
Richard M. Stallman's avatar
Richard M. Stallman committed
1077
@var{before-p} is non-@code{nil}, it goes at the beginning.  This
1078 1079 1080 1081 1082 1083
function also invokes the value of @code{interprogram-cut-function}
(see below).  This handles @var{yank-handler} just like
@code{kill-new}, except that if @var{yank-handler} is different from
the @code{yank-handler} property of the first entry of the kill ring,
@code{kill-append} pushes the concatenated string onto the kill ring,
instead of replacing the original first entry with it.
Richard M. Stallman's avatar
Richard M. Stallman committed
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
@end defun

@defvar interprogram-paste-function
This variable provides a way of transferring killed text from other
programs, when you are using a window system.  Its value should be
@code{nil} or a function of no arguments.

If the value is a function, @code{current-kill} calls it to get the
``most recent kill''.  If the function returns a non-@code{nil} value,
then that value is used as the ``most recent kill''.  If it returns
1094
@code{nil}, then the front of the kill ring is used.
Richard M. Stallman's avatar
Richard M. Stallman committed
1095

1096 1097 1098
The normal use of this hook is to get the window system's primary
selection as the most recent kill, even if the selection belongs to
another application.  @xref{Window System Selections}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1099 1100 1101
@end defvar

@defvar interprogram-cut-function
1102 1103
This variable provides a way of communicating killed text to other
programs, when you are using a window system.  Its value should be
1104
@code{nil} or a function of one required and one optional argument.
Richard M. Stallman's avatar
Richard M. Stallman committed
1105 1106

If the value is a function, @code{kill-new} and @code{kill-append} call
1107 1108 1109 1110
it with the new first element of the kill ring as the first argument.
The second, optional, argument has the same meaning as the @var{push}
argument to @code{x-set-cut-buffer} (@pxref{Definition of
x-set-cut-buffer}) and only affects the second and later cut buffers.
Richard M. Stallman's avatar
Richard M. Stallman committed
1111

1112
The normal use of this hook is to set the window system's primary
1113 1114
selection (and first cut buffer) from the newly killed text.
@xref{Window System Selections}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1115 1116 1117 1118 1119 1120 1121 1122
@end defvar

@node Internals of Kill Ring
@comment  node-name,  next,  previous,  up
@subsection Internals of the Kill Ring

  The variable @code{kill-ring} holds the kill ring contents, in the
form of a list of strings.  The most recent kill is always at the front
1123
of the list.
Richard M. Stallman's avatar
Richard M. Stallman committed
1124 1125

  The @code{kill-ring-yank-pointer} variable points to a link in the
1126 1127
kill ring list, whose @sc{car} is the text to yank next.  We say it
identifies the ``front'' of the ring.  Moving
Richard M. Stallman's avatar
Richard M. Stallman committed
1128
@code{kill-ring-yank-pointer} to a different link is called
1129 1130 1131 1132
@dfn{rotating the kill ring}.  We call the kill ring a ``ring'' because
the functions that move the yank pointer wrap around from the end of the
list to the beginning, or vice-versa.  Rotation of the kill ring is
virtual; it does not change the value of @code{kill-ring}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1133 1134 1135 1136 1137 1138 1139 1140 1141 1142

  Both @code{kill-ring} and @code{kill-ring-yank-pointer} are Lisp
variables whose values are normally lists.  The word ``pointer'' in the
name of the @code{kill-ring-yank-pointer} indicates that the variable's
purpose is to identify one element of the list for use by the next yank
command.

  The value of @code{kill-ring-yank-pointer} is always @code{eq} to one
of the links in the kill ring list.  The element it identifies is the
@sc{car} of that link.  Kill commands, which change the kill ring, also
1143 1144
set this variable to the value of @code{kill-ring}.  The effect is to
rotate the ring so that the newly killed text is at the front.
Richard M. Stallman's avatar
Richard M. Stallman committed
1145 1146 1147

  Here is a diagram that shows the variable @code{kill-ring-yank-pointer}
pointing to the second entry in the kill ring @code{("some text" "a
1148
different piece of text" "yet older text")}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1149 1150 1151

@example
@group
1152 1153 1154 1155 1156 1157
kill-ring                  ---- kill-ring-yank-pointer
  |                       |
  |                       v
  |     --- ---          --- ---      --- ---
   --> |   |   |------> |   |   |--> |   |   |--> nil
        --- ---          --- ---      --- ---
1158 1159 1160
         |                |            |
         |                |            |
         |                |             -->"yet older text"
Richard M. Stallman's avatar
Richard M. Stallman committed
1161
         |                |
1162
         |                 --> "a different piece of text"
Richard M. Stallman's avatar
Richard M. Stallman committed
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172
         |
          --> "some text"
@end group
@end example

@noindent
This state of affairs might occur after @kbd{C-y} (@code{yank})
immediately followed by @kbd{M-y} (@code{yank-pop}).

@defvar kill-ring
1173 1174
This variable holds the list of killed text sequences, most recently
killed first.
Richard M. Stallman's avatar
Richard M. Stallman committed
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
@end defvar

@defvar kill-ring-yank-pointer
This variable's value indicates which element of the kill ring is at the
``front'' of the ring for yanking.  More precisely, the value is a tail
of the value of @code{kill-ring}, and its @sc{car} is the kill string
that @kbd{C-y} should yank.
@end defvar

@defopt kill-ring-max
The value of this variable is the maximum length to which the kill
ring can grow, before elements are thrown away at the end.  The default
1187
value for @code{kill-ring-max} is 60.
Richard M. Stallman's avatar
Richard M. Stallman committed
1188 1189 1190 1191 1192 1193 1194
@end defopt

@node Undo
@comment  node-name,  next,  previous,  up
@section Undo
@cindex redo

1195 1196 1197 1198 1199 1200
  Most buffers have an @dfn{undo list}, which records all changes made
to the buffer's text so that they can be undone.  (The buffers that
don't have one are usually special-purpose buffers for which Emacs
assumes that undoing is not useful.)  All the primitives that modify the
text in the buffer automatically add elements to the front of the undo
list, which is in the variable @code{buffer-undo-list}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1201 1202 1203 1204 1205 1206 1207 1208 1209

@defvar buffer-undo-list
This variable's value is the undo list of the current buffer.
A value of @code{t} disables the recording of undo information.
@end defvar

Here are the kinds of elements an undo list can have:

@table @code
1210 1211 1212 1213 1214
@item @var{position}
This kind of element records a previous value of point; undoing this
element moves point to @var{position}.  Ordinary cursor motion does not
make any sort of undo record, but deletion operations use these entries
to record where point was before the command.
Richard M. Stallman's avatar
Richard M. Stallman committed
1215 1216 1217

@item (@var{beg} . @var{end})
This kind of element indicates how to delete text that was inserted.
1218
Upon insertion, the text occupied the range @var{beg}--@var{end} in the
Richard M. Stallman's avatar
Richard M. Stallman committed
1219 1220
buffer.

Richard M. Stallman's avatar
Richard M. Stallman committed
1221
@item (@var{text} . @var{position})
Richard M. Stallman's avatar
Richard M. Stallman committed
1222
This kind of element indicates how to reinsert text that was deleted.
Richard M. Stallman's avatar
Richard M. Stallman committed
1223
The deleted text itself is the string @var{text}.  The place to
1224 1225 1226
reinsert it is @code{(abs @var{position})}.  If @var{position} is
positive, point was at the beginning of the deleted text, otherwise it
was at the end.
Richard M. Stallman's avatar
Richard M. Stallman committed
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242

@item (t @var{high} . @var{low})
This kind of element indicates that an unmodified buffer became
modified.  The elements @var{high} and @var{low} are two integers, each
recording 16 bits of the visited file's modification time as of when it
was previously visited or saved.  @code{primitive-undo} uses those
values to determine whether to mark the buffer as unmodified once again;
it does so only if the file's modification time matches those numbers.

@item (nil @var{property} @var{value} @var{beg} . @var{end})
This kind of element records a change in a text property.
Here's how you might undo the change:

@example
(put-text-property @var{beg} @var{end} @var{property} @var{value})
@end example
Richard M. Stallman's avatar
Richard M. Stallman committed
1243

1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
@item (apply @var{funname} . @var{args})
This kind of element records a change that can be undone by evaluating
(@code{apply} @var{funname} @var{args}).

@item (apply @var{delta} @var{beg} @var{end} @var{funname} . @var{args})
This kind of element records a change that can be undone by evaluating
(@code{apply} @var{funname} @var{args}).  The integer values @var{beg}
and @var{end} is buffer positions of the range affected by this change
and @var{delta} is an integer value which is the number of bytes added
or deleted in that range by this change.  This kind of element
1254 1255
enables undo limited to a region to determine whether the element
pertains to that region.
1256

1257 1258 1259 1260 1261 1262
@item (@var{marker} . @var{adjustment})
This kind of element records the fact that the marker @var{marker} was
relocated due to deletion of surrounding text, and that it moved
@var{adjustment} character positions.  Undoing this element moves
@var{marker} @minus{} @var{adjustment} characters.

1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
@item (apply @var{funname} . @var{args})
This is an extensible undo item, which is undone by calling
@var{funname} with arguments @var{args}.

@item (apply @var{delta} @var{beg} @var{end} @var{funname} . @var{args})
This is an extensible undo item, which records a change limited to the
range @var{beg} to @var{end}, which increased the size of the buffer
by @var{delta}.  It is undone by calling @var{funname} with arguments
@var{args}.

Richard M. Stallman's avatar
Richard M. Stallman committed
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
@item nil
This element is a boundary.  The elements between two boundaries are
called a @dfn{change group}; normally, each change group corresponds to
one keyboard command, and undo commands normally undo an entire group as
a unit.
@end table

@defun undo-boundary
This function places a boundary element in the undo list.  The undo
command stops at such a boundary, and successive undo commands undo
to earlier and earlier boundaries.  This function returns @code{nil}.

1285 1286 1287 1288 1289 1290 1291 1292 1293
The editor command loop automatically creates an undo boundary before
each key sequence is executed.  Thus, each undo normally undoes the
effects of one command.  Self-inserting input characters are an
exception.  The command loop makes a boundary for the first such
character; the next 19 consecutive self-inserting input characters do
not make boundaries, and then the 20th does, and so on as long as
self-inserting characters continue.

All buffer modifications add a boundary whenever the previous undoable
1294 1295
change was made in some other buffer.  This is to ensure that
each command makes a boundary in each buffer where it makes changes.
1296 1297 1298 1299 1300

Calling this function explicitly is useful for splitting the effects of
a command into more than one unit.  For example, @code{query-replace}
calls @code{undo-boundary} after each replacement, so that the user can
undo individual replacements one by one.
Richard M. Stallman's avatar
Richard M. Stallman committed
1301 1302
@end defun

1303 1304 1305 1306 1307 1308
@defvar undo-in-progress
This variable is normally @code{nil}, but the undo commands bind it to
@code{t}.  This is so that various kinds of change hooks can tell when
they're being called for the sake of undoing.
@end defvar

Richard M. Stallman's avatar
Richard M. Stallman committed
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
@defun primitive-undo count list
This is the basic function for undoing elements of an undo list.
It undoes the first @var{count} elements of @var{list}, returning
the rest of @var{list}.  You could write this function in Lisp,
but it is convenient to have it in C.

@code{primitive-undo} adds elements to the buffer's undo list when it
changes the buffer.  Undo commands avoid confusion by saving the undo
list value at the beginning of a sequence of undo operations.  Then the
undo operations use and update the saved value.  The new elements added
Karl Heuer's avatar
Karl Heuer committed
1319
by undoing are not part of this saved value, so they don't interfere with
Richard M. Stallman's avatar
Richard M. Stallman committed
1320
continuing to undo.
1321 1322

This function does not bind @code{undo-in-progress}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
@end defun

@node Maintaining Undo
@section Maintaining Undo Lists

  This section describes how to enable and disable undo information for
a given buffer.  It also explains how the undo list is truncated
automatically so it doesn't get too big.

  Recording of undo information in a newly created buffer is normally
enabled to start with; but if the buffer name starts with a space, the
undo recording is initially disabled.  You can explicitly enable or
disable undo recording with the following two functions, or by setting
@code{buffer-undo-list} yourself.

@deffn Command buffer-enable-undo &optional buffer-or-name
This command enables recording undo information for buffer
@var{buffer-or-name}, so that subsequent changes can be undone.  If no
argument is supplied, then the current buffer is used.  This function
does nothing if undo recording is already enabled in the buffer.  It
returns @code{nil}.

In an interactive call, @var{buffer-or-name} is the current buffer.
You cannot specify any other buffer.
@end deffn

1349
@deffn Command buffer-disable-undo &optional buffer-or-name
Richard M. Stallman's avatar
Richard M. Stallman committed
1350
@cindex disable undo
Luc Teirlinck's avatar