text.texi 133 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
@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc. 
Richard M. Stallman's avatar
Richard M. Stallman committed
4 5
@c See the file elisp.texi for copying conditions.
@setfilename ../info/text
6
@node Text, Non-ASCII Characters, Markers, Top
Richard M. Stallman's avatar
Richard M. Stallman committed
7 8 9 10
@chapter Text
@cindex text

  This chapter describes the functions that deal with the text in a
11
buffer.  Most examine, insert, or delete text in the current buffer,
12 13 14
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
15 16 17 18 19 20 21 22 23 24 25 26 27 28

  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
29 30 31
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
32 33 34 35 36 37 38 39 40 41 42 43 44 45

@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
46
* Margins::          How to specify margins for filling commands.
Karl Heuer's avatar
Karl Heuer committed
47
* Adaptive Fill::    Adaptive Fill mode chooses a fill prefix from context.
Richard M. Stallman's avatar
Richard M. Stallman committed
48 49 50 51 52 53 54
* 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.
55
* Transposition::    Swapping two portions of a buffer.
Richard M. Stallman's avatar
Richard M. Stallman committed
56 57
* Registers::        How registers are implemented.  Accessing the text or
                       position stored in a register.
58
* Base 64::          Conversion to or from base 64 encoding.
Richard M. Stallman's avatar
Richard M. Stallman committed
59 60 61 62 63 64 65 66 67 68
* 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}.

69
@defun char-after &optional position
Richard M. Stallman's avatar
Richard M. Stallman committed
70 71 72
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
73 74
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
75 76 77 78 79 80 81 82 83 84 85 86

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

87
@defun char-before &optional position
88 89 90
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 before the beginning of the buffer, or at or beyond
91 92
the end, then the value is @code{nil}.  The default for
@var{position} is point.
93 94
@end defun

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

  This section describes two 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
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
173 174 175 176 177
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
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
@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
"
@end group
@end example
@end defun

198
@defun buffer-substring-no-properties start end
Karl Heuer's avatar
Karl Heuer committed
199 200 201 202
This is like @code{buffer-substring}, except that it does not copy text
properties, just the characters themselves.  @xref{Text Properties}.
@end defun

Richard M. Stallman's avatar
Richard M. Stallman committed
203
@defun buffer-string
204
This function returns the contents of the entire accessible portion of
205 206 207 208 209
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
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

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

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

(buffer-string)
     @result{} "This is the contents of buffer foo
"
@end group
@end example
@end defun

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
@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
248 249 250 251 252 253 254 255 256 257 258 259
@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 and two positions within the buffer.  The last three
arguments specify the other substring in the same way.  You can use
260
@code{nil} for @var{buffer1}, @var{buffer2}, or both to stand for the
Richard M. Stallman's avatar
Richard M. Stallman committed
261 262 263 264 265 266 267 268
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
Karl Heuer's avatar
Karl Heuer committed
269 270
if @code{case-fold-search} is non-@code{nil}.  It always ignores
text properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
271 272 273 274 275 276 277 278 279 280 281 282 283

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
(compare-buffer-substring nil 6 11 nil 16 21)
     @result{} 2
@end example
@end defun

@node Insertion
Karl Heuer's avatar
Karl Heuer committed
284
@section Inserting Text
Richard M. Stallman's avatar
Richard M. Stallman committed
285 286 287
@cindex insertion of text
@cindex text insertion

288 289
@cindex insertion before point
@cindex before point, insertion
Richard M. Stallman's avatar
Richard M. Stallman committed
290 291
  @dfn{Insertion} means adding new text to a buffer.  The inserted text
goes at point---between the character before point and the character
292 293 294
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
295 296 297 298

  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,
299 300 301 302 303
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
304 305 306 307

  Insertion functions signal an error if the current buffer is
read-only.

Karl Heuer's avatar
Karl Heuer committed
308 309 310 311 312 313
  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.

314 315 316 317 318 319 320
  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
321 322
@defun insert &rest args
This function inserts the strings and/or characters @var{args} into the
323 324 325
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
326 327 328 329 330 331 332 333 334 335
@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
336
after the inserted text.  If an overlay begins the insertion point, the
337 338
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
339 340
@end defun

341
@defun insert-char character &optional count inherit
Richard M. Stallman's avatar
Richard M. Stallman committed
342
This function inserts @var{count} instances of @var{character} into the
343 344 345
current buffer before point.  The argument @var{count} should be a
number (@code{nil} means 1), and @var{character} must be a character.
The value is @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
346

347 348 349 350
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
351 352 353
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
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
@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
text inserted is the region from @var{start} and @var{end}.  (These
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 ----------
378
We hold these truth@point{}
Richard M. Stallman's avatar
Richard M. Stallman committed
379 380 381 382 383 384
---------- Buffer: bar ----------
@end group
@end example
@end defun

  @xref{Sticky Properties}, for other insertion functions that inherit
385
text properties from the nearby text in addition to inserting it.
Richard M. Stallman's avatar
Richard M. Stallman committed
386 387
Whitespace inserted by indentation functions also inherits text
properties.
Richard M. Stallman's avatar
Richard M. Stallman committed
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

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

@deffn Command self-insert-command count
@cindex character insertion
@cindex self-insertion
405 406 407 408 409
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
410 411 412

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

Karl Heuer's avatar
Karl Heuer committed
413 414 415
This command calls @code{auto-fill-function} whenever that is
non-@code{nil} and the character inserted is a space or a newline
(@pxref{Auto Filling}).
Richard M. Stallman's avatar
Richard M. Stallman committed
416 417

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

Karl Heuer's avatar
Karl Heuer committed
422 423
This is also responsible for calling @code{blink-paren-function} when
the inserted character has close parenthesis syntax (@pxref{Blinking}).
Richard M. Stallman's avatar
Richard M. Stallman committed
424 425 426 427 428 429 430 431
@end deffn

@deffn Command newline &optional number-of-newlines 
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
432 433 434 435 436 437 438
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
439

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

Richard M. Stallman's avatar
Richard M. Stallman committed
443 444 445 446 447 448
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
449
after point down vertically so that it is on the next line directly
Richard M. Stallman's avatar
Richard M. Stallman committed
450 451 452 453 454 455 456 457
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
458 459 460 461 462 463
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
464 465 466
@end defvar

@node Deletion
Karl Heuer's avatar
Karl Heuer committed
467
@section Deleting Text
Richard M. Stallman's avatar
Richard M. Stallman committed
468 469 470 471 472

@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}).
473 474
Some deletion functions do save text in the kill ring in some special
cases.
Richard M. Stallman's avatar
Richard M. Stallman committed
475 476 477 478

  All of the deletion functions operate on the current buffer, and all
return a value of @code{nil}.

479
@deffn Command erase-buffer
Richard M. Stallman's avatar
Richard M. Stallman committed
480 481 482 483 484 485 486 487 488 489
This function deletes the entire text of the current buffer, leaving it
empty.  If the buffer is read-only, it signals a @code{buffer-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
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.
490
@end deffn
Richard M. Stallman's avatar
Richard M. Stallman committed
491 492 493

@deffn Command delete-region start end
This command deletes the text in the current buffer in the region
494 495 496
defined by @var{start} and @var{end}.  The value is @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.
Richard M. Stallman's avatar
Richard M. Stallman committed
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
@end deffn

@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

550
@defopt backward-delete-char-untabify-method
551
@tindex backward-delete-char-untabify-method
552 553 554 555 556 557 558 559
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 the whitespace characters before point
with one command, and @code{nil}, meaning do nothing special for
whitespace characters.
@end defopt

Richard M. Stallman's avatar
Richard M. Stallman committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573
@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
@cindex deleting whitespace
This function deletes all spaces and tabs around point.  It returns
@code{nil}.

In the following examples, we call @code{delete-horizontal-space} four
times, once on each line, with point between the second and third
574
characters on the line each time.
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

@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

@deffn Command delete-indentation &optional join-following-p 
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
605
instead.  The function returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
606 607 608

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
609
fill prefix before joining the lines.  @xref{Margins}.
Richard M. Stallman's avatar
Richard M. Stallman committed
610 611 612 613 614 615

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
616
@group
Richard M. Stallman's avatar
Richard M. Stallman committed
617 618 619 620
---------- Buffer: foo ----------
When in the course of human
@point{}    events, it becomes necessary
---------- Buffer: foo ----------
621
@end group
Richard M. Stallman's avatar
Richard M. Stallman committed
622 623 624 625

(delete-indentation)
     @result{} nil

626
@group
Richard M. Stallman's avatar
Richard M. Stallman committed
627 628 629
---------- Buffer: foo ----------
When in the course of human@point{} events, it becomes necessary
---------- Buffer: foo ----------
630
@end group
Richard M. Stallman's avatar
Richard M. Stallman committed
631 632 633 634 635 636 637
@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

@defun fixup-whitespace
638
This function replaces all the whitespace surrounding point with either
Richard M. Stallman's avatar
Richard M. Stallman committed
639 640 641 642 643 644 645 646 647
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
648 649
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
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

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

@deffn Command just-one-space
@comment !!SourceFile simple.el
This command replaces any spaces and tabs around point with a single
space.  It returns @code{nil}.
@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
blank lines following it.

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

697
  @dfn{Kill functions} delete text like the deletion functions, but save
Richard M. Stallman's avatar
Richard M. Stallman committed
698 699 700 701 702 703 704 705 706
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
707
commands for killing text.  When you need to delete text for internal
Richard M. Stallman's avatar
Richard M. Stallman committed
708 709 710 711 712
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
713 714 715 716 717 718
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
719 720

  Some people think this use of the word ``kill'' is unfortunate, since
721
it refers to operations that specifically @emph{do not} destroy the
Richard M. Stallman's avatar
Richard M. Stallman committed
722 723 724 725 726 727 728 729 730 731 732
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.
* Yank Commands::          Commands that access the kill ring.
733
* Low-Level Kill Ring::	   Functions and variables for kill ring access.
Richard M. Stallman's avatar
Richard M. Stallman committed
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
* Internals of Kill Ring:: Variables that hold kill-ring data.
@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
754 755 756
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.
Richard M. Stallman's avatar
Richard M. Stallman committed
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771

  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
772 773
adds it to the most recent element.  It determines automatically (using
@code{last-command}) whether the previous command was a kill command,
774
and if so appends the killed text to the most recent entry.
Richard M. Stallman's avatar
Richard M. Stallman committed
775 776 777

@deffn Command kill-region start end
This function kills the text in the region defined by @var{start} and
Karl Heuer's avatar
Karl Heuer committed
778 779
@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
780 781 782 783 784 785 786 787 788 789 790

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

@c Emacs 19 feature
If the buffer 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 all the kill commands to copy
text into the kill ring from a read-only buffer.
@end deffn

791 792 793 794 795 796
@defopt kill-read-only-ok
If this option is non-@code{nil}, @code{kill-region} does not get an
error if the buffer is read-only.  Instead, it simply returns, updating
the kill ring but not changing the buffer.
@end defopt

Richard M. Stallman's avatar
Richard M. Stallman committed
797 798
@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
799 800 801 802
the kill ring (including text properties), but does not delete the text
from the buffer.  It returns @code{nil}.  It also indicates the extent
of the text copied by moving the cursor momentarily, or by displaying a
message in the echo area.
Richard M. Stallman's avatar
Richard M. Stallman committed
803

Karl Heuer's avatar
Karl Heuer committed
804 805 806
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
807
Don't call @code{copy-region-as-kill} in Lisp programs unless you aim to
808 809 810
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
811 812 813 814 815 816 817
@end deffn

@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
818
from the kill ring.  The text properties are copied too.
Richard M. Stallman's avatar
Richard M. Stallman committed
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856

@deffn Command yank &optional arg
@cindex inserting killed text
This command inserts before point the text in the first entry in the
kill ring.  It positions the mark at the beginning of that text, and
point at the end.

If @var{arg} is a 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.

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.

@code{yank} does not alter the contents of the kill ring or rotate it.
It returns @code{nil}.
@end deffn

@deffn Command yank-pop 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.

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.

857
The return value is always @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
858 859
@end deffn

860 861
@node Low-Level Kill Ring
@subsection Low-Level Kill Ring
Richard M. Stallman's avatar
Richard M. Stallman committed
862

863 864 865 866
  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
867 868

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

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
875
returns the @var{n}th kill, counting from the current yanking pointer.
Richard M. Stallman's avatar
Richard M. Stallman committed
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907

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

@defun kill-new string
This function puts the text @var{string} into the kill ring as a new
entry at the front of the ring.  It discards the oldest entry if
appropriate.  It also invokes the value of
@code{interprogram-cut-function} (see below).
@end defun

@defun kill-append string before-p
This function appends the text @var{string} to the first entry in the
kill ring.  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
function also invokes the value of @code{interprogram-cut-function} (see
below).
@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
@code{nil}, then the first element of @code{kill-ring} is used.

908 909 910
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
911 912 913
@end defvar

@defvar interprogram-cut-function
914 915
This variable provides a way of communicating killed text to other
programs, when you are using a window system.  Its value should be
Richard M. Stallman's avatar
Richard M. Stallman committed
916 917 918 919 920
@code{nil} or a function of one argument.

If the value is a function, @code{kill-new} and @code{kill-append} call
it with the new first element of the kill ring as an argument.

921 922
The normal use of this hook is to set the window system's primary
selection from the newly killed text.  @xref{Window System Selections}.
Richard M. Stallman's avatar
Richard M. Stallman committed
923 924 925 926 927 928 929 930 931 932 933
@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
of the list. 

  The @code{kill-ring-yank-pointer} variable points to a link in the
934 935
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
936
@code{kill-ring-yank-pointer} to a different link is called
937 938 939 940
@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
941 942 943 944 945 946 947 948 949 950

  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
951 952
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
953 954 955 956 957 958 959

  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
960 961 962 963 964 965
kill-ring                  ---- kill-ring-yank-pointer
  |                       |
  |                       v
  |     --- ---          --- ---      --- ---
   --> |   |   |------> |   |   |--> |   |   |--> nil
        --- ---          --- ---      --- ---
Richard M. Stallman's avatar
Richard M. Stallman committed
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
         |                |            |            
         |                |            |            
         |                |             -->"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
981 982
This variable holds the list of killed text sequences, most recently
killed first.
Richard M. Stallman's avatar
Richard M. Stallman committed
983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
@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
value for @code{kill-ring-max} is 30.
@end defopt

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

1003 1004 1005 1006 1007 1008
  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
1009 1010 1011 1012 1013 1014 1015 1016 1017

@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
1018 1019 1020 1021 1022
@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
1023 1024 1025 1026 1027 1028

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

Richard M. Stallman's avatar
Richard M. Stallman committed
1029
@item (@var{text} . @var{position})
Richard M. Stallman's avatar
Richard M. Stallman committed
1030
This kind of element indicates how to reinsert text that was deleted.
Richard M. Stallman's avatar
Richard M. Stallman committed
1031 1032
The deleted text itself is the string @var{text}.  The place to
reinsert it is @code{(abs @var{position})}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048

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

1050 1051 1052 1053 1054 1055
@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.

Richard M. Stallman's avatar
Richard M. Stallman committed
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
@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}.

1068 1069 1070 1071 1072 1073 1074 1075 1076
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
1077 1078
change was made in some other buffer.  This is to ensure that
each command makes a boundary in each buffer where it makes changes.
1079 1080 1081 1082 1083

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
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
@end defun

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

1124 1125
@deffn Command buffer-disable-undo &optional buffer
@deffnx Command buffer-flush-undo &optional buffer
Richard M. Stallman's avatar
Richard M. Stallman committed
1126 1127 1128 1129 1130 1131 1132
@cindex disable undo
This function discards the undo list of @var{buffer}, 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} is already disabled, this function
has no effect.

1133
This function returns @code{nil}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1134 1135

The name @code{buffer-flush-undo} is not considered obsolete, but the
1136
preferred name is @code{buffer-disable-undo}.
1137
@end deffn
Richard M. Stallman's avatar
Richard M. Stallman committed
1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151

  As editing continues, undo lists get longer and longer.  To prevent
them from using up all available memory space, garbage collection trims
them back to size limits you can set.  (For this purpose, the ``size''
of an undo list measures the cons cells that make up the list, plus the
strings of deleted text.)  Two variables control the range of acceptable
sizes: @code{undo-limit} and @code{undo-strong-limit}.

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

@defvar undo-strong-limit
1152 1153 1154
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
1155
change group is never discarded no matter how big it is.
Richard M. Stallman's avatar
Richard M. Stallman committed
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
@end defvar

@node Filling
@comment  node-name,  next,  previous,  up
@section Filling
@cindex filling, explicit

  @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
Karl Heuer's avatar
Karl Heuer committed
1166 1167 1168
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.
Richard M. Stallman's avatar
Richard M. Stallman committed
1169 1170 1171 1172 1173

  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.

Karl Heuer's avatar
Karl Heuer committed
1174 1175
  Most of the commands in this section return values that are not
meaningful.  All the functions that do filling take note of the current
Karl Heuer's avatar
Karl Heuer committed
1176 1177 1178 1179 1180 1181 1182 1183 1184
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
1185 1186
(see @code{current-justification}, below).  Any other value is treated
as @code{full}.
Karl Heuer's avatar
Karl Heuer committed
1187 1188 1189

  When you call the filling functions interactively, using a prefix
argument implies the value @code{full} for @var{justify}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1190

Karl Heuer's avatar
Karl Heuer committed
1191
@deffn Command fill-paragraph justify
Richard M. Stallman's avatar
Richard M. Stallman committed
1192 1193
@cindex filling a paragraph
This command fills the paragraph at or after point.  If
Karl Heuer's avatar
Karl Heuer committed
1194
@var{justify} is non-@code{nil}, each line is justified as well.
Richard M. Stallman's avatar
Richard M. Stallman committed
1195 1196 1197 1198
It uses the ordinary paragraph motion commands to find paragraph
boundaries.  @xref{Paragraphs,,, emacs, The Emacs Manual}.
@end deffn

1199
@deffn Command fill-region start end &optional justify nosqueeze
Richard M. Stallman's avatar
Richard M. Stallman committed
1200
This command fills each of the paragraphs in the region from @var{start}
Karl Heuer's avatar
Karl Heuer committed
1201
to @var{end}.  It justifies as well if @var{justify} is
Richard M. Stallman's avatar
Richard M. Stallman committed
1202 1203
non-@code{nil}.

1204 1205
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},
1206
that means to keep filling to the end of the paragraph---or the next hard
1207 1208
newline, if @code{use-hard-newlines} is enabled (see below).

Richard M. Stallman's avatar
Richard M. Stallman committed
1209 1210 1211 1212
The variable @code{paragraph-separate} controls how to distinguish
paragraphs.  @xref{Standard Regexps}.
@end deffn

Karl Heuer's avatar
Karl Heuer committed
1213
@deffn Command fill-individual-paragraphs start end &optional justify mail-flag
Richard M. Stallman's avatar
Richard M. Stallman committed
1214 1215 1216 1217 1218 1219 1220
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,
Karl Heuer's avatar
Karl Heuer committed
1221 1222
@var{justify} and @var{mail-flag}, are optional.  If
@var{justify} is non-@code{nil}, the paragraphs are justified as
Richard M. Stallman's avatar
Richard M. Stallman committed
1223 1224 1225 1226 1227 1228 1229
well as filled.  If @var{mail-flag} is non-@code{nil}, it means the
function is operating on a mail message and therefore should not fill
the header lines.

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
1230 1231
separator lines separate paragraphs.  That mode can handle indented
paragraphs with additional indentation on the first line.
Richard M. Stallman's avatar
Richard M. Stallman committed
1232 1233 1234 1235 1236 1237 1238
@end deffn

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

1239
@deffn Command fill-region-as-paragraph start end &optional justify nosqueeze squeeze-after
1240 1241 1242 1243
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}.
Karl Heuer's avatar
Karl Heuer committed
1244 1245

In an interactive call, any prefix argument requests justification.
Richard M. Stallman's avatar
Richard M. Stallman committed
1246

1247 1248
If @var{nosqueeze} is non-@code{nil}, that means to leave whitespace
other than line breaks untouched.  If @var{squeeze-after} is
1249
non-@code{nil}, it specifies a position in the region, and means don't
1250 1251 1252 1253
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}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1254 1255
@end deffn

Karl Heuer's avatar
Karl Heuer committed
1256
@deffn Command justify-current-line how eop nosqueeze
Richard M. Stallman's avatar
Richard M. Stallman committed
1257 1258 1259
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}.
Karl Heuer's avatar
Karl Heuer committed
1260 1261 1262 1263 1264 1265 1266

The argument @var{how}, if non-@code{nil} specifies explicitly the style
of justification.  It can be @code{left}, @code{right}, @code{full},
@code{center}, or @code{none}.  If it is @code{t}, that means to do
follow specified justification style (see @code{current-justification},
below).  @code{nil} means to do full justification.

1267
If @var{eop} is non-@code{nil}, that means do left-justification if
Karl Heuer's avatar
Karl Heuer committed
1268 1269 1270 1271 1272 1273
@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.
Richard M. Stallman's avatar
Richard M. Stallman committed
1274 1275
@end deffn

Karl Heuer's avatar
Karl Heuer committed
1276 1277 1278 1279
@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
Karl Heuer's avatar
Karl Heuer committed
1280
@code{none}.  The default value is @code{left}.
Karl Heuer's avatar
Karl Heuer committed
1281 1282 1283 1284 1285 1286 1287
@end defopt

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

1288 1289 1290 1291 1292 1293
@defopt sentence-end-double-space
If this variable is non-@code{nil}, a period followed by just one space
does not count as the end of a sentence, and the filling functions
avoid breaking the line at such a place.
@end defopt

Karl Heuer's avatar
Karl Heuer committed
1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
@defvar fill-paragraph-function
This variable provides a way for major modes to override the filling of
paragraphs.  If the value is non-@code{nil}, @code{fill-paragraph} calls
this function to do the work.  If the function returns a non-@code{nil}
value, @code{fill-paragraph} assumes the job is done, and immediately
returns that value.

The usual use of this feature is to fill comments in programming
language modes.  If the function needs to fill a paragraph in the usual
way, it can do so as follows:

@example
(let ((fill-paragraph-function nil))
  (fill-paragraph arg))
@end example
@end defvar

@defvar use-hard-newlines
If this variable is non-@code{nil}, the filling functions do not delete
newlines that have the @code{hard} text property.  These ``hard
newlines'' act as paragraph separators.
@end defvar

@node Margins
@section Margins for Filling

1320
@defopt fill-prefix
1321 1322
This buffer-local variable specifies a string of text that appears at
the beginning
1323 1324 1325 1326 1327 1328
of normal text lines and should be disregarded when filling them.  Any
line that fails to start with the fill prefix is considered the start of
a paragraph; so is any line that starts with the fill prefix followed by
additional whitespace.  Lines that start with the fill prefix but no
additional whitespace are ordinary text lines that can be filled
together.  The resulting filled lines also start with the fill prefix.
Karl Heuer's avatar
Karl Heuer committed
1329 1330

The fill prefix follows the left margin whitespace, if any.
1331 1332
@end defopt

1333
@defopt fill-column
1334 1335 1336 1337
This buffer-local variable specifies the maximum width of filled lines.
Its value should be an integer, which is a number of columns.  All the
filling, justification, and centering commands are affected by this
variable, including Auto Fill mode (@pxref{Auto Filling}).
Richard M. Stallman's avatar
Richard M. Stallman committed
1338 1339 1340 1341 1342

As a practical matter, if you are writing text for other people to
read, you should set @code{fill-column} to no more than 70.  Otherwise
the line will be too long for people to read comfortably, and this can
make the text seem clumsy.
1343
@end defopt
Richard M. Stallman's avatar
Richard M. Stallman committed
1344 1345 1346 1347 1348 1349 1350 1351 1352

@defvar default-fill-column
The value of this variable is the default value for @code{fill-column} in
buffers that do not override it.  This is the same as
@code{(default-value 'fill-column)}.

The default value for @code{default-fill-column} is 70.
@end defvar

Karl Heuer's avatar
Karl Heuer committed
1353 1354 1355 1356 1357 1358 1359
@deffn Command set-left-margin from to margin
This sets the @code{left-margin} property on the text from @var{from} to
@var{to} to the value @var{margin}.  If Auto Fill mode is enabled, this
command also refills the region to fit the new margin.
@end deffn

@deffn Command set-right-margin from to margin
Karl Heuer's avatar
Karl Heuer committed
1360 1361 1362
This sets the @code{right-margin} property on the text from @var{from}
to @var{to} to the value @var{margin}.  If Auto Fill mode is enabled,
this command also refills the region to fit the new margin.
Karl Heuer's avatar
Karl Heuer committed
1363 1364 1365 1366 1367 1368
@end deffn

@defun current-left-margin
This function returns the proper left margin value to use for filling
the text around point.  The value is the sum of the @code{left-margin}
property of the character at the start of the current line (or zero if
Karl Heuer's avatar
Karl Heuer committed
1369
none), and the value of the variable @code{left-margin}.
Karl Heuer's avatar
Karl Heuer committed
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
@end defun

@defun current-fill-column
This function returns the proper fill column value to use for filling
the text around point.  The value is the value of the @code{fill-column}
variable, minus the value of the @code{right-margin} property of the
character after point.
@end defun

@deffn Command move-to-left-margin &optional n force
This function moves point to the left margin of the current line.  The
column moved to is determined by calling the function
Karl Heuer's avatar
Karl Heuer committed
1382
@code{current-left-margin}.  If the argument @var{n} is non-@code{nil},
Karl Heuer's avatar
Karl Heuer committed
1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
@code{move-to-left-margin} moves forward @var{n}@minus{}1 lines first.

If @var{force} is non-@code{nil}, that says to fix the line's
indentation if that doesn't match the left margin value.
@end deffn

@defun delete-to-left-margin from to
This function removes left margin indentation from the text
between @var{from} and @var{to}.  The amount of indentation
to delete is determined by calling @code{current-left-margin}.
In no case does this function delete non-whitespace.
@end defun

Karl Heuer's avatar
Karl Heuer committed
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405
@defun indent-to-left-margin
This is the default @code{indent-line-function}, used in Fundamental
mode, Text mode, etc.  Its effect is to adjust the indentation at the
beginning of the current line to the value specified by the variable
@code{left-margin}.  This may involve either inserting or deleting
whitespace.
@end defun

@defvar left-margin
This variable specifies the base left margin column.  In Fundamental
1406
mode, @kbd{C-j} indents to this column.  This variable automatically
Karl Heuer's avatar
Karl Heuer committed
1407 1408 1409
becomes buffer-local when set in any fashion.
@end defvar

1410
@defvar fill-nobreak-predicate
1411
@tindex fill-nobreak-predicate
1412 1413 1414 1415 1416 1417 1418
This variable gives major modes a way to specify not to break a line at
certain places.  Its value should be a function.  This function is
called during filling, with no arguments and with point located at the
place where a break is being considered.  If the function returns
non-@code{nil}, then the line won't be broken there.
@end defvar

1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
@node Adaptive Fill
@section Adaptive Fill Mode
@cindex Adaptive Fill mode

  Adaptive Fill mode chooses a fill prefix automatically from the text
in each paragraph being filled.

@defopt adaptive-fill-mode
Adaptive Fill mode is enabled when this variable is non-@code{nil}.
It is @code{t} by default.
@end defopt

@defun fill-context-prefix from to
This function implements the heart of Adaptive Fill mode; it chooses a
fill prefix based on the text between @var{from} and @var{to}.  It does
this by looking at the first two lines of the paragraph, based on the
variables described below.
@end defun

@defopt adaptive-fill-regexp
This variable holds a regular expression to control Adaptive Fill mode.
1440 1441 1442
Adaptive Fill mode matches this regular expression against the text
starting after the left margin whitespace (if any) on a line; the
characters it matches are that line's candidate for the fill prefix.
1443 1444 1445
@end defopt

@defopt adaptive-fill-first-line-regexp
1446 1447 1448 1449
In a one-line paragraph, if the candidate fill prefix matches this
regular expression, or if it matches @code{comment-start-skip}, then it
is used---otherwise, spaces amounting to the same width are used
instead.
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463

However, the fill prefix is never taken from a one-line paragraph
if it would act as a paragraph starter on subsequent lines.
@end defopt

@defopt adaptive-fill-function
You can specify more complex ways of choosing a fill prefix
automatically by setting this variable to a function.  The function is
called when @code{adaptive-fill-regexp} does not match, with point after
the left margin of a line, and it should return the appropriate fill
prefix based on that line.  If it returns @code{nil}, that means it sees
no fill prefix in that line.
@end defopt

Richard M. Stallman's avatar
Richard M. Stallman committed
1464 1465 1466 1467 1468 1469
@node Auto Filling
@comment  node-name,  next,  previous,  up
@section Auto Filling
@cindex filling, automatic
@cindex Auto Fill mode

1470
  Auto Fill mode is a minor mode that fills lines automatically as text
1471
is inserted.  This section describes the hook used by Auto Fill mode.
1472 1473
For a description of functions that you can call explicitly to fill and
justify existing text, see @ref{Filling}.
Richard M. Stallman's avatar
Richard M. Stallman committed
1474

Karl Heuer's avatar
Karl Heuer committed
1475 1476 1477
  Auto Fill mode also enables the functions that change the margins and
justification style to refill portions of the text.  @xref{Margins}.

Richard M. Stallman's avatar
Richard M. Stallman committed
1478
@defvar auto-fill-function
Karl Heuer's avatar
Karl Heuer committed
1479 1480 1481
The value of this variable should be a function (of no arguments) to be
called after self-inserting a space or a newline.  It may be @code{nil},
in which case nothing special is done in that case.
Richard M. Stallman's avatar
Richard M. Stallman committed
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493

The value of @code{auto-fill-function} is @code{do-auto-fill} when
Auto-Fill mode is enabled.  That is a function whose sole purpose is to
implement the usual strategy for breaking a line.

@quotation
In older Emacs versions, this variable was named @code{auto-fill-hook},
but since it is not called with the standard convention for hooks, it
was renamed to @code{auto-fill-function} in version 19.
@end quotation
@end defvar

1494 1495 1496
@defvar normal-auto-fill-function
This variable specifies the function to use for
@code{auto-fill-function}, if and when Auto Fill is turned on.  Major
1497 1498
modes can set buffer-local values for this variable to alter how Auto
Fill works.
1499 1500
@end defvar

Richard M. Stallman's avatar
Richard M. Stallman committed
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
@node Sorting