text.texi 231 KB
Newer Older
Glenn Morris's avatar
Glenn Morris committed
1 2
@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
Paul Eggert's avatar
Paul Eggert committed
3
@c Copyright (C) 1990-1995, 1998-2019 Free Software Foundation, Inc.
Glenn Morris's avatar
Glenn Morris committed
4
@c See the file elisp.texi for copying conditions.
5
@node Text
Glenn Morris's avatar
Glenn Morris committed
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
@chapter Text
@cindex text

  This chapter describes the functions that deal with the text in a
buffer.  Most examine, insert, or delete text in the current buffer,
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}).

  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
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.

@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.
Glenn Morris's avatar
Glenn Morris committed
43
                        How to control how much information is kept.
Glenn Morris's avatar
Glenn Morris committed
44 45 46 47 48 49 50 51 52 53 54 55
* Filling::          Functions for explicit filling.
* Margins::          How to specify margins for filling commands.
* Adaptive Fill::    Adaptive Fill mode chooses a fill prefix from context.
* 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.
* Registers::        How registers are implemented.  Accessing the text or
                       position stored in a register.
Chong Yidong's avatar
Chong Yidong committed
56
* Transposition::    Swapping two portions of a buffer.
57 58
* Replacing::        Replacing the text of one buffer with the text
                       of another buffer.
Glenn Morris's avatar
Glenn Morris committed
59
* Decompression::    Dealing with compressed data.
Glenn Morris's avatar
Glenn Morris committed
60
* Base 64::          Conversion to or from base 64 encoding.
61
* Interpolated Strings:: Formatting Customizable Strings.
62
* Checksum/Hash::    Computing cryptographic hashes.
63
* GnuTLS Cryptography:: Cryptographic algorithms imported from GnuTLS.
64
* Parsing HTML/XML:: Parsing HTML and XML.
65
* Parsing JSON::     Parsing and generating JSON values.
João Távora's avatar
João Távora committed
66
* JSONRPC::          JSON Remote Procedure Call protocol
Paul Eggert's avatar
Paul Eggert committed
67
* Atomic Changes::   Installing several buffer changes atomically.
Glenn Morris's avatar
Glenn Morris committed
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
* Change Hooks::     Supplying functions to be run when text is changed.
@end menu

@node Near Point
@section Examining Text Near Point
@cindex 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}.

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

@defun char-after &optional position
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
or beyond the end, then the value is @code{nil}.  The default for
@var{position} is point.

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

@example
@group
94
(string (char-after 1))
Glenn Morris's avatar
Glenn Morris committed
95 96 97 98 99 100 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
     @result{} "@@"
@end group
@end example
@end defun

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

@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 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
129
(string (preceding-char))
Glenn Morris's avatar
Glenn Morris committed
130
     @result{} "a"
131
(string (following-char))
Glenn Morris's avatar
Glenn Morris committed
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
     @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.
@xref{Text Lines}.  The beginning of the buffer (or of its accessible
portion) always counts as the beginning of a line.
@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
171
@cindex buffer portion as string
Glenn Morris's avatar
Glenn Morris committed
172 173 174 175 176 177 178

  This section describes functions that allow a Lisp program to
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
179 180 181
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.
Glenn Morris's avatar
Glenn Morris committed
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

Here's an example which assumes Font-Lock mode is not enabled:

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

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

@group
(buffer-substring 1 10)
     @result{} "This is t"
@end group
@group
(buffer-substring (point-max) 10)
     @result{} "he contents of buffer foo\n"
@end group
@end example

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.

For example, if Font-Lock mode is enabled, you might get results like
these:

@example
@group
(buffer-substring 1 10)
     @result{} #("This is t" 0 1 (fontified t) 1 9 (fontified t))
@end group
@end example
@end defun

@defun buffer-substring-no-properties start end
This is like @code{buffer-substring}, except that it does not copy text
properties, just the characters themselves.  @xref{Text Properties}.
@end defun

224 225
@defun buffer-string
This function returns the contents of the entire accessible portion of
226
the current buffer, as a string.
227 228
@end defun

229 230 231 232 233 234
  If you need to make sure the resulting string, when copied to a
different location, will not change its visual appearance due to
reordering of bidirectional text, use the
@code{buffer-substring-with-bidi-context} function
(@pxref{Bidirectional Display, buffer-substring-with-bidi-context}).

235
@defun filter-buffer-substring start end &optional delete
236 237 238 239 240
This function filters the buffer text between @var{start} and @var{end}
using a function specified by the variable
@code{filter-buffer-substring-function}, and returns the result.

The default filter function consults the obsolete wrapper hook
241 242 243
@code{filter-buffer-substring-functions} (see the documentation string
of the macro @code{with-wrapper-hook} for the details about this
obsolete facility), and the obsolete variable
244 245 246 247 248
@code{buffer-substring-filters}.  If both of these are @code{nil}, it
returns the unaltered text from the buffer, i.e., what
@code{buffer-substring} would return.

If @var{delete} is non-@code{nil}, the function deletes the text
Glenn Morris's avatar
Glenn Morris committed
249 250 251 252 253 254 255
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},
@code{buffer-substring-no-properties},
or @code{delete-and-extract-region} when copying into user-accessible
data structures such as the kill-ring, X clipboard, and registers.
256 257
Major and minor modes can modify @code{filter-buffer-substring-function}
to alter such text as it is copied out of the buffer.
Glenn Morris's avatar
Glenn Morris committed
258 259
@end defun

260 261 262 263 264 265 266 267 268 269 270 271
@defvar filter-buffer-substring-function
The value of this variable is a function that @code{filter-buffer-substring}
will call to do the actual work.  The function receives three
arguments, the same as those of @code{filter-buffer-substring},
which it should treat as per the documentation of that function.  It
should return the filtered text (and optionally delete the source text).
@end defvar

@noindent The following two variables are obsoleted by
@code{filter-buffer-substring-function}, but are still supported for
backward compatibility.

272
@defvar filter-buffer-substring-functions
273 274 275 276 277 278
This obsolete variable is a wrapper hook, whose members should be functions
that accept four arguments: @var{fun}, @var{start}, @var{end}, and
@var{delete}.  @var{fun} is a function that takes three arguments
(@var{start}, @var{end}, and @var{delete}), and returns a string.  In
both cases, the @var{start}, @var{end}, and @var{delete} arguments are
the same as those of @code{filter-buffer-substring}.
279 280

The first hook function is passed a @var{fun} that is equivalent to
281
the default operation of @code{filter-buffer-substring}, i.e., it
282 283 284 285 286 287 288
returns the buffer-substring between @var{start} and @var{end}
(processed by any @code{buffer-substring-filters}) and optionally
deletes the original text from the buffer.  In most cases, the hook
function will call @var{fun} once, and then do its own processing of
the result.  The next hook function receives a @var{fun} equivalent to
this, and so on.  The actual return value is the result of all the
hook functions acting in sequence.
Glenn Morris's avatar
Glenn Morris committed
289 290
@end defvar

291
@defvar buffer-substring-filters
292 293 294 295 296 297
The value of this obsolete variable should be a list of functions
that accept a single string argument and return another string.
The default @code{filter-buffer-substring} function 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 passed to @code{filter-buffer-substring-functions}.
298
@end defvar
Glenn Morris's avatar
Glenn Morris committed
299 300

@defun current-word &optional strict really-word
301 302
This function returns the symbol (or word) at or near point, as a
string.  The return value includes no text properties.
Glenn Morris's avatar
Glenn Morris committed
303 304 305 306 307 308 309 310 311 312 313

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).

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

314
@defun thing-at-point thing &optional no-properties
Glenn Morris's avatar
Glenn Morris committed
315 316 317 318 319 320 321
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.

322 323 324
When the optional argument @var{no-properties} is non-@code{nil}, this
function strips text properties from the return value.

Glenn Morris's avatar
Glenn Morris committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
@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

@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,
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.

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
if @code{case-fold-search} is non-@code{nil}.  It always ignores
text properties.

Ted Zlatanov's avatar
Ted Zlatanov committed
364 365 366 367
Suppose you have the text @w{@samp{foobarbar haha!rara!}} in the
current buffer; 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.
Glenn Morris's avatar
Glenn Morris committed
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387

@example
(compare-buffer-substrings nil 6 11 nil 16 21)
     @result{} 2
@end example
@end defun

@node Insertion
@section Inserting Text
@cindex insertion of text
@cindex text insertion

@cindex insertion before point
@cindex before point, insertion
  @dfn{Insertion} means adding new text to a buffer.  The inserted text
goes at point---between the character before point and the character
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}.

388 389 390 391 392 393 394
  Insertion moves markers located 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, 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.
Glenn Morris's avatar
Glenn Morris committed
395 396

  Insertion functions signal an error if the current buffer is
397 398
read-only (@pxref{Read Only Buffers}) or if they insert within
read-only text (@pxref{Special Properties}).
Glenn Morris's avatar
Glenn Morris committed
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433

  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.

  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}.

@defun insert &rest args
This function inserts the strings and/or characters @var{args} into the
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}.
@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
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.
@end defun

Chong Yidong's avatar
Chong Yidong committed
434 435 436 437 438 439 440 441
@deffn Command insert-char character &optional count inherit
This command inserts @var{count} instances of @var{character} into the
current buffer before point.  The argument @var{count} must be an
integer, and @var{character} must be a character.

If called interactively, this command prompts for @var{character}
using its Unicode name or its code point.  @xref{Inserting Text,,,
emacs, The GNU Emacs Manual}.
Glenn Morris's avatar
Glenn Morris committed
442 443 444 445 446

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}.

Chong Yidong's avatar
Chong Yidong committed
447
If @var{inherit} is non-@code{nil}, the inserted characters inherit
Glenn Morris's avatar
Glenn Morris committed
448 449
sticky text properties from the two characters before and after the
insertion point.  @xref{Sticky Properties}.
Chong Yidong's avatar
Chong Yidong committed
450
@end deffn
Glenn Morris's avatar
Glenn Morris committed
451 452 453

@defun insert-buffer-substring from-buffer-or-name &optional start end
This function inserts a portion of buffer @var{from-buffer-or-name}
454 455 456 457
into the current buffer before point.  The text inserted is the region
between @var{start} (inclusive) and @var{end} (exclusive).  (These
arguments default to the beginning and end of the accessible portion
of that buffer.)  This function returns @code{nil}.
Glenn Morris's avatar
Glenn Morris committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503

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 ----------
We hold these truth@point{}
---------- Buffer: bar ----------
@end group
@end example
@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.
@end defun

  @xref{Sticky Properties}, for other insertion functions that inherit
text properties from the nearby text in addition to inserting it.
Whitespace inserted by indentation functions also inherits text
properties.

@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
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}.
@end deffn

504
@deffn Command self-insert-command count &optional char
Glenn Morris's avatar
Glenn Morris committed
505 506
@cindex character insertion
@cindex self-insertion
507 508 509 510 511
This command inserts the character @var{char} (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.
Glenn Morris's avatar
Glenn Morris committed
512 513 514

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

515
@c FIXME: This variable is obsolete since 23.1.
516 517 518
Self-insertion translates the input character through
@code{translation-table-for-input}.  @xref{Translation of Characters}.

Glenn Morris's avatar
Glenn Morris committed
519 520 521 522 523 524 525
This command calls @code{auto-fill-function} whenever that is
non-@code{nil} and the character inserted is in the table
@code{auto-fill-chars} (@pxref{Auto Filling}).

@c Cross refs reworded to prevent overfull hbox.  --rjc 15mar92
This command performs abbrev expansion if Abbrev mode is enabled and
the inserted character does not have word-constituent
526
syntax.  (@xref{Abbrevs}, and @ref{Syntax Class Table}.)  It is also
Glenn Morris's avatar
Glenn Morris committed
527 528 529
responsible for calling @code{blink-paren-function} when the inserted
character has close parenthesis syntax (@pxref{Blinking}).

Glenn Morris's avatar
Glenn Morris committed
530
@vindex post-self-insert-hook
531
@vindex self-insert-uses-region-functions
Glenn Morris's avatar
Glenn Morris committed
532 533
The final thing this command does is to run the hook
@code{post-self-insert-hook}.  You could use this to automatically
534 535 536 537 538 539 540 541
reindent text as it is typed, for example.  If any function on this
hook needs to act on the region (@pxref{The Region}), it should make
sure Delete Selection mode (@pxref{Using Region, Delete Selection, ,
emacs, The GNU Emacs Manual}) doesn't delete the region before
@code{post-self-insert-hook} functions are invoked.  The way to do so
is to add a function that returns @code{nil} to
@code{self-insert-uses-region-functions}, a special hook that tells
Delete Selection mode it should not delete the region.
Glenn Morris's avatar
Glenn Morris committed
542

Glenn Morris's avatar
Glenn Morris committed
543 544 545 546 547
Do not try substituting your own definition of
@code{self-insert-command} for the standard one.  The editor command
loop handles this function specially.
@end deffn

548
@deffn Command newline &optional number-of-newlines interactive
Glenn Morris's avatar
Glenn Morris committed
549 550
This command inserts newlines into the current buffer before point.
If @var{number-of-newlines} is supplied, that many newline characters
551 552
are inserted.  In an interactive call, @var{number-of-newlines} is the
numeric prefix argument.
Glenn Morris's avatar
Glenn Morris committed
553 554

@cindex newline and Auto Fill mode
555 556 557
This command calls @code{self-insert-command} to insert newlines,
which may subsequently break the preceding line by calling
@code{auto-fill-function} (@pxref{Auto Filling}).  Typically what
Glenn Morris's avatar
Glenn Morris committed
558 559 560 561 562
@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}.

563 564 565
This command does not run the hook @code{post-self-insert-hook} unless
called interactively or @var{interactive} is non-@code{nil}.

Glenn Morris's avatar
Glenn Morris committed
566 567 568
This command indents to the left margin if that is not zero.
@xref{Margins}.

569
The value returned is @code{nil}.
Glenn Morris's avatar
Glenn Morris committed
570 571 572 573 574 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
@end deffn

@defvar overwrite-mode
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).
@end defvar

@node Deletion
@section Deleting Text
@cindex text deletion

@cindex deleting text 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}).
Some deletion functions do save text in the kill ring in some special
cases.

  All of the deletion functions operate on the current buffer.

@deffn Command erase-buffer
This function deletes the entire text of the current buffer
(@emph{not} just the accessible portion), leaving it
empty.  If the buffer is read-only, it signals a @code{buffer-read-only}
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}.

Normally, deleting a large amount of text from a buffer inhibits further
Paul Eggert's avatar
Paul Eggert committed
603
auto-saving of that buffer because it has shrunk.  However,
Glenn Morris's avatar
Glenn Morris committed
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 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 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
@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.
@end deffn

@deffn Command delete-region start end
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}.
Otherwise, point relocates with the surrounding text, as markers do.
@end deffn

@defun delete-and-extract-region start end
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

@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 deleting 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

@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;
@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
whitespace characters.
@end defopt

@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.

@deffn Command delete-horizontal-space &optional backward-only
@cindex deleting whitespace
This function deletes all spaces and tabs around point.  It returns
@code{nil}.

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

In the following examples, we call @code{delete-horizontal-space} four
times, once on each line, with point between the second and third
characters on the line each time.

@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

730
@deffn Command delete-indentation &optional join-following-p beg end
Glenn Morris's avatar
Glenn Morris committed
731 732 733 734
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
735 736 737 738 739 740 741
instead.  Otherwise, if @var{beg} and @var{end} are non-@code{nil},
this function joins all lines in the region they define.

In an interactive call, @var{join-following-p} is the prefix argument,
and @var{beg} and @var{end} are, respectively, the start and end of
the region if it is active, else @code{nil}.  The function returns
@code{nil}.
Glenn Morris's avatar
Glenn Morris committed
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818

If there is a fill prefix, and the second of the lines being joined
starts with the prefix, then @code{delete-indentation} deletes the
fill prefix before joining the lines.  @xref{Margins}.

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
@group
---------- Buffer: foo ----------
When in the course of human
@point{}    events, it becomes necessary
---------- Buffer: foo ----------
@end group

(delete-indentation)
     @result{} nil

@group
---------- Buffer: foo ----------
When in the course of human@point{} events, it becomes necessary
---------- Buffer: foo ----------
@end group
@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

@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}.

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
with point before the word @samp{spaces} in the first line.  For the
second invocation, point is directly after the @samp{(}.

@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
@end deffn

@deffn Command just-one-space &optional n
@comment !!SourceFile simple.el
This command replaces any spaces and tabs around point with a single
space, or @var{n} spaces if @var{n} is specified.  It returns
@code{nil}.
@end deffn

Glenn Morris's avatar
Glenn Morris committed
819 820 821
@c There is also cycle-spacing, but I cannot see it being useful in
@c Lisp programs, so it is not mentioned here.

Glenn Morris's avatar
Glenn Morris committed
822 823 824 825 826 827 828 829
@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
blank lines immediately following it.

A blank line is defined as a line containing only tabs and spaces.
830
@c and the Newline character?
Glenn Morris's avatar
Glenn Morris committed
831 832 833 834

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

835
@deffn Command delete-trailing-whitespace &optional start end
836 837 838 839 840 841
Delete trailing whitespace in the region defined by @var{start} and
@var{end}.

This command deletes whitespace characters after the last
non-whitespace character in each line in the region.

Paul Eggert's avatar
Paul Eggert committed
842
If this command acts on the entire buffer (i.e., if called
843
interactively with the mark inactive, or called from Lisp with
844
@var{end} @code{nil}), it also deletes all trailing lines at the end of the
845 846 847
buffer if the variable @code{delete-trailing-lines} is non-@code{nil}.
@end deffn

Glenn Morris's avatar
Glenn Morris committed
848 849 850 851 852 853 854 855
@node The Kill Ring
@section The Kill Ring
@cindex kill ring

  @dfn{Kill functions} delete text like the deletion functions, but save
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
Paul Eggert's avatar
Paul Eggert committed
856
yanking (though they can still be undone); these are deletion
Glenn Morris's avatar
Glenn Morris committed
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
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
commands for killing text.  When you need to delete text for internal
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
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.

  Some people think this use of the word ``kill'' is unfortunate, since
it refers to operations that specifically @emph{do not} destroy the
Paul Eggert's avatar
Paul Eggert committed
877 878
entities killed.  This is in sharp contrast to ordinary life, in
which death is permanent and killed entities do not come back to
Glenn Morris's avatar
Glenn Morris committed
879 880 881 882 883 884 885 886 887 888
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.
* Yanking::                How yanking is done.
* Yank Commands::          Commands that access the kill ring.
Glenn Morris's avatar
Glenn Morris committed
889
* Low-Level Kill Ring::    Functions and variables for kill ring access.
Glenn Morris's avatar
Glenn Morris committed
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912
* Internals of Kill Ring:: Variables that hold kill ring data.
@end menu

@node Kill Ring Concepts
@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
succession build up a single kill ring entry, which would be yanked as a
unit; the second and subsequent consecutive kill commands add text to
the entry made by the first one.

Paul Eggert's avatar
Paul Eggert committed
913 914 915
  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
Glenn Morris's avatar
Glenn Morris committed
916 917 918 919 920 921 922
change the list itself---the most recent entry always comes first in the
list.

@node Kill Functions
@subsection Functions for Killing

  @code{kill-region} is the usual subroutine for killing text.  Any
Paul Eggert's avatar
Paul Eggert committed
923
command that calls this function is a kill command (and should
Glenn Morris's avatar
Glenn Morris committed
924 925 926 927 928 929
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
adds it to the most recent element.  It determines automatically (using
@code{last-command}) whether the previous command was a kill command,
and if so appends the killed text to the most recent entry.

930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
@cindex filtering killed text
  The commands described below can filter the killed text before they
save it in the kill ring.  They call @code{filter-buffer-substring}
(@pxref{Buffer Contents}) to perform the filtering.  By default,
there's no filtering, but major and minor modes and hook functions can
set up filtering, so that text saved in the kill ring is different
from what was in the buffer.

@deffn Command kill-region start end &optional region
This function kills the stretch of text between @var{start} and
@var{end}; but if the optional argument @var{region} is
non-@code{nil}, it ignores @var{start} and @var{end}, and kills the
text in the current region instead.  The text is deleted but saved in
the kill ring, along with its text properties.  The value is always
@code{nil}.
Glenn Morris's avatar
Glenn Morris committed
945 946

In an interactive call, @var{start} and @var{end} are point and
947 948
the mark, and @var{region} is always non-@code{nil}, so the command
always kills the text in the current region.
Glenn Morris's avatar
Glenn Morris committed
949 950 951 952 953 954 955 956 957 958 959 960 961

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.
@end deffn

@defopt kill-read-only-ok
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.
@end defopt

962 963 964 965 966 967 968 969 970 971 972
@deffn Command copy-region-as-kill start end &optional region
This function saves the stretch of text between @var{start} and
@var{end} on the kill ring (including text properties), but does not
delete the text from the buffer.  However, if the optional argument
@var{region} is non-@code{nil}, the function ignores @var{start} and
@var{end}, and saves the current region instead.  It always returns
@code{nil}.

In an interactive call, @var{start} and @var{end} are point and
the mark, and @var{region} is always non-@code{nil}, so the command
always saves the text in the current region.
Glenn Morris's avatar
Glenn Morris committed
973 974 975 976 977 978 979 980

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.
@end deffn

@node Yanking
@subsection Yanking

981 982 983 984
  Yanking means inserting text from the kill ring, but it does not
insert the text blindly.  The @code{yank} command, and related
commands, use @code{insert-for-yank} to perform special processing on
the text before it is inserted.
Glenn Morris's avatar
Glenn Morris committed
985 986

@defun insert-for-yank string
987 988 989 990 991
This function works like @code{insert}, except that it processes the
text in @var{string} according to the @code{yank-handler} text
property, as well as the variables @code{yank-handled-properties} and
@code{yank-excluded-properties} (see below), before inserting the
result into the current buffer.
Glenn Morris's avatar
Glenn Morris committed
992 993 994
@end defun

@defun insert-buffer-substring-as-yank buf &optional start end
995 996 997 998 999
This function resembles @code{insert-buffer-substring}, except that it
processes the text according to @code{yank-handled-properties} and
@code{yank-excluded-properties}.  (It does not handle the
@code{yank-handler} property, which does not normally occur in buffer
text anyway.)
Glenn Morris's avatar
Glenn Morris committed
1000 1001
@end defun

1002
@c FIXME: Add an index for yank-handler.
1003 1004 1005 1006 1007 1008 1009
  If you put a @code{yank-handler} text property on all or part of a
string, that alters how @code{insert-for-yank} inserts the string.  If
different parts of the string have different @code{yank-handler}
values (comparison being done with @code{eq}), each substring is
handled separately.  The property value must be a list of one to four
elements, with the following format (where elements after the first
may be omitted):
Glenn Morris's avatar
Glenn Morris committed
1010 1011 1012 1013 1014 1015 1016 1017 1018

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

  Here is what the elements do:

@table @var
@item function
1019 1020 1021
When @var{function} is non-@code{nil}, it is called instead of
@code{insert} to insert the string, with one argument---the string to
insert.
Glenn Morris's avatar
Glenn Morris committed
1022 1023 1024

@item param
If @var{param} is present and non-@code{nil}, it replaces @var{string}
1025 1026 1027 1028
(or the substring 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.
Glenn Morris's avatar
Glenn Morris committed
1029 1030

@item noexclude
1031 1032 1033
If @var{noexclude} is present and non-@code{nil}, that disables the
normal action of @code{yank-handled-properties} and
@code{yank-excluded-properties} on the inserted string.
Glenn Morris's avatar
Glenn Morris committed
1034 1035 1036 1037 1038 1039 1040 1041 1042

@item undo
If @var{undo} is present and non-@code{nil}, it is a function that will be
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

1043
@cindex yanking and text properties
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057
@defopt yank-handled-properties
This variable specifies special text property handling conditions for
yanked text.  It takes effect after the text has been inserted (either
normally, or via the @code{yank-handler} property), and prior to
@code{yank-excluded-properties} taking effect.

The value should be an alist of elements @code{(@var{prop}
. @var{fun})}.  Each alist element is handled in order.  The inserted
text is scanned for stretches of text having text properties @code{eq}
to @var{prop}; for each such stretch, @var{fun} is called with three
arguments: the value of the property, and the start and end positions
of the text.
@end defopt

1058
@defopt yank-excluded-properties
1059 1060 1061 1062 1063
The value of this variable is the list of properties to remove from
inserted text.  Its default value contains properties that might lead
to annoying results, such as causing the text to respond to the mouse
or specifying key bindings.  It takes effect after
@code{yank-handled-properties}.
1064 1065
@end defopt

1066

Glenn Morris's avatar
Glenn Morris committed
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
@node Yank Commands
@subsection Functions for Yanking

  This section describes higher-level commands for yanking, which are
intended primarily for the user but useful also in Lisp programs.
Both @code{yank} and @code{yank-pop} honor the
@code{yank-excluded-properties} variable and @code{yank-handler} text
property (@pxref{Yanking}).

@deffn Command yank &optional arg
@cindex inserting killed text
1078 1079 1080
This command inserts before point the text at the front of the kill
ring.  It sets the mark at the beginning of that text, using
@code{push-mark} (@pxref{The Mark}), and puts point at the end.
Glenn Morris's avatar
Glenn Morris committed
1081 1082 1083 1084

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
1085
sets the mark after it.
Glenn Morris's avatar
Glenn Morris committed
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139

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.

@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}.
@end deffn

@deffn Command yank-pop &optional arg
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.
It does however rotate the kill ring to place the newly yanked string at
the front.

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.

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

@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
@code{yank-pop} command.  The value must be a function of two
arguments, the start and end of the current region.

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

@node Low-Level Kill Ring
@subsection Low-Level Kill Ring

  These functions and variables provide access to the kill ring at a
1140 1141
lower level, but are still convenient for use in Lisp programs,
because they take care of interaction with window system selections
Glenn Morris's avatar
Glenn Morris committed
1142 1143 1144 1145
(@pxref{Window System Selections}).

@defun current-kill n &optional do-not-move
The function @code{current-kill} rotates the yanking pointer, which
Paul Eggert's avatar
Paul Eggert committed
1146
designates the front of the kill ring, by @var{n} places (from newer
Glenn Morris's avatar
Glenn Morris committed
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
kills to older ones), and returns the text at that place in the ring.

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
returns the @var{n}th kill, counting from the current yanking pointer.

If @var{n} is zero, indicating a request for the latest kill,
@code{current-kill} calls the value of
@code{interprogram-paste-function} (documented below) before
consulting the kill ring.  If that value is a function and calling it
1157
returns a string or a list of several strings, @code{current-kill}
1158
pushes the strings onto the kill ring and returns the first string.
1159 1160
It also sets the yanking pointer to point to the kill-ring entry of
the first string returned by @code{interprogram-paste-function},
1161 1162 1163 1164
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.
Glenn Morris's avatar
Glenn Morris committed
1165 1166
@end defun

1167
@defun kill-new string &optional replace
Glenn Morris's avatar
Glenn Morris committed
1168 1169
This function pushes the text @var{string} onto the kill ring and
makes the yanking pointer point to it.  It discards the oldest entry
1170 1171 1172 1173
if appropriate.  It also invokes the values of
@code{interprogram-paste-function} (subject to
the user option @code{save-interprogram-paste-before-kill})
and @code{interprogram-cut-function} (see below).
Glenn Morris's avatar
Glenn Morris committed
1174 1175 1176 1177 1178 1179

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.
@end defun

1180
@defun kill-append string before-p
Glenn Morris's avatar
Glenn Morris committed
1181 1182 1183 1184
This function appends the text @var{string} to the first entry in the
kill ring and makes the yanking pointer point to the combined entry.
Normally @var{string} goes at the end of the entry, but if
@var{before-p} is non-@code{nil}, it goes at the beginning.  This
1185 1186 1187 1188
function calls @code{kill-new} as a subroutine, thus causing the
values of @code{interprogram-cut-function} and possibly
@code{interprogram-paste-function} (see below) to be invoked by
extension.
Glenn Morris's avatar
Glenn Morris committed
1189 1190 1191 1192 1193 1194 1195 1196
@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
Paul Eggert's avatar
Paul Eggert committed
1197 1198
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
Glenn Morris's avatar
Glenn Morris committed
1199 1200
@code{nil}, then the front of the kill ring is used.

1201 1202
To facilitate support for window systems that support multiple
selections, this function may also return a list of strings.  In that
Paul Eggert's avatar
Paul Eggert committed
1203
case, the first string is used as the most recent kill, and all
1204 1205 1206
the other strings are pushed onto the kill ring, for easy access by
@code{yank-pop}.

1207 1208
The normal use of this function is to get the window system's
clipboard as the most recent kill, even if the selection belongs to
1209
another application.  @xref{Window System Selections}.  However, if
1210 1211
the clipboard contents come from the current Emacs session, this
function should return @code{nil}.
Glenn Morris's avatar
Glenn Morris committed
1212 1213 1214 1215 1216
@end defvar

@defvar interprogram-cut-function
This variable provides a way of communicating killed text to other
programs, when you are using a window system.  Its value should be
1217
@code{nil} or a function of one required argument.
Glenn Morris's avatar
Glenn Morris committed
1218 1219

If the value is a function, @code{kill-new} and @code{kill-append} call
1220
it with the new first element of the kill ring as the argument.
Glenn Morris's avatar
Glenn Morris committed
1221

1222 1223
The normal use of this function is to put newly killed text in the
window system's clipboard.  @xref{Window System Selections}.
Glenn Morris's avatar
Glenn Morris committed
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
@end defvar

@node Internals of Kill Ring
@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
of the list.

  The @code{kill-ring-yank-pointer} variable points to a link in the
kill ring list, whose @sc{car} is the text to yank next.  We say it
Paul Eggert's avatar
Paul Eggert committed
1235
identifies the front of the ring.  Moving
Glenn Morris's avatar
Glenn Morris committed
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
@code{kill-ring-yank-pointer} to a different link is called
@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}.

  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
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.

  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
different piece of text" "yet older text")}.

@example
@group
kill-ring                  ---- kill-ring-yank-pointer
  |                       |
  |                       v
  |     --- ---          --- ---      --- ---
   --> |   |   |------> |   |   |--> |   |   |--> nil
        --- ---          --- ---      --- ---
         |                |            |
         |                |            |
         |                |             -->"yet older text"
         |                |
         |                 --> "a different piece of text"
         |
          --> "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
This variable holds the list of killed text sequences, most recently
killed first.
@end defvar

@defvar kill-ring-yank-pointer
This variable's value indicates which element of the kill ring is at the
Paul Eggert's avatar
Paul Eggert committed
1287
front of the ring for yanking.  More precisely, the value is a tail
Glenn Morris's avatar
Glenn Morris committed
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
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
value for @code{kill-ring-max} is 60.
@end defopt

@node Undo
@section Undo
@cindex redo

  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.  In particular, any buffer whose
name begins with a space has its undo recording off by default;
see @ref{Buffer Names}.)  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}.

@defvar buffer-undo-list
This buffer-local variable's value is the undo list of the current
1313
buffer.  A value of @code{t} disables the recording of undo information.
Glenn Morris's avatar
Glenn Morris committed
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
@end defvar

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

@table @code
@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.

@item (@var{beg} . @var{end})
This kind of element indicates how to delete text that was inserted.
Upon insertion, the text occupied the range @var{beg}--@var{end} in the
buffer.

@item (@var{text} . @var{position})
This kind of element indicates how to reinsert text that was deleted.
The deleted text itself is the string @var{text}.  The place to
reinsert it is @code{(abs @var{position})}.  If @var{position} is
positive, point was at the beginning of the deleted text, otherwise it
1335 1336
was at the end.  Zero or more (@var{marker} . @var{adjustment})
elements follow immediately after this element.
Glenn Morris's avatar
Glenn Morris committed
1337

Paul Eggert's avatar
Paul Eggert committed
1338
@item (t . @var{time-flag})
Glenn Morris's avatar
Glenn Morris committed
1339
This kind of element indicates that an unmodified buffer became
1340 1341
modified.  A @var{time-flag} that is a non-integer Lisp timestamp
represents the visited file's modification time as of
1342
when it was previously visited or saved, using the same format as
Paul Eggert's avatar
Paul Eggert committed
1343 1344 1345 1346
@code{current-time}; see @ref{Time of Day}.
A @var{time-flag} of 0 means the buffer does not correspond to any file;
@minus{}1 means the visited file previously did not exist.
@code{primitive-undo} uses these
Glenn Morris's avatar
Glenn Morris committed
1347
values to determine whether to mark the buffer as unmodified once again;
Paul Eggert's avatar
Paul Eggert committed
1348
it does so only if the file's status matches that of @var{time-flag}.
Glenn Morris's avatar
Glenn Morris committed
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360

@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

@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
1361 1362 1363 1364
@var{adjustment} character positions.  If the marker's location is
consistent with the (@var{text} . @var{position}) element preceding it
in the undo list, then undoing this element moves @var{marker}
@minus{} @var{adjustment} characters.
Glenn Morris's avatar
Glenn Morris committed
1365 1366 1367 1368 1369 1370 1371 1372

@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
1373
by @var{delta} characters.  It is undone by calling @var{funname} with
Xue Fuqiao's avatar
Xue Fuqiao committed
1374
arguments @var{args}.
Glenn Morris's avatar
Glenn Morris committed
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394

This kind of element enables undo limited to a region to determine
whether the element pertains to that region.

@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}.

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.
1395 1396 1397

Mostly, however, this function is called automatically at an
appropriate time.
Glenn Morris's avatar
Glenn Morris committed
1398 1399
@end defun

1400
@defun undo-auto-amalgamate
1401
@cindex amalgamating commands, and undo
1402 1403 1404
The editor command loop automatically calls @code{undo-boundary} just
before executing each key sequence, so that each undo normally undoes
the effects of one command.  A few exceptional commands are
1405 1406
@dfn{amalgamating}: these commands generally cause small changes to
buffers, so with these a boundary is inserted only every 20th command,
1407
allowing the changes to be undone as a group.  By default, the commands
1408
@code{self-insert-command}, which produces self-inserting input
1409 1410
characters (@pxref{Commands for Insertion}), and @code{delete-char},
which deletes characters (@pxref{Deletion}), are amalgamating.
1411 1412
Where a command affects the contents of several buffers, as may happen,
for example, when a function on the @code{post-command-hook} affects a
1413
buffer other than the @code{current-buffer}, then @code{undo-boundary}
1414
will be called in each of the affected buffers.
1415 1416 1417 1418

This function can be called before an amalgamating command.  It
removes the previous @code{undo-boundary} if a series of such calls
have been made.
1419 1420
@end defun

1421
@defvar undo-auto-current-boundary-timer
1422
Some buffers, such as process buffers, can change even when no
1423 1424 1425
commands are executing.  In these cases, @code{undo-boundary} is
normally called periodically by the timer in this variable.  Setting
this variable to non-@code{nil} prevents this behavior.
1426 1427
@end defvar

Glenn Morris's avatar
Glenn Morris committed
1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480
@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

@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}.

@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
by undoing are not part of this saved value, so they don't interfere with
continuing to undo.

This function does not bind @code{undo-in-progress}.
@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

@deffn Command buffer-disable-undo &optional buffer-or-name
@cindex disabling undo
This function discards the undo list of @var{buffer-or-name}, and disables
further recording of undo information.  As a result, it is no longer
possible to undo either previous changes or any subsequent changes.  If
the undo list of @var{buffer-or-name} is already disabled, this function
has no effect.

1481 1482
In an interactive call, BUFFER-OR-NAME is the current buffer.  You
cannot specify any other buffer.  This function returns @code{nil}.
Glenn Morris's avatar
Glenn Morris committed
1483 1484 1485 1486
@end deffn

  As editing continues, undo lists get longer and longer.  To prevent
them from using up all available memory space, garbage collection trims
Paul Eggert's avatar
Paul Eggert committed
1487
them back to size limits you can set.  (For this purpose, the size
Glenn Morris's avatar
Glenn Morris committed
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
of an undo list measures the cons cells that make up the list, plus the
strings of deleted text.)  Three variables control the range of acceptable
sizes: @code{undo-limit}, @code{undo-strong-limit} and
@code{undo-outer-limit}.  In these variables, size is counted as the
number of bytes occupied, which includes both saved text and other
data.

@defopt undo-limit
This is the soft limit for the acceptable size of an undo list.  The
change group at which this size is exceeded is the last one kept.
@end defopt

@defopt undo-strong-limit
This is the upper limit for the acceptable size of an undo list.  The
change group at which this size is exceeded is discarded itself (along
with all older change groups).  There is one exception: the very latest
change group is only discarded if it exceeds @code{undo-outer-limit}.
@end defopt

@defopt undo-outer-limit
If at garbage collection time the undo info for the current command
exceeds this limit, Emacs discards the info and displays a warning.
This is a last ditch limit to prevent memory overflow.
@end defopt

@defopt undo-ask-before-discard
If this variable is non-@code{nil}, when the undo info exceeds
@code{undo-outer-limit}, Emacs asks in the echo area whether to
discard the info.  The default value is @code{nil}, which means to
discard it automatically.

This option is mainly intended for debugging.  Garbage collection is
inhibited while the question is asked, which means that Emacs might
leak memory if the user waits too long before answering the question.
@end defopt

@node Filling
@section Filling
@cindex filling text

  @dfn{Filling} means adjusting the lengths of lines (by moving the line
breaks) so that they are nearly (but no greater than) a specified
maximum width.  Additionally, lines can be @dfn{justified}, which means
inserting spaces to make the left and/or right margins line up
precisely.  The width is controlled by the variable @code{fill-column}.
For ease of reading, lines should be no longer than 70 or so columns.

  You can use Auto Fill mode (@pxref{Auto Filling}) to fill text
automatically as you insert it, but changes to existing text may leave
it improperly filled.  Then you must fill the text explicitly.

  Most of the commands in this section return values that are not
meaningful.  All the functions that do filling take note of the current
left margin, current right margin, and current justification style
(@pxref{Margins}).  If the current justification style is
@code{none}, the filling functions don't actually do anything.

  Several of the filling functions have an argument @var{justify}.
If it is non-@code{nil}, that requests some kind of justification.  It
can be @code{left}, @code{right}, @code{full}, or @code{center}, to
request a specific style of justification.  If it is @code{t}, that
means to use the current justification style for this part of the text
(see @code{current-justification}, below).  Any other value is treated
as @code{full}.

  When you call the filling functions interactively, using a prefix
argument implies the value @code{full} for @var{justify}.

1556
@deffn Command fill-paragraph &optional justify region
Glenn Morris's avatar
Glenn Morris committed
1557 1558 1559 1560
This command fills the paragraph at or after point.  If
@var{justify} is non-@code{nil}, each line is justified as well.
It uses the ordinary paragraph motion commands to find paragraph
boundaries.  @xref{Paragraphs,,, emacs, The GNU Emacs Manual}.
1561 1562 1563 1564 1565 1566

When @var{region} is non-@code{nil}, then if Transient Mark mode is
enabled and the mark is active, this command calls @code{fill-region}
to fill all the paragraphs in the region, instead of filling only the
current paragraph.  When this command is called interactively,
@var{region} is @code{t}.
Glenn Morris's avatar
Glenn Morris committed
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
@end deffn

@deffn Command fill-region start end &optional justify nosqueeze to-eop
This command fills each of the paragraphs in the region from @var{start}
to @var{end}.  It justifies as well if @var{justify} is
non-@code{nil}.

If @var{nosqueeze} is non-@code{nil}, that means to leave whitespace
other than line breaks untouched.  If @var{to-eop} is non-@code{nil},
that means to keep filling to the end of the paragraph---or the next hard
newline, if @code{use-hard-newlines} is enabled (see below).

The variable @code{paragraph-separate} controls how to distinguish
paragraphs.  @xref{Standard Regexps}.
@end deffn

@deffn Command fill-individual-paragraphs start end &optional justify citation-regexp
This command fills each paragraph in the region according to its
individual fill prefix.  Thus, if the lines of a paragraph were indented
with spaces, the filled paragraph will remain indented in the same
fashion.

The first two arguments, @var{start} and @var{end}, are the beginning
and end of the region to be filled.  The third and fourth arguments,
@var{justify} and @var{citation-regexp}, are optional.  If
@var{justify} is non-@code{nil}, the paragraphs are justified as
well as filled.  If @var{citation-regexp} is non-@code{nil}, it means the
function is operating on a mail message and therefore should not fill
the header lines.  If @var{citation-regexp} is a string, it is used as
a regular expression; if it matches the beginning of a line, that line
is treated as a citation marker.

1599
@c FIXME: "That mode" is confusing.  It isn't a major/minor mode.
Glenn Morris's avatar
Glenn Morris committed
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
Ordinarily, @code{fill-individual-paragraphs} regards each change in
indentation as starting a new paragraph.  If
@code{fill-individual-varying-indent} is non-@code{nil}, then only
separator lines separate paragraphs.  That mode can handle indented
paragraphs with additional indentation on the first line.
@end deffn

@defopt fill-individual-varying-indent
This variable alters the action of @code{fill-individual-paragraphs} as
described above.
@end defopt

@deffn Command fill-region-as-paragraph start end &optional justify nosqueeze squeeze-after
This command considers a region of text as a single paragraph and fills
it.  If the region was made up of many paragraphs, the blank lines
between paragraphs are removed.  This function justifies as well as
filling when @var{justify} is non-@code{nil}.

If @var{nosqueeze} is non-@code{nil}, that means to leave whitespace
other than line breaks untouched.  If @var{squeeze-after} is
non-@code{nil}, it specifies a position in the region, and means don't
canonicalize spaces before that position.

In Adaptive Fill mode, this command calls @code{fill-context-prefix} to
choose a fill prefix by default.  @xref{Adaptive Fill}.
@end deffn

@deffn Command justify-current-line &optional how eop nosqueeze
This command inserts spaces between the words of the current line so
that the line ends exactly at @code{fill-column}.  It returns
@code{nil}.

The argument @var{how}, if non-@code{nil} specifies explicitly the style
of justification.  It can be @code{left}, @code{right}, @code{full},
1634
@code{center}, or @code{none}.  If it is @code{t}, that means to
Glenn Morris's avatar
Glenn Morris committed
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
follow specified justification style (see @code{current-justification},
below).  @code{nil} means to do full justification.

If @var{eop} is non-@code{nil}, that means do only left-justification
if @code{current-justification} specifies full justification.  This is
used for the last line of a paragraph; even if the paragraph as a
whole is fully justified, the last line should not be.

If @var{nosqueeze} is non-@code{nil}, that means do not change interior
whitespace.
@end deffn

@defopt default-justification
This variable's value specifies the style of justification to use for
text that doesn't specify a style with a text property.  The possible
values are @code{left}, @code{right}, @code{full}, @code{center}, or
@code{none}.  The default value is @code{left}.
@end defopt

@defun current-justification
This function returns the proper justification style to use for filling
the text around point.

This returns the value of the @code{justification} text property at
1659
point, or the variable @code{default-justification} if there is no such
Glenn Morris's avatar
Glenn Morris committed
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669