   This version is newer than the second printed edition of the GNU
Emacs Lisp Reference Manual.  It corresponds to Emacs Version 19.19.

   Published by the Free Software Foundation 675 Massachusetts Avenue
Cambridge, MA 02139 USA

   Copyright (C) 1990, 1991, 1992, 1993 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Foundation.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled "GNU General Public License" is included
exactly as in the original, and provided that the entire resulting
derived work is distributed under the terms of a permission notice
identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled "GNU General Public License"
may be included in a translation approved by the Free Software
Foundation instead of in the original English.

Insertion
=========

   Insertion takes place at point.  Markers pointing at positions after
the insertion point are relocated with the surrounding text (see
Markers.).  When a marker points at the place of insertion, it is
normally not relocated, so that it points to the beginning of the
inserted text; however, when `insert-before-markers' is used, all such
markers are relocated to point after the inserted text.

   Point may end up either before or after inserted text, depending on
the function used.  If point is left after the inserted text, we speak
of insertion "before point".

   If a string with non-`nil' extent data is inserted, the remembered
extents will also be inserted.  See Duplicable Extents.

   Each of these functions signals an error if the current buffer is
read-only.

 - Function: insert &rest ARGS
     This function inserts the strings and/or characters ARGS into the
     current buffer, at point, moving point forward.  An error is
     signaled unless all ARGS are either strings or characters.  The
     value is `nil'.

 - Function: insert-before-markers &rest ARGS
     This function inserts the strings and/or characters ARGS into the
     current buffer, at point, moving point forward.  An error is
     signaled unless all ARGS are either strings or characters.  The
     value is `nil'.

     This function is unlike the other insertion functions in that a
     marker whose position initially equals point is relocated to come
     after the newly inserted text.

 - Function: insert-char CHARACTER COUNT
     This function inserts COUNT instances of CHARACTER into the
     current buffer before point.  COUNT must be a number, and
     CHARACTER must be a character.  The value is `nil'.

 - Function: insert-buffer-substring FROM-BUFFER-OR-NAME &optional
          START END
     This function inserts a substring of the contents of buffer
     FROM-BUFFER-OR-NAME (which must already exist) into the current
     buffer before point.  The text inserted consists of the characters
     in the region defined by START and END (These arguments default to
     the beginning and end of the accessible portion of that buffer).
     The function returns `nil'.

     In this example, the form is executed with buffer `bar' as the
     current buffer.  We assume that buffer `bar' is initially empty.

          ---------- Buffer: foo ----------
          We hold these truths to be self-evident, that all
          ---------- Buffer: foo ----------

          (insert-buffer-substring "foo" 1 20)
               => nil

          ---------- Buffer: bar ----------
          We hold these truth
          ---------- Buffer: bar ----------

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.

 - Command: insert-buffer FROM-BUFFER-OR-NAME
     This function inserts the entire contents of FROM-BUFFER-OR-NAME
     (which must exist) into the current buffer after point.  It leaves
     the mark after the inserted text.  The value is `nil'.

 - Command: self-insert-command COUNT
     This function inserts the last character typed COUNT times and
     returns `nil'.  Most printing characters are bound to this
     command.  In routine use, `self-insert-command' is the most
     frequently called function in Emacs, but programs rarely use it
     except to install it on a keymap.

     In an interactive call, COUNT is the numeric prefix argument.

     This function calls `auto-fill-function' if the current column
     number is greater than the value of `fill-column' and the character
     inserted is a space (see Auto Filling.).

     This function performs abbrev expansion if Abbrev mode is enabled
     and the inserted character does not have word-constituent syntax.
     (see Abbrevs, and Syntax Class Table.)

     This function is also responsible for calling
     `blink-paren-function' when the inserted character has close
     parenthesis syntax (see Blinking.).

 - Command: newline &optional NUMBER-OF-NEWLINES
     This function inserts newlines into the current buffer before
     point.  If NUMBER-OF-NEWLINES is supplied, that many newline
     characters are inserted.

     In Auto Fill mode, `newline' can break the preceding line if
     NUMBER-OF-NEWLINES is not supplied.  When this happens, it
     actually inserts two newlines at different places: one at point,
     and another earlier in the line.  `newline' does not auto-fill if
     NUMBER-OF-NEWLINES is non-`nil'.

     The value returned is `nil'.  In an interactive call, COUNT is the
     numeric prefix argument.

 - Command: split-line
     This function splits the current line, moving the portion of the
     line after point down vertically, so that it is on the next line
     directly below where it was before.  Whitespace is inserted as
     needed at the beginning of the lower line, using the `indent-to'
     function.  `split-line' returns the position of point.

     Programs hardly ever use this function.

 - Variable: overwrite-mode
     This variable controls whether overwrite mode is in effect: a
     non-`nil' value enables the mode.  It is automatically made
     buffer-local when set in any fashion.

Deletion of Text
================

   All of the deletion functions operate on the current buffer, and all
return a value of `nil'.  In addition to these functions, you can also
delete text using the "kill" functions that save it in the kill ring;
some of these functions save text in the kill ring in some cases but
not in the usual case.  See The Kill Ring.

 - Function: erase-buffer
     This function deletes the entire text of the current buffer,
     leaving it empty.  If the buffer is read-only, it signals a
     `buffer-read-only' error.  Otherwise, it deletes the text without
     asking for any confirmation.  The value is always `nil'.

     Normally, deleting a large amount of text from a buffer inhibits
     further auto-saving of that buffer "because it has shrunk".
     However, `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.

 - Command: delete-region START END
     This function deletes the text in the current buffer in the region
     defined by START and END.  The value is `nil'.

 - Command: delete-char COUNT &optional KILLP
     This function deletes COUNT characters directly after point, or
     before point if COUNT is negative.  If KILLP is non-`nil', then it
     saves the deleted characters in the kill ring.

     In an interactive call, COUNT is the numeric prefix argument, and
     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 `nil'.

 - Command: delete-backward-char COUNT &optional KILLP
     This function deletes COUNT characters directly before point, or
     after point if COUNT is negative.  If KILLP is non-`nil', then it
     saves the deleted characters in the kill ring.

     In an interactive call, COUNT is the numeric prefix argument, and
     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 `nil'.

 - Command: backward-delete-char-untabify COUNT &optional KILLP
     This function deletes 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 KILLP is non-`nil', then the command saves the deleted
     characters in the kill ring.

     If COUNT is negative, then tabs are not changed to spaces, and the
     characters are deleted by calling `delete-backward-char' with
     COUNT.

     In an interactive call, COUNT is the numeric prefix argument, and
     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 `nil'.

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.

 - Command: delete-horizontal-space
     This function deletes all spaces and tabs around point.  It returns
     `nil'.

     In the following examples, assume that `delete-horizontal-space' is
     called four times, once on each line, with point between the
     second and third characters on the line.

          ---------- Buffer: foo ----------
          I -!-thought
          I -!-     thought
          We-!- thought
          Yo-!-u thought
          ---------- Buffer: foo ----------

          (delete-horizontal-space)   ; Four times.
               => nil

          ---------- Buffer: foo ----------
          Ithought
          Ithought
          Wethought
          You thought
          ---------- Buffer: foo ----------

 - 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 JOIN-FOLLOWING-P is non-`nil',
     `delete-indentation' joins this line to the following line
     instead.  The value is `nil'.

     If there is a fill prefix, and the second of the lines being joined
     starts with the prefix, then `delete-indentation' deletes the fill
     prefix before joining the lines.

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

          ---------- Buffer: foo ----------
          When in the course of human
          -!-    events, it becomes necessary
          ---------- Buffer: foo ----------

          (delete-indentation)
               => nil

          ---------- Buffer: foo ----------
          When in the course of human-!- events, it becomes necessary
          ---------- Buffer: foo ----------

     After the lines are joined, the function `fixup-whitespace' is
     responsible for deciding whether to leave a space at the junction.

 - Function: fixup-whitespace
     This function replaces white space between the objects on either
     side of point with either one space or no space as appropriate.
     It returns `nil'.

     The appropriate amount of space is none at the beginning or end of
     the line.  Otherwise, it is one space except when point is before a
     character with close parenthesis syntax or after a character with
     open parenthesis or expression-prefix syntax.  See Syntax Class Table.

     In the example below, when `fixup-whitespace' is called the first
     time, point is before the word `spaces' in the first line.  It is
     located directly after the `(' for the second invocation.

          ---------- Buffer: foo ----------
          This has too many     -!-spaces
          This has too many spaces at the start of (-!-   this list)
          ---------- Buffer: foo ----------

          (fixup-whitespace)
               => nil
          (fixup-whitespace)
               => nil

          ---------- Buffer: foo ----------
          This has too many spaces
          This has too many spaces at the start of (this list)
          ---------- Buffer: foo ----------

 - Command: just-one-space
     This command replaces any spaces and tabs around point with a
     single space.  It returns `nil'.

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

     `delete-blank-lines' returns `nil'.

The Kill Ring
=============

   "Kill" functions delete text like the deletion functions, but save
it so that the user can reinsert it by "yanking".  Most of these
functions have `kill-' in their name.  By contrast, the functions whose
names start with `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.  When deleting text for internal purposes
within a Lisp function, you should normally use deletion functions, so
as not to disturb the kill ring contents.  See Deletion.

   Emacs saves the last several batches of killed text in a list.  We
call it the "kill ring" because, in yanking, the elements are
considered to be in a cyclic order.  The list is kept in the variable
`kill-ring', and can be operated on with the usual functions for lists;
there are also specialized functions, described in this section, which
treat it as a ring.

   Some people think use of the word "kill" in Emacs is unfortunate,
since it refers to processes which specifically *do not* destroy the
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 now.

Kill Ring Concepts
------------------

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

     ("some text" "a different piece of text" "yet more text")

   New entries in the kill ring go at the front of the list.  When the
list reaches `kill-ring-max' entries in length, adding a new entry
automatically deletes the last entry.

   When kill commands are interwoven with other commands, the killed
portions of text are put into separate entries in the kill ring.  But
when two or more kill commands are executed in succession, the text they
kill forms a single entry, because the second and subsequent consecutive
kill commands append to the entry made by the first one.

   The user can reinsert or "yank" text from any element in the kill
ring.  One of the entries in the ring is considered the "front", and
the simplest yank command yanks that entry.  Other yank commands
"rotate" the ring by designating other entries as the "front".

Functions for Killing
---------------------

   `kill-region' is the usual subroutine for killing text.  Any command
that calls this function is a "kill command" (and should probably have
`kill' in its name).  `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 uses the `last-command' variable to keep track of whether
the previous was a kill command, and in such cases appends the killed
text to the most recent entry.

 - Command: kill-region START END
     This function kills the text in the region defined by START and
     END.  The text is deleted but saved in the kill ring.  The value
     is always `nil'.

     In an interactive call, START and END are point and the mark.

     If the buffer is read-only, `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.

 - Command: copy-region-as-kill START END
     This function saves the region defined by START and END on the
     kill ring, but does not delete the text from the buffer.  It
     returns `nil'.  It also indicates the extent of the text copied by
     moving the cursor momentarily, or by displaying a message in the
     echo area.

     Don't use this command in Lisp programs; use `kill-new' or
     `kill-append' instead.  See Low Level Kill Ring.

     In an interactive call, START and END are point and the mark.

Functions for Yanking
---------------------

 - Command: yank &optional ARG
     This function inserts the text in the first entry in the kill ring
     directly before point.  After the yank, the mark is positioned at
     the beginning and point is positioned after the end of the
     inserted text.

     If ARG is a list (which occurs interactively when the user types
     `C-u' with no digits), then `yank' inserts the text as described
     above, but puts point before the yanked text and puts the mark
     after it.  If ARG is a number, then `yank' inserts the ARGth most
     recently killed text.

     `yank' does not alter the contents of the kill ring or rotate it.
     It returns `nil'.

 - Command: yank-pop ARG
     This function replaces the just-yanked text with another batch of
     killed text--another element of the kill ring.

     This command is allowed only immediately after a `yank' or a
     `yank-pop'.  At such a time, the region contains text that was just
     inserted by the previous `yank'.  `yank-pop' deletes that text and
     inserts in its place a different stretch of killed text.  The text
     that is deleted is not inserted into the kill ring, since it is
     already in the kill ring somewhere.

     If ARG is `nil', then the existing region contents are replaced
     with the previous element of the kill ring.  If ARG is numeric,
     then the ARGth previous kill is the replacement.  If 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 value is always `nil'.

Low Level Kill Ring
-------------------

   These functions and variables provide access to the kill ring at a
lower level, but still convenient for use in Lisp programs.  They take
care of interaction with X Window selections.  They do not exist in
Emacs version 18.

 - Function: current-kill N &optional DO-NOT-MOVE
     The function `current-kill' rotates the yanking pointer in the
     kill ring by N places, and returns the text at that place in the
     ring.

     If the optional second argument DO-NOT-MOVE is non-`nil', then
     `current-kill' doesn't alter the yanking pointer; it just returns
     the Nth kill forward from the current yanking pointer.

     If N is zero, indicating a request for the latest kill,
     `current-kill' calls the value of `interprogram-paste-function'
     (documented below) before consulting the kill ring.

 - Function: kill-new STRING
     This function puts the text STRING into the kill ring as a new
     entry at the front of the ring.  It also discards the oldest entry
     if appropriate.  It also invokes the value of
     `interprogram-cut-function' (see below).

 - Function: kill-append STRING BEFORE-P
     This function appends the text STRING to the first entry in the
     kill ring.  Normally STRING goes at the end of the entry, but if
     BEFORE-P is non-`nil', it goes at the beginning.  This function
     also invokes the value of `interprogram-cut-function' (see below).

 - Variable: 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
     `nil' or a function of no arguments.

     If the value is a function, it is called when the "most recent
     kill" value is called for.  If the function returns a non-`nil'
     values, then that value is used as the "most recent kill".  If it
     returns `nil', then the first element of the kill ring is used.

 - Variable: interprogram-cut-function
     This variable provides a way of communicating killed text to and
     from other programs, when you are using a window system.  Its
     value should be `nil' or a function of one argument.

     If the value is a function, it is called whenever the "most recent
     kill" is changed, with the new string of killed text as an
     argument.

Internals of the Kill Ring
--------------------------

   The variable `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 `kill-ring-yank-pointer' variable points to a link in the kill
ring list, whose CAR is the text that "yank" functions should copy.
Moving `kill-ring-yank-pointer' to a different link is called "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.  Rotating the ring does not change the value
of `kill-ring'.

   Both `kill-ring' and `kill-ring-yank-pointer' are Lisp variables
whose values are normally lists.  The word "pointer" in the name of the
`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 `kill-ring-yank-pointer' is always `eq' to one of the
links in the kill ring list.  The element it identifies is the CAR of
that link.  Commands which change the text in the kill ring also set
this variable from `kill-ring'.  The effect is to rotate the ring so
that the newly killed text is at front.

   Here is a diagram that shows the variable `kill-ring-yank-pointer'
pointing to the second entry in the kill ring `("some text" "a
different piece of text" "yet more text")'.

     kill-ring       kill-ring-yank-pointer
       |               |
       |     ___ ___    --->  ___ ___      ___ ___
        --> |___|___|------> |___|___|--> |___|___|--> nil
              |                |            |
              |                |            |
              |                |             -->"yet more text"
              |                |
              |                 --> "a different piece of text"
              |
               --> "some text"

This circumstance might occur after `C-y' (`yank') immediately followed
by `M-y' (`yank-pop').

 - Variable: kill-ring
     List of killed text sequences, most recently killed first.

 - Variable: 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 sublist of the value of `kill-ring', and its CAR is the kill
     string that `C-y' should yank.

 - User Option: 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 `kill-ring-max' is 30.

Undo
====

   Most buffers have an "undo list" which records all changes made to
the buffer's text so that they can be undone.  (The buffers which don't
have one are usually special-purpose buffers for which Emacs assumes
that undoing is not useful.)  All the primitives which modify the text
in the buffer automatically add elements to the front of the undo list,
which you can find in the variable `buffer-undo-list'.

 - Variable: buffer-undo-list
     This variable's value is the undo list of the current buffer.  A
     value of `t' disables the recording of undo information.

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

`INTEGER'
     This kind of element records a previous value of point.  Ordinary
     cursor motion does not get any sort of undo record, but these
     entries are used to record where point was before a deletion.

`(BEG . END)'
     This kind of element indicates how to delete text that was
     inserted.  Upon insertion, the text occupied the range BEG-END in
     the buffer.

`(POS . DELETED)'
     This kind of element indicates how to reinsert text that was
     deleted.  The deleted text itself is the string DELETED.  The
     place to reinsert it is POS.

`(t HIGH . LOW)'
     This kind of element indicates that an unmodified buffer became
     modified.  The elements HIGH and LOW are two integers, each
     recording 16 bits of the visited file's modification time as of
     when it was previously visited or saved.  `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.

`(nil PROPERTY VALUE BEG . END)'
     This kind of element records a change in a text property.  Here's
     how you might undo the change:

          (put-text-property BEG END
                             PROPERTY VALUE)

`nil'
     This element is a boundary.  The function `undo-boundary' adds
     these elements.  The elements between two boundaries are called a
     "change group"; normally, each change group corresponds to one
     keyboard command, and undo commands normally undo an entire group
     as a unit.

 - Function: 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 `nil'.

     The editor command loop automatically creates an undo boundary
     between keystroke commands.  Thus, each undo normally undoes the
     effects of one command.  Calling this function explicitly is
     useful for splitting the effects of a command into more than one
     unit.  For example, `query-replace' calls this function after each
     replacement so that the user can undo individual replacements one
     by one.

 - Function: primitive-undo COUNT LIST
     This is the basic function for undoing elements of an undo list.
     It undoes the first COUNT elements of LIST, returning the rest of
     LIST.  You could write this function in Lisp, but it is convenient
     to have it in C.

     `primitive-undo' adds elements to the buffer's undo list.  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 never get into the saved value, so they don't cause any
     trouble.

Maintaining Undo Lists
======================

   This section describes how to enable and disable undo information for
a given buffer.  It also explains how data from the undo list is
discarded 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
`buffer-undo-list' yourself.

 - Command: buffer-enable-undo &optional BUFFER-OR-NAME
     This function enables recording undo information for buffer
     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 `nil'.

     In an interactive call, BUFFER-OR-NAME is the current buffer.  You
     cannot specify any other buffer.

 - Function: buffer-disable-undo BUFFER
 - Function: buffer-flush-undo BUFFER
     This function discards the undo list of 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 BUFFER is already disabled, this
     function has no effect.

     This function returns `nil'.  It cannot be called interactively.

     The name `buffer-flush-undo' is not considered obsolete, but the
     preferred name `buffer-disable-undo' was not provided in Emacs
     versions 18 and earlier.

   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: `undo-limit' and `undo-strong-limit'.

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

 - Variable: undo-strong-limit
     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 subsequent changes).  There is one exception:
     garbage collection always keeps the very last change group no
     matter how big it is.

Filling
=======

   "Filling" means adjusting the lengths of lines (by moving words
between them) so that they are nearly (but no greater than) a specified
maximum width.  Additionally, lines can be "justified", which means
that spaces are inserted between words to make the line exactly the
specified width.  The width is controlled by the variable
`fill-column'.  For ease of reading, lines should be no longer than 70
or so columns.

   You can use Auto Fill mode (see 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 functions in this section return values that are not
meaningful.

 - Command: fill-paragraph JUSTIFY-FLAG
     This function fills the paragraph at or after point.  If
     JUSTIFY-FLAG is non-`nil', each line is justified as well.  It
     uses the ordinary paragraph motion commands to find paragraph
     boundaries.

 - Command: fill-region START END &optional JUSTIFY-FLAG
     This function fills each of the paragraphs in the region from
     START to END.  It justifies as well if JUSTIFY-FLAG is non-`nil'.
     (In an interactive call, this is true if there is a prefix
     argument.)

     The variable `paragraph-separate' controls how to distinguish
     paragraphs.

 - Command: fill-individual-paragraphs START END &optional JUSTIFY-FLAG
          MAIL-FLAG
     This function fills each paragraph in the region according to its
     individual fill prefix.  Thus, if the lines of a paragraph are
     indented with spaces, the filled paragraph will continue to be
     indented in the same fashion.

     The first two arguments, START and END, are the beginning and end
     of the region that will be filled.  The third and fourth
     arguments, JUSTIFY-FLAG and MAIL-FLAG, are optional.  If
     JUSTIFY-FLAG is non-`nil', the paragraphs are justified as well as
     filled.  If MAIL-FLAG is non-`nil', the function is told that it
     is operating on a mail message and therefore should not fill the
     header lines.

     Ordinarily, `fill-individual-paragraphs' regards each change in
     indentation as starting a new paragraph.  If
     `fill-individual-varying-indent' is non-`nil', then only separator
     lines separate paragraphs.  That mode can handle paragraphs with
     extra indentation on the first line.

 - User Option: fill-individual-varying-indent
     This variable alters the action of `fill-individual-paragraphs' as
     described above.

 - Command: fill-region-as-paragraph START END &optional JUSTIFY-FLAG
     This function considers a region of text as a 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 JUSTIFY-FLAG is non-`nil'.  In an interactive
     call, any prefix argument requests justification.

     In Adaptive Fill mode, which is enabled by default,
     `fill-region-as-paragraph' on an indented paragraph when there is
     no fill prefix uses the indentation of the second line of the
     paragraph as the fill prefix.

 - Command: justify-current-line
     This function inserts spaces between the words of the current line
     so that the line ends exactly at `fill-column'.  It returns `nil'.

 - User Option: fill-column
     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 (see
     Auto Filling.).

     As a practical matter, if you are writing text for other people to
     read, you should set `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.

 - Variable: default-fill-column
     The value of this variable is the default value for `fill-column'
     in buffers that do not override it.  This is the same as
     `(default-value 'fill-column)'.

     The default value for `default-fill-column' is 70.

Auto Filling
============

   "Filling" breaks text into lines that are no more than a specified
number of columns wide.  Filled lines end between words, and therefore
may have to be shorter than the maximum width.

   Auto Fill mode is a minor mode in which Emacs fills lines
automatically as text as inserted.  This section describes the hook and
the two variables used by Auto Fill mode.  For a description of
functions that you can call manually to fill and justify text, see
Filling.

 - Variable: auto-fill-function
     The value of this variable should be a function (of no arguments)
     to be called after self-inserting a space at a column beyond
     `fill-column'.  It may be `nil', in which case nothing special is
     done.

     The default value for `auto-fill-function' is `do-auto-fill', a
     function whose sole purpose is to implement the usual strategy for
     breaking a line.

          In older Emacs versions, this variable was named
          `auto-fill-hook', but since it is not called with the
          standard convention for hooks, it was renamed to
          `auto-fill-function' in version 19.

Sorting Text
============

   The sorting commands described in this section all rearrange text in
a buffer.  This is in contrast to the function `sort', which rearranges
the order of the elements of a list (see Rearrangement.).  The
values returned by these commands are not meaningful.

 - Command: sort-regexp-fields REVERSE RECORD-REGEXP KEY-REGEXP START
          END
     This command sorts the region between START and END alphabetically
     as specified by RECORD-REGEXP and KEY-REGEXP.  If REVERSE is a
     negative integer, then sorting is in reverse order.

     Alphabetical sorting means that two sort keys are compared by
     comparing the first characters of each, the second characters of
     each, and so on.  If a mismatch is found, it means that the sort
     keys are unequal; the sort key whose character is less at the
     point of first mismatch is the lesser sort key.  The individual
     characters are compared according to their numerical values.
     Since Emacs uses the ASCII character set, the ordering in that set
     determines alphabetical order.

     The value of the RECORD-REGEXP argument specifies the textual
     units or "records" that should be sorted.  At the end of each
     record, a search is done for this regular expression, and the text
     that matches it is the next record.  For example, the regular
     expression `^.+$', which matches lines with at least one character
     besides a newline, would make each such line into a sort record.
     See Regular Expressions, for a description of the syntax and
     meaning of regular expressions.

     The value of the KEY-REGEXP argument specifies what part of each
     record is to be compared against the other records.  The
     KEY-REGEXP could match the whole record, or only a part.  In the
     latter case, the rest of the record has no effect on the sorted
     order of records, but it is carried along when the record moves to
     its new position.

     The KEY-REGEXP argument can refer to the text matched by a
     subexpression of RECORD-REGEXP, or it can be a regular expression
     on its own.

     If KEY-REGEXP is:

    `\DIGIT'
          then the text matched by the DIGITth `\(...\)' parenthesis
          grouping in RECORD-REGEXP is used for sorting.

    `\&'
          then the whole record is used for sorting.

    a regular expression
          then the function searches for a match for the regular
          expression within the record.  If such a match is found, it
          is used for sorting.  If a match for KEY-REGEXP is not found
          within a record then that record is ignored, which means its
          position in the buffer is not changed.  (The other records
          may move around it.)

     For example, if you plan to sort all the lines in the region by the
     first word on each line starting with the letter `f', you should
     set RECORD-REGEXP to `^.*$' and set KEY-REGEXP to `\<f\w*\>'.  The
     resulting expression looks like this:

          (sort-regexp-fields nil "^.*$" "\\<f\\w*\\>"
                              (region-beginning)
                              (region-end))

     If you call `sort-regexp-fields' interactively, you are prompted
     for RECORD-REGEXP and KEY-REGEXP in the minibuffer.

 - Command: sort-subr REVERSE NEXTRECFUN ENDRECFUN &optional
          STARTKEYFUN ENDKEYFUN
     This command is the general text sorting routine that divides a
     buffer into records and sorts them.  The functions `sort-lines',
     `sort-paragraphs', `sort-pages', `sort-fields',
     `sort-regexp-fields' and `sort-numeric-fields' all use `sort-subr'.

     To understand how `sort-subr' works, consider the whole accessible
     portion of the buffer as being divided into disjoint pieces called
     "sort records".  A portion of each sort record (perhaps all of it)
     is designated as the sort key.  The records are rearranged in the
     buffer in order by their sort keys.  The records may or may not be
     contiguous.

     Usually, the records are rearranged in order of ascending sort key.
     If the first argument to the `sort-subr' function, REVERSE, is
     non-`nil', the sort records are rearranged in order of descending
     sort key.

     The next four arguments to `sort-subr' are functions that are
     called to move point across a sort record.  They are called many
     times from within `sort-subr'.

       1. NEXTRECFUN is called with point at the end of a record.  This
          function moves point to the start of the next record.  The
          first record is assumed to start at the position of point
          when `sort-subr' is called.  (Therefore, you should usually
          move point to the beginning of the buffer before calling
          `sort-subr'.)

          This function can indicate there are no more sort records by
          leaving point at the end of the buffer.

       2. ENDRECFUN is called with point within a record.  It moves
          point to the end of the record.

       3. STARTKEYFUN is called to move point from the start of a
          record to the start of the sort key.  This argument is
          optional.  If supplied, the function should either return a
          non-`nil' value to be used as the sort key, or return `nil'
          to indicate that the sort key is in the buffer starting at
          point.  In the latter case, ENDKEYFUN is called to find the
          end of the sort key.

       4. ENDKEYFUN is called to move point from the start of the sort
          key to the end of the sort key.  This argument is optional.
          If STARTKEYFUN returns `nil' and this argument is omitted (or
          `nil'), then the sort key extends to the end of the record.
          There is no need for ENDKEYFUN if STARTKEYFUN returns a
          non-`nil' value.

     As an example of `sort-subr', here is the complete function
     definition for `sort-lines':

          ;; Note that the first two lines of doc string
          ;; are effectively one line when viewed by a user.
          (defun sort-lines (reverse beg end)
            "Sort lines in region alphabetically;\
           argument means descending order.
          Called from a program, there are three arguments:
          REVERSE (non-nil means reverse order),
          and BEG and END (the region to sort)."
            (interactive "P\nr")
            (save-restriction
              (narrow-to-region beg end)
              (goto-char (point-min))
              (sort-subr reverse
                         'forward-line
                         'end-of-line)))

     Here `forward-line' moves point to the start of the next record,
     and `end-of-line' moves point to the end of record.  We do not pass
     the arguments STARTKEYFUN and ENDKEYFUN, because the entire record
     is used as the sort key.

     The `sort-paragraphs' function is very much the same, except that
     its `sort-subr' call looks like this:

          (sort-subr reverse
                     (function
                      (lambda ()
                        (skip-chars-forward "\n \t\f")))
                     'forward-paragraph)

 - Command: sort-lines REVERSE START END
     This command sorts lines in the region between START and END
     alphabetically.  If REVERSE is non-`nil', the sort is in reverse
     order.

 - Command: sort-paragraphs REVERSE START END
     This command sorts paragraphs in the region between START and END
     alphabetically.  If REVERSE is non-`nil', the sort is in reverse
     order.

 - Command: sort-pages REVERSE START END
     This command sorts pages in the region between START and END
     alphabetically.  If REVERSE is non-`nil', the sort is in reverse
     order.

 - Command: sort-fields FIELD START END
     This command sorts lines in the region between START and END,
     comparing them alphabetically by the FIELDth field of each line.
     Fields are separated by whitespace and numbered starting from 1.
     If FIELD is negative, sorting is by the -FIELDth field from the
     end of the line.  This command is useful for sorting tables.

 - Command: sort-numeric-fields FIELD START END
     This command sorts lines in the region between START and END,
     comparing them numerically by the FIELDth field of each line.
     Fields are separated by whitespace and numbered starting from 1.
     The specified field must contain a number in each line of the
     region.  If FIELD is negative, sorting is by the -FIELDth field
     from the end of the line.  This command is useful for sorting
     tables.

 - Command: sort-columns REVERSE &optional BEG END
     This command sorts the lines in the region between BEG and END,
     comparing them alphabetically by a certain range of columns.  The
     column positions of BEG and END bound the range of columns to sort
     on.

     If REVERSE is non-`nil', the sort is in reverse order.

     One unusual thing about this command is that the entire line
     containing position BEG, and the entire line containing position
     END, are included in the region sorted.

     Note that `sort-columns' uses the `sort' utility program, and so
     cannot work properly on text containing tab characters.  Use `M-x
     `untabify'' to convert tabs to spaces before sorting.

     The `sort-columns' function did not work on VMS prior to Emacs 19.

Indentation
===========

   The indentation functions are used to examine, move to, and change
whitespace that is at the beginning of a line.  Some of the functions
can also change whitespace elsewhere on a line.  Indentation always
counts from zero at the left margin.

Indentation Primitives
----------------------

   This section describes the primitive functions used to count and
insert indentation.  The functions in the following sections use these
primitives.

 - Function: current-indentation
     This function returns the indentation of the current line, which is
     the horizontal position of the first nonblank character.  If the
     contents are entirely blank, then this is the horizontal position
     of the end of the line.

 - Command: indent-to COLUMN &optional MINIMUM
     This function indents from point with tabs and spaces until COLUMN
     is reached.  If MINIMUM is specified and non-`nil', then at least
     that many spaces are inserted even if this requires going beyond
     COLUMN.  The value is the column at which the inserted indentation
     ends.

 - User Option: indent-tabs-mode
     If this variable is non-`nil', indentation functions can insert
     tabs as well as spaces.  Otherwise, they insert only spaces.
     Setting this variable automatically makes it local to the current
     buffer.