Initial revision

3 files changed, 3041 insertions, 0 deletions

diff --git a/lispref/backups.texi b/lispref/backups.texi
new file mode 100644
index 00000000000..57108105e0b
--- /dev/null
+++ b/lispref/backups.texi
@@ -0,0 +1,621 @@
+@c -*-texinfo-*-
+@c This is part of the GNU Emacs Lisp Reference Manual.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
+@c See the file elisp.texi for copying conditions.
+@setfilename ../info/backups
+@node Backups and Auto-Saving, Buffers, Files, Top
+@chapter Backups and Auto-Saving
+
+  Backup files and auto-save files are two methods by which Emacs tries
+to protect the user from the consequences of crashes or of the user's
+own errors.  Auto-saving preserves the text from earlier in the current
+editing session; backup files preserve file contents prior to the
+current session.
+
+@menu
+* Backup Files::   How backup files are made; how their names are chosen.
+* Auto-Saving::    How auto-save files are made; how their names are chosen.
+* Reverting::      @code{revert-buffer}, and how to customize what it does.
+@end menu
+
+@node Backup Files, Auto-Saving, Backups and Auto-Saving, Backups and Auto-Saving
+@section Backup Files
+@cindex backup file
+
+  A @dfn{backup file} is a copy of the old contents of a file you are
+editing.  Emacs makes a backup file the first time you save a buffer
+into its visited file.  Normally, this means that the backup file
+contains the contents of the file as it was before the current editing
+session.  The contents of the backup file normally remain unchanged once
+it exists.
+
+  Backups are usually made by renaming the visited file to a new name.
+Optionally, you can specify that backup files should be made by copying
+the visited file.  This choice makes a difference for files with
+multiple names; it also can affect whether the edited file remains owned
+by the original owner or becomes owned by the user editing it.
+
+  By default, Emacs makes a single backup file for each file edited.
+You can alternatively request numbered backups; then each new backup
+file gets a new name.  You can delete old numbered backups when you
+don't want them any more, or Emacs can delete them automatically.
+
+@menu
+* Making Backups::     How Emacs makes backup files, and when.
+* Rename or Copy::     Two alternatives: renaming the old file or copying it.
+* Numbered Backups::   Keeping multiple backups for each source file.
+* Backup Names::       How backup file names are computed; customization.
+@end menu
+
+@node Making Backups, Rename or Copy, Backup Files, Backup Files
+@subsection Making Backup Files
+
+@defun backup-buffer
+  This function makes a backup of the file visited by the current
+buffer, if appropriate.  It is called by @code{save-buffer} before
+saving the buffer the first time.
+@end defun
+
+@defvar buffer-backed-up
+  This buffer-local variable indicates whether this buffer's file has
+been backed up on account of this buffer.  If it is non-@code{nil}, then
+the backup file has been written.  Otherwise, the file should be backed
+up when it is next saved (if backup files are enabled).  This is a
+permanent local; @code{kill-local-variables} does not alter it.
+@end defvar
+
+@defopt make-backup-files
+  This variable determines whether or not to make backup files.  If it
+is non-@code{nil}, then Emacs creates a backup of each file when it is
+saved for the first time.
+
+  The following example shows how to change the @code{make-backup-files}
+variable only in the @file{RMAIL} buffer and not elsewhere.  Setting it
+@code{nil} stops Emacs from making backups of the @file{RMAIL} file,
+which may save disk space.  (You would put this code in your
+@file{.emacs} file.)
+
+@smallexample
+@group
+(add-hook 'rmail-mode-hook 
+          (function (lambda ()
+                      (make-local-variable 
+                       'make-backup-files)
+                      (setq make-backup-files nil))))
+@end group
+@end smallexample
+@end defopt
+
+@defvar backup-enable-predicate filename
+This variable's value is a function to be called on certain occasions to
+decide whether a there should be backup files for file name
+@var{filename}.  If it returns @code{nil}, backups are disabled.
+Otherwise, the other variables in this section say whether and how to
+make backups.
+
+The default value is this:
+
+@example
+(lambda (name)
+  (or (< (length name) 5)
+      (not (string-equal "/tmp/"
+                         (substring name 0 5)))))
+@end example
+@end defvar
+
+@defvar backup-inhibited
+If this variable is non-@code{nil}, backups are inhibited.  It records
+the result of testing @code{backup-enable-predicate} on the visited file
+name.  It can also coherently be used by other mechanisms that inhibit
+backups based on which file is visited.  Major modes should not set this
+variable.
+@end defvar
+
+@node Rename or Copy, Numbered Backups, Making Backups, Backup Files
+@subsection Backup by Renaming or by Copying?
+@cindex backup files, how to make them
+
+  There are two ways that Emacs can make a backup file: 
+
+@itemize @bullet
+@item
+Emacs can rename the original file so that it becomes a backup file, and
+then write the buffer being saved into a new file.  After this
+procedure, any other names (i.e., hard links) of the original file now
+refer to the backup file.  The new file is owned by the user doing the
+editing, and its group is the default for new files written by the user
+in that directory.
+
+@item
+Emacs can copy the original file into a backup file, and then overwrite
+the original file with new contents.  After this procedure, any other
+names (i.e., hard links) of the original file still refer to the current
+version of the file.  The file's owner and group will be unchanged.
+@end itemize
+
+  The first method, renaming, is the default.
+
+  The variable @code{backup-by-copying}, if non-@code{nil}, says to use
+the second method, which is to copy the original file and overwrite it
+with the new buffer contents.  The variable @code{file-precious-flag},
+if non-@code{nil}, also has this effect (as a sideline of its main
+significance).  @xref{Saving Buffers}.
+
+@defvar backup-by-copying
+If this variable is non-@code{nil}, Emacs always makes backup files by
+copying.
+@end defvar
+
+  The following two variables, when non-@code{nil}, cause the second
+method to be used in certain special cases.  They have no effect on the
+treatment of files that don't fall into the special cases.
+
+@defvar backup-by-copying-when-linked
+If this variable is non-@code{nil}, Emacs makes backups by copying for
+files with multiple names (hard links).
+
+This variable is significant only if @code{backup-by-copying} is
+@code{nil}, since copying is always used when that variable is
+non-@code{nil}.
+@end defvar
+
+@defvar backup-by-copying-when-mismatch
+If this variable is non-@code{nil}, Emacs makes backups by copying in cases
+where renaming would change either the owner or the group of the file.
+
+The value has no effect when renaming would not alter the owner or
+group of the file; that is, for files which are owned by the user and
+whose group matches the default for a new file created there by the
+user.
+
+This variable is significant only if @code{backup-by-copying} is
+@code{nil}, since copying is always used when that variable is
+non-@code{nil}.
+@end defvar
+
+@node Numbered Backups, Backup Names, Rename or Copy, Backup Files
+@subsection Making and Deleting Numbered Backup Files
+
+  If a file's name is @file{foo}, the names of its numbered backup
+versions are @file{foo.~@var{v}~}, for various integers @var{v}, like
+this: @file{foo.~1~}, @file{foo.~2~}, @file{foo.~3~}, @dots{},
+@file{foo.~259~}, and so on.
+
+@defopt version-control
+This variable controls whether to make a single non-numbered backup
+file or multiple numbered backups.
+
+@table @asis
+@item @code{nil}
+Make numbered backups if the visited file already has numbered backups;
+otherwise, do not.
+
+@item @code{never}
+Do not make numbered backups.
+
+@item @var{anything else}
+Do make numbered backups.
+@end table
+@end defopt
+
+  The use of numbered backups ultimately leads to a large number of
+backup versions, which must then be deleted.  Emacs can do this
+automatically.
+
+@defopt kept-new-versions
+The value of this variable is the number of oldest versions to keep
+when a new numbered backup is made.  The newly made backup is included
+in the count.  The default value is 2.
+@end defopt
+
+@defopt kept-old-versions
+The value of this variable is the number of oldest versions to keep
+when a new numbered backup is made.  The default value is 2.
+@end defopt
+
+  If there are backups numbered 1, 2, 3, 5, and 7, and both of these
+variables have the value 2, then the backups numbered 1 and 2 are kept
+as old versions and those numbered 5 and 7 are kept as new versions;
+backup version 3 is deleted.  The function @code{find-backup-file-name}
+(@pxref{Backup Names}) is responsible for determining which backup
+versions to delete, but does not delete them itself.
+
+@defopt trim-versions-without-asking
+If this variable is non-@code{nil}, then saving a file deletes excess
+backup versions silently.  Otherwise, it asks the user whether to delete
+them.
+@end defopt
+
+@defopt dired-kept-versions
+This variable specifies how many of the newest backup versions to keep
+in the Dired command @kbd{.} (@code{dired-clean-directory}).  That's the
+same thing @code{kept-new-versions} does when you make a new backup
+file.  The default value is 2.
+@end defopt
+
+@node Backup Names, , Numbered Backups, Backup Files
+@subsection Naming Backup Files
+
+  The functions in this section are documented mainly because you can
+customize the naming conventions for backup files by redefining them.
+If you change one, you probably need to change the rest.
+
+@defun backup-file-name-p filename
+This function returns a non-@code{nil} value if @var{filename} is a
+possible name for a backup file.  A file with the name @var{filename}
+need not exist; the function just checks the name.
+
+@smallexample
+@group
+(backup-file-name-p "foo")
+     @result{} nil
+@end group
+@group
+(backup-file-name-p "foo~")
+     @result{} 3
+@end group
+@end smallexample
+
+The standard definition of this function is as follows:
+
+@smallexample
+@group
+(defun backup-file-name-p (file)
+  "Return non-nil if FILE is a backup file \
+name (numeric or not)..."
+  (string-match "~$" file))
+@end group
+@end smallexample
+
+@noindent
+Thus, the function returns a non-@code{nil} value if the file name ends
+with a @samp{~}.  (We use a backslash to split the documentation
+string's first line into two lines in the text, but produce just one
+line in the string itself.)
+
+This simple expression is placed in a separate function to make it easy
+to redefine for customization.
+@end defun
+
+@defun make-backup-file-name filename
+This function returns a string which is the name to use for a
+non-numbered backup file for file @var{filename}.  On Unix, this is just
+@var{filename} with a tilde appended.
+
+The standard definition of this function is as follows:
+
+@smallexample
+@group
+(defun make-backup-file-name (file)
+  "Create the non-numeric backup file name for FILE.
+@dots{}"
+  (concat file "~"))
+@end group
+@end smallexample
+
+You can change the backup file naming convention by redefining this
+function.  The following example redefines @code{make-backup-file-name}
+to prepend a @samp{.} as well as appending a tilde:
+
+@smallexample
+@group
+(defun make-backup-file-name (filename)
+  (concat "." filename "~"))
+@end group
+
+@group
+(make-backup-file-name "backups.texi")
+     @result{} ".backups.texi~"
+@end group
+@end smallexample
+@end defun
+
+@defun find-backup-file-name filename
+This function computes the file name for a new backup file for
+@var{filename}.  It may also propose certain existing backup files for
+deletion.  @code{find-backup-file-name} returns a list whose @sc{car} is
+the name for the new backup file and whose @sc{cdr} is a list of backup
+files whose deletion is proposed.
+
+Two variables, @code{kept-old-versions} and @code{kept-new-versions},
+determine which backup versions should be kept.  This function keeps
+those versions by excluding them from the @sc{cdr} of the value.
+@xref{Numbered Backups}.
+
+In this example, the value says that @file{~rms/foo.~5~} is the name
+to use for the new backup file, and @file{~rms/foo.~3~} is an ``excess''
+version that the caller should consider deleting now.
+
+@smallexample
+@group
+(find-backup-file-name "~rms/foo")
+     @result{} ("~rms/foo.~5~" "~rms/foo.~3~")
+@end group
+@end smallexample
+@end defun
+
+@c Emacs 19 feature
+@defun file-newest-backup filename
+This function returns the name of the most recent backup file for
+@var{filename}, or @code{nil} that file has no backup files.
+
+Some file comparison commands use this function in order to compare
+a file by default with its most recent backup.
+@end defun 
+
+@node Auto-Saving, Reverting, Backup Files, Backups and Auto-Saving
+@section Auto-Saving
+@cindex auto-saving
+
+  Emacs periodically saves all files that you are visiting; this is
+called @dfn{auto-saving}.  Auto-saving prevents you from losing more
+than a limited amount of work if the system crashes.  By default,
+auto-saves happen every 300 keystrokes, or after around 30 seconds of
+idle time.  @xref{Auto-Save, Auto-Save, Auto-Saving: Protection Against
+Disasters, emacs, The GNU Emacs Manual}, for information on auto-save
+for users.  Here we describe the functions used to implement auto-saving
+and the variables that control them.
+
+@defvar buffer-auto-save-file-name
+This buffer-local variable is the name of the file used for
+auto-saving the current buffer.  It is @code{nil} if the buffer
+should not be auto-saved.
+
+@example
+@group
+buffer-auto-save-file-name
+=> "/xcssun/users/rms/lewis/#files.texi#"
+@end group
+@end example
+@end defvar
+
+@deffn Command auto-save-mode arg
+When used interactively without an argument, this command is a toggle
+switch: it turns on auto-saving of the current buffer if it is off, and
+vice-versa.  With an argument @var{arg}, the command turns auto-saving
+on if the value of @var{arg} is @code{t}, a nonempty list, or a positive
+integer.  Otherwise, it turns auto-saving off.
+@end deffn
+
+@defun auto-save-file-name-p filename
+This function returns a non-@code{nil} value if @var{filename} is a
+string that could be the name of an auto-save file.  It works based on
+knowledge of the naming convention for auto-save files: a name that
+begins and ends with hash marks (@samp{#}) is a possible auto-save file
+name.  The argument @var{filename} should not contain a directory part.
+
+@example
+@group
+(make-auto-save-file-name)
+     @result{} "/xcssun/users/rms/lewis/#files.texi#"
+@end group
+@group
+(auto-save-file-name-p "#files.texi#")
+     @result{} 0
+@end group
+@group
+(auto-save-file-name-p "files.texi")
+     @result{} nil
+@end group
+@end example
+
+The standard definition of this function is as follows:
+
+@example
+@group
+(defun auto-save-file-name-p (filename)
+  "Return non-nil if FILENAME can be yielded by..."
+  (string-match "^#.*#$" filename))
+@end group
+@end example
+
+This function exists so that you can customize it if you wish to
+change the naming convention for auto-save files.  If you redefine it,
+be sure to redefine the function @code{make-auto-save-file-name}
+correspondingly.
+@end defun
+
+@defun make-auto-save-file-name
+This function returns the file name to use for auto-saving the current
+buffer.  This is just the file name with hash marks (@samp{#}) appended
+and prepended to it.  This function does not look at the variable
+@code{auto-save-visited-file-name}; you should check that before calling
+this function.
+
+@example
+@group
+(make-auto-save-file-name)
+     @result{} "/xcssun/users/rms/lewis/#backup.texi#"
+@end group
+@end example
+
+The standard definition of this function is as follows:
+
+@example
+@group
+(defun make-auto-save-file-name ()
+  "Return file name to use for auto-saves \
+of current buffer.
+@dots{}"
+  (if buffer-file-name
+@end group
+@group
+      (concat
+       (file-name-directory buffer-file-name)
+       "#"
+       (file-name-nondirectory buffer-file-name)
+       "#")
+    (expand-file-name
+     (concat "#%" (buffer-name) "#"))))
+@end group
+@end example
+
+This exists as a separate function so that you can redefine it to
+customize the naming convention for auto-save files.  Be sure to
+change @code{auto-save-file-name-p} in a corresponding way.
+@end defun
+
+@defvar auto-save-visited-file-name
+If this variable is non-@code{nil}, Emacs auto-saves buffers in
+the files they are visiting.  That is, the auto-save is done in the same
+file which you are editing.  Normally, this variable is @code{nil}, so
+auto-save files have distinct names that are created by
+@code{make-auto-save-file-name}.
+
+When you change the value of this variable, the value does not take
+effect until the next time auto-save mode is reenabled in any given
+buffer.  If auto-save mode is already enabled, auto-saves continue to go
+in the same file name until @code{auto-save-mode} is called again.
+@end defvar
+
+@defun recent-auto-save-p
+This function returns @code{t} if the current buffer has been
+auto-saved since the last time it was read in or saved.
+@end defun
+
+@defun set-buffer-auto-saved
+This function marks the current buffer as auto-saved.  The buffer will
+not be auto-saved again until the buffer text is changed again.  The
+function returns @code{nil}.
+@end defun
+
+@defopt auto-save-interval
+The value of this variable is the number of characters that Emacs
+reads from the keyboard between auto-saves.  Each time this many more
+characters are read, auto-saving is done for all buffers in which it is
+enabled.
+@end defopt
+
+@defopt auto-save-timeout
+The value of this variable is the number of seconds of idle time that
+should cause auto-saving.  Each time the user pauses for this long,
+Emacs auto-saves any buffers that need it.  (Actually, the specified
+timeout is multiplied by a factor depending on the size of the current
+buffer.)
+@end defopt
+
+@defvar auto-save-hook
+This normal hook is run whenever an auto-save is about to happen.
+@end defvar
+
+@defopt auto-save-default
+If this variable is non-@code{nil}, buffers that are visiting files
+have auto-saving enabled by default.  Otherwise, they do not.
+@end defopt
+
+@deffn Command do-auto-save &optional no-message
+This function auto-saves all buffers that need to be auto-saved.  It
+saves all buffers for which auto-saving is enabled and that have been
+changed since the previous auto-save.
+
+Normally, if any buffers are auto-saved, a message that says
+@samp{Auto-saving...} is displayed in the echo area while auto-saving is
+going on.  However, if @var{no-message} is non-@code{nil}, the message
+is inhibited.
+@end deffn
+
+@defun delete-auto-save-file-if-necessary
+This function deletes the current buffer's auto-save file if
+@code{delete-auto-save-files} is non-@code{nil}.  It is called every
+time a buffer is saved.
+@end defun
+
+@defvar delete-auto-save-files
+This variable is used by the function
+@code{delete-auto-save-file-if-necessary}.  If it is non-@code{nil},
+Emacs deletes auto-save files when a true save is done (in the visited
+file).  This saves disk space and unclutters your directory.
+@end defvar
+
+@defun rename-auto-save-file
+This function adjusts the current buffer's auto-save file name if the
+visited file name has changed.  It also renames an existing auto-save
+file.  If the visited file name has not changed, this function does
+nothing.
+@end defun
+
+@node Reverting,  , Auto-Saving, Backups and Auto-Saving
+@section Reverting
+
+  If you have made extensive changes to a file and then change your mind
+about them, you can get rid of them by reading in the previous version
+of the file with the @code{revert-buffer} command.  @xref{Reverting, ,
+Reverting a Buffer, emacs, The GNU Emacs Manual}.
+
+@deffn Command revert-buffer &optional check-auto-save noconfirm
+This command replaces the buffer text with the text of the visited
+file on disk.  This action undoes all changes since the file was visited
+or saved.
+
+If the argument @var{check-auto-save} is non-@code{nil}, and the
+latest auto-save file is more recent than the visited file,
+@code{revert-buffer} asks the user whether to use that instead.
+Otherwise, it always uses the text of the visited file itself.
+Interactively, @var{check-auto-save} is set if there is a numeric prefix
+argument.
+
+Normally, @code{revert-buffer} asks for confirmation before it changes
+the buffer; but if the argument @var{noconfirm} is non-@code{nil},
+@code{revert-buffer} does not ask for confirmation.
+
+Reverting tries to preserve marker positions in the buffer by using the
+replacement feature of @code{insert-file-contents}.  If there is no
+actual difference between the buffer and the file, before reversion,
+this preserves all the markers.  If reversion does change the buffer,
+this preserves the markers in the unchanged text (if any) at the
+beginning and end of the buffer.  Preserving any additional markers
+would be problematical.
+
+If the value of the @code{revert-buffer-function} variable is
+non-@code{nil}, it is called as a function with no arguments to do the
+work.
+@end deffn
+
+@defvar revert-buffer-function
+The value of this variable is the function to use to revert this
+buffer; but if the value of this variable is @code{nil}, then the
+@code{revert-buffer} function carries out its default action.  Modes
+such as Dired mode, in which the text being edited does not consist of a
+file's contents but can be regenerated in some other fashion, give this
+variable a buffer-local value that is a function to regenerate the
+contents.
+@end defvar
+
+@defvar revert-buffer-insert-file-contents-function
+The value of this variable, if non-@code{nil}, is the function to use
+to insert contents when reverting this buffer.  The function receives
+two arguments, first the file name to use, and second, @code{t} if the
+user has asked to read the auto-save file.
+@end defvar
+
+@defvar before-revert-hook
+This normal hook is run by @code{revert-buffer} before actually
+inserting the modified contents---but only if
+@code{revert-buffer-function} is @code{nil}.
+
+Font Lock mode uses this hook to record that the buffer contents are no
+longer fontified.
+@end defvar
+
+@defvar after-revert-hook
+This normal hook is run by @code{revert-buffer} after actually inserting
+the modified contents---but only if @code{revert-buffer-function} is
+@code{nil}.
+
+Font Lock mode uses this hook to recompute the fonts for the updated
+buffer contents.
+@end defvar
+
+@deffn Command recover-file filename
+This function visits @var{filename}, but gets the contents from its
+last auto-save file.  This is useful after the system has crashed, to
+resume editing the same file without losing all the work done in the
+previous session.
+
+An error is signaled if there is no auto-save file for @var{filename},
+or if @var{filename} is newer than its auto-save file.  If
+@var{filename} does not exist, but its auto-save file does, then the
+auto-save file is read as usual.  This last situation may occur if you
+visited a nonexistent file and never actually saved it.
+@end deffn
+
diff --git a/lispref/buffers.texi b/lispref/buffers.texi
new file mode 100644
index 00000000000..6f777d7480c
--- /dev/null
+++ b/lispref/buffers.texi
@@ -0,0 +1,828 @@
+@c -*-texinfo-*-
+@c This is part of the GNU Emacs Lisp Reference Manual.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
+@c See the file elisp.texi for copying conditions.
+@setfilename ../info/buffers
+@node Buffers, Windows, Backups and Auto-Saving, Top
+@chapter Buffers
+@cindex buffer
+
+  A @dfn{buffer} is a Lisp object containing text to be edited.  Buffers
+are used to hold the contents of files that are being visited; there may
+also be buffers which are not visiting files.  While several buffers may
+exist at one time, exactly one buffer is designated the @dfn{current
+buffer} at any time.  Most editing commands act on the contents of the
+current buffer.  Each buffer, including the current buffer, may or may
+not be displayed in any windows.
+
+@menu
+* Buffer Basics::       What is a buffer?
+* Buffer Names::        Accessing and changing buffer names.
+* Buffer File Name::    The buffer file name indicates which file is visited.
+* Buffer Modification:: A buffer is @dfn{modified} if it needs to be saved.
+* Modification Time::   Determining whether the visited file was changed
+                         ``behind Emacs's back''.
+* Read Only Buffers::   Modifying text is not allowed in a read-only buffer.
+* The Buffer List::     How to look at all the existing buffers.
+* Creating Buffers::    Functions that create buffers.
+* Killing Buffers::     Buffers exist until explicitly killed.
+* Current Buffer::      Designating a buffer as current
+                          so primitives will access its contents.
+@end menu
+
+@node Buffer Basics
+@comment  node-name,  next,  previous,  up
+@section Buffer Basics
+
+@ifinfo
+  A @dfn{buffer} is a Lisp object containing text to be edited.  Buffers
+are used to hold the contents of files that are being visited; there may
+also be buffers which are not visiting files.  While several buffers may
+exist at one time, exactly one buffer is designated the @dfn{current
+buffer} at any time.  Most editing commands act on the contents of the
+current buffer.  Each buffer, including the current buffer, may or may
+not be displayed in any windows.
+@end ifinfo
+
+  Buffers in Emacs editing are objects which have distinct names and
+hold text that can be edited.  Buffers appear to Lisp programs as a
+special data type.  The contents of a buffer may be viewed as an
+extendable string; insertions and deletions may occur in any part of the
+buffer.  @xref{Text}.
+
+  A Lisp buffer object contains numerous pieces of information.  Some of
+this information is directly accessible to the programmer through
+variables, while other information is only accessible through
+special-purpose functions.  For example, the visited file name is
+directly accessible through a variable, while the value of point is
+accessible only through a primitive function.
+
+  Buffer-specific information that is directly accessible is stored in
+@dfn{buffer-local} variable bindings, which are variable values that are
+effective only in a particular buffer.  This feature allows each buffer
+to override the values of certain variables.  Most major modes override
+variables such as @code{fill-column} or @code{comment-column} in this
+way.  For more information about buffer-local variables and functions
+related to them, see @ref{Buffer-Local Variables}.
+
+  For functions and variables related to visiting files in buffers, see
+@ref{Visiting Files} and @ref{Saving Buffers}.  For functions and
+variables related to the display of buffers in windows, see
+@ref{Buffers and Windows}.
+
+@defun bufferp object
+This function returns @code{t} if @var{object} is a buffer,
+@code{nil} otherwise.
+@end defun
+
+@node Buffer Names
+@section Buffer Names
+@cindex buffer names
+
+  Each buffer has a unique name, which is a string.  Many of the
+functions that work on buffers accept either a buffer or a buffer name
+as an argument.  Any argument called @var{buffer-or-name} is of this
+sort, and an error is signaled if it is neither a string nor a buffer.
+Any argument called @var{buffer} must be an actual buffer
+object, not a name.
+
+  Buffers that are ephemeral and generally uninteresting to the user
+have names starting with a space, so that the @code{list-buffers} or
+@code{buffer-menu} commands don't mention them.  A name starting with
+space also initially disables recording undo information; see
+@ref{Undo}.
+
+@defun buffer-name &optional buffer
+This function returns the name of @var{buffer} as a string.  If
+@var{buffer} is not supplied, it defaults to the current buffer.
+
+If @code{buffer-name} returns @code{nil}, it means that @var{buffer}
+has been killed.  @xref{Killing Buffers}.
+
+@example
+@group
+(buffer-name)
+     @result{} "buffers.texi"
+@end group
+
+@group
+(setq foo (get-buffer "temp"))
+     @result{} #<buffer temp>
+@end group
+@group
+(kill-buffer foo)
+     @result{} nil
+@end group
+@group
+(buffer-name foo)
+     @result{} nil
+@end group
+@group
+foo
+     @result{} #<killed buffer>
+@end group
+@end example
+@end defun
+
+@deffn Command rename-buffer newname &optional unique
+This function renames the current buffer to @var{newname}.  An error
+is signaled if @var{newname} is not a string, or if there is already a
+buffer with that name.  The function returns @code{nil}.
+
+@c Emacs 19 feature
+Ordinarily, @code{rename-buffer} signals an error if @var{newname} is
+already in use.  However, if @var{unique} is non-@code{nil}, it modifies
+@var{newname} to make a name that is not in use.  Interactively, you can
+make @var{unique} non-@code{nil} with a numeric prefix argument.
+
+One application of this command is to rename the @samp{*shell*} buffer
+to some other name, thus making it possible to create a second shell
+buffer under the name @samp{*shell*}.
+@end deffn
+
+@defun get-buffer buffer-or-name
+This function returns the buffer specified by @var{buffer-or-name}.
+If @var{buffer-or-name} is a string and there is no buffer with that
+name, the value is @code{nil}.  If @var{buffer-or-name} is a buffer, it
+is returned as given.  (That is not very useful, so the argument is usually 
+a name.)  For example:
+
+@example
+@group
+(setq b (get-buffer "lewis"))
+     @result{} #<buffer lewis>
+@end group
+@group
+(get-buffer b)
+     @result{} #<buffer lewis>
+@end group
+@group
+(get-buffer "Frazzle-nots")
+     @result{} nil
+@end group
+@end example
+
+See also the function @code{get-buffer-create} in @ref{Creating Buffers}.
+@end defun
+
+@c Emacs 19 feature
+@defun generate-new-buffer-name starting-name
+This function returns a name that would be unique for a new buffer---but
+does not create the buffer.  It starts with @var{starting-name}, and
+produces a name not currently in use for any buffer by appending a
+number inside of @samp{<@dots{}>}.
+
+See the related function @code{generate-new-buffer} in @ref{Creating
+Buffers}.
+@end defun
+
+@node Buffer File Name
+@section Buffer File Name
+@cindex visited file
+@cindex buffer file name
+@cindex file name of buffer
+
+  The @dfn{buffer file name} is the name of the file that is visited in
+that buffer.  When a buffer is not visiting a file, its buffer file name
+is @code{nil}.  Most of the time, the buffer name is the same as the
+nondirectory part of the buffer file name, but the buffer file name and
+the buffer name are distinct and can be set independently.
+@xref{Visiting Files}.
+
+@defun buffer-file-name &optional buffer
+This function returns the absolute file name of the file that
+@var{buffer} is visiting.  If @var{buffer} is not visiting any file,
+@code{buffer-file-name} returns @code{nil}.  If @var{buffer} is not
+supplied, it defaults to the current buffer.
+
+@example
+@group
+(buffer-file-name (other-buffer))
+     @result{} "/usr/user/lewis/manual/files.texi"
+@end group
+@end example
+@end defun
+
+@defvar buffer-file-name
+This buffer-local variable contains the name of the file being visited
+in the current buffer, or @code{nil} if it is not visiting a file.  It
+is a permanent local, unaffected by @code{kill-local-variables}.
+
+@example
+@group
+buffer-file-name
+     @result{} "/usr/user/lewis/manual/buffers.texi"
+@end group
+@end example
+
+It is risky to change this variable's value without doing various other
+things.  See the definition of @code{set-visited-file-name} in
+@file{files.el}; some of the things done there, such as changing the
+buffer name, are not strictly necessary, but others are essential to
+avoid confusing Emacs.
+@end defvar
+
+@defvar buffer-file-truename
+This buffer-local variable holds the truename of the file visited in the
+current buffer, or @code{nil} if no file is visited.  It is a permanent
+local, unaffected by @code{kill-local-variables}.  @xref{Truenames}.
+@end defvar
+
+@defvar buffer-file-number
+This buffer-local variable holds the file number and directory device
+number of the file visited in the current buffer, or @code{nil} if no
+file or a nonexistent file is visited.  It is a permanent local,
+unaffected by @code{kill-local-variables}.  @xref{Truenames}.
+
+The value is normally a list of the form @code{(@var{filenum}
+@var{devnum})}.  This pair of numbers uniquely identifies the file among
+all files accessible on the system.  See the function
+@code{file-attributes}, in @ref{File Attributes}, for more information
+about them.
+@end defvar
+
+@defun get-file-buffer filename
+This function returns the buffer visiting file @var{filename}.  If
+there is no such buffer, it returns @code{nil}.  The argument
+@var{filename}, which must be a string, is expanded (@pxref{File Name
+Expansion}), then compared against the visited file names of all live
+buffers.
+
+@example
+@group
+(get-file-buffer "buffers.texi")
+    @result{} #<buffer buffers.texi>
+@end group
+@end example
+
+In unusual circumstances, there can be more than one buffer visiting
+the same file name.  In such cases, this function returns the first
+such buffer in the buffer list.
+@end defun
+
+@deffn Command set-visited-file-name filename
+If @var{filename} is a non-empty string, this function changes the
+name of the file visited in current buffer to @var{filename}.  (If the
+buffer had no visited file, this gives it one.)  The @emph{next time}
+the buffer is saved it will go in the newly-specified file.  This
+command marks the buffer as modified, since it does not (as far as Emacs
+knows) match the contents of @var{filename}, even if it matched the
+former visited file.
+
+If @var{filename} is @code{nil} or the empty string, that stands for
+``no visited file''.  In this case, @code{set-visited-file-name} marks
+the buffer as having no visited file.
+
+@c Wordy to avoid overfull hbox.  --rjc 16mar92
+When the function @code{set-visited-file-name} is called interactively, it
+prompts for @var{filename} in the minibuffer.
+
+See also @code{clear-visited-file-modtime} and
+@code{verify-visited-file-modtime} in @ref{Buffer Modification}.
+@end deffn
+
+@defvar list-buffers-directory
+This buffer-local variable records a string to display in a buffer
+listing in place of the visited file name, for buffers that don't have a
+visited file name.  Dired buffers use this variable.
+@end defvar
+
+@node Buffer Modification
+@section Buffer Modification
+@cindex buffer modification
+@cindex modification flag (of buffer)
+
+  Emacs keeps a flag called the @dfn{modified flag} for each buffer, to
+record whether you have changed the text of the buffer.  This flag is
+set to @code{t} whenever you alter the contents of the buffer, and
+cleared to @code{nil} when you save it.  Thus, the flag shows whether
+there are unsaved changes.  The flag value is normally shown in the mode
+line (@pxref{Mode Line Variables}), and controls saving (@pxref{Saving
+Buffers}) and auto-saving (@pxref{Auto-Saving}).
+
+  Some Lisp programs set the flag explicitly.  For example, the function
+@code{set-visited-file-name} sets the flag to @code{t}, because the text
+does not match the newly-visited file, even if it is unchanged from the
+file formerly visited.
+
+  The functions that modify the contents of buffers are described in
+@ref{Text}.
+
+@defun buffer-modified-p &optional buffer
+This function returns @code{t} if the buffer @var{buffer} has been modified
+since it was last read in from a file or saved, or @code{nil}
+otherwise.  If @var{buffer} is not supplied, the current buffer
+is tested.
+@end defun
+
+@defun set-buffer-modified-p flag
+This function marks the current buffer as modified if @var{flag} is
+non-@code{nil}, or as unmodified if the flag is @code{nil}.
+
+Another effect of calling this function is to cause unconditional
+redisplay of the mode line for the current buffer.  In fact, the
+function @code{force-mode-line-update} works by doing this:
+
+@example
+@group
+(set-buffer-modified-p (buffer-modified-p))
+@end group
+@end example
+@end defun
+
+@deffn Command not-modified
+This command marks the current buffer as unmodified, and not needing
+to be saved.  Don't use this function in programs, since it prints a
+message in the echo area; use @code{set-buffer-modified-p} (above) instead.
+@end deffn
+
+@c Emacs 19 feature
+@defun buffer-modified-tick &optional buffer
+This function returns @var{buffer}`s modification-count.  This is a
+counter that increments every time the buffer is modified.  If
+@var{buffer} is @code{nil} (or omitted), the current buffer is used.
+@end defun
+
+@node Modification Time
+@comment  node-name,  next,  previous,  up
+@section Comparison of Modification Time
+@cindex comparison of modification time
+@cindex modification time, comparison of 
+
+  Suppose that you visit a file and make changes in its buffer, and
+meanwhile the file itself is changed on disk.  At this point, saving the
+buffer would overwrite the changes in the file.  Occasionally this may
+be what you want, but usually it would lose valuable information.  Emacs
+therefore checks the file's modification time using the functions
+described below before saving the file.
+
+@defun verify-visited-file-modtime buffer
+This function compares what @var{buffer} has recorded for the
+modification time of its visited file against the actual modification
+time of the file as recorded by the operating system.  The two should be
+the same unless some other process has written the file since Emacs
+visited or saved it.
+
+The function returns @code{t} if the last actual modification time and
+Emacs's recorded modification time are the same, @code{nil} otherwise.
+@end defun
+
+@defun clear-visited-file-modtime
+This function clears out the record of the last modification time of
+the file being visited by the current buffer.  As a result, the next
+attempt to save this buffer will not complain of a discrepancy in
+file modification times.
+
+This function is called in @code{set-visited-file-name} and other
+exceptional places where the usual test to avoid overwriting a changed
+file should not be done.
+@end defun
+
+@c Emacs 19 feature
+@defun visited-file-modtime
+This function returns the buffer's recorded last file modification time,
+as a list of the form @code{(@var{high} . @var{low})}.  (This is the
+same format that @code{file-attributes} uses to return time values; see
+@ref{File Attributes}.)
+@end defun
+
+@c Emacs 19 feature
+@defun set-visited-file-modtime &optional time
+This function updates the buffer's record of the last modification time
+of the visited file, to the value specified by @var{time} if @var{time}
+is not @code{nil}, and otherwise to the last modification time of the
+visited file.
+
+If @var{time} is not @code{nil}, it should have the form
+@code{(@var{high} . @var{low})} or @code{(@var{high} @var{low})}, in
+either case containing two integers, each of which holds 16 bits of the
+time.
+
+This function is useful if the buffer was not read from the file
+normally, or if the file itself has been changed for some known benign
+reason.
+@end defun
+
+@defun ask-user-about-supersession-threat fn
+@cindex obsolete buffer
+This function is used to ask a user how to proceed after an attempt to
+modify an obsolete buffer.  An @dfn{obsolete buffer} is an unmodified
+buffer for which the associated file on disk is newer than the last
+save-time of the buffer.  This means some other program has probably
+altered the file.
+
+This function is called automatically by Emacs on the proper
+occasions.  It exists so you can customize Emacs by redefining it.
+See the file @file{userlock.el} for the standard definition.
+
+@kindex file-supersession
+Depending on the user's answer, the function may return normally, in
+which case the modification of the buffer proceeds, or it may signal a
+@code{file-supersession} error with data @code{(@var{fn})}, in which
+case the proposed buffer modification is not allowed.  
+
+See also the file locking mechanism in @ref{File Locks}.
+@end defun
+
+@node Read Only Buffers
+@section Read-Only Buffers
+@cindex read-only buffer
+@cindex buffer, read-only
+
+  If a buffer is @dfn{read-only}, then you cannot change its contents,
+although you may change your view of the contents by scrolling and 
+narrowing.
+
+  Read-only buffers are used in two kinds of situations:
+
+@itemize @bullet
+@item
+A buffer visiting a write-protected file is normally read-only.
+
+Here, the purpose is to show the user that editing the buffer with the
+aim of saving it in the file may be futile or undesirable.  The user who
+wants to change the buffer text despite this can do so after clearing
+the read-only flag with @kbd{C-M-q}.
+
+@item
+Modes such as Dired and Rmail make buffers read-only when altering the
+contents with the usual editing commands is probably a mistake.
+
+The special commands of these modes bind @code{buffer-read-only} to
+@code{nil} (with @code{let}) or bind @code{inhibit-read-only} to
+@code{t} around the places where they change the text.
+@end itemize
+
+@defvar buffer-read-only
+This buffer-local variable specifies whether the buffer is read-only.
+The buffer is read-only if this variable is non-@code{nil}.
+@end defvar
+
+@defvar inhibit-read-only
+If this variable is non-@code{nil}, then read-only buffers and read-only
+characters may be modified.  The value of @code{buffer-read-only} does
+not matter when @code{inhibit-read-only} is non-@code{nil}.
+
+If @code{inhibit-read-only} is @code{t}, all @code{read-only} text
+properties have no effect (@pxref{Special Properties}).  If
+@code{inhibit-read-only} is a list, then @code{read-only} text
+properties are ignored if they are members of the list (comparison is
+done with @code{eq}).
+@end defvar
+
+@deffn Command toggle-read-only
+This command changes whether the current buffer is read-only.  It is
+intended for interactive use; don't use it in programs.  At any given
+point in a program, you should know whether you want the read-only flag
+on or off; so you can set @code{buffer-read-only} explicitly to the
+proper value, @code{t} or @code{nil}.
+@end deffn
+
+@defun barf-if-buffer-read-only
+This function signals a @code{buffer-read-only} error if the current
+buffer is read-only.  @xref{Interactive Call}, for another way to
+signal an error if the current buffer is read-only.
+@end defun
+
+@node The Buffer List
+@section The Buffer List
+@cindex buffer list
+
+  The @dfn{buffer list} is a list of all live buffers.  Creating a
+buffer adds it to this list, and killing a buffer deletes it.  The order
+of the buffers in the list is based primarily on how recently each
+buffer has been displayed in the selected window.  Buffers move to the
+front of the list when they are selected and to the end when they are
+buried.  Several functions, notably @code{other-buffer}, use this
+ordering.  A buffer list displayed for the user also follows this order.
+
+@defun buffer-list
+This function returns a list of all buffers, including those whose names
+begin with a space.  The elements are actual buffers, not their names.
+
+@example
+@group
+(buffer-list)
+     @result{} (#<buffer buffers.texi>
+         #<buffer  *Minibuf-1*> #<buffer buffer.c>
+         #<buffer *Help*> #<buffer TAGS>)
+@end group
+
+@group
+;; @r{Note that the name of the minibuffer}
+;;   @r{begins with a space!}
+(mapcar (function buffer-name) (buffer-list))
+    @result{} ("buffers.texi" " *Minibuf-1*" 
+        "buffer.c" "*Help*" "TAGS")
+@end group
+@end example
+
+This list is a copy of a list used inside Emacs; modifying it has no
+effect on the ordering of buffers.
+@end defun
+
+@defun other-buffer &optional buffer-or-name visible-ok
+This function returns the first buffer in the buffer list other than
+@var{buffer-or-name}.  Usually this is the buffer most recently shown in
+the selected window, aside from @var{buffer-or-name}.  Buffers whose
+names start with a space are not considered.
+
+If @var{buffer-or-name} is not supplied (or if it is not a buffer),
+then @code{other-buffer} returns the first buffer on the buffer list
+that is not visible in any window in a visible frame.
+
+@c Emacs 19 feature
+If @var{visible-ok} is @code{nil}, @code{other-buffer} avoids returning
+a buffer visible in any window on any visible frame, except as a last
+resort.   If @var{visible-ok} is non-@code{nil}, then it does not matter
+whether a buffer is displayed somewhere or not.
+
+If no suitable buffer exists, the buffer @samp{*scratch*} is returned
+(and created, if necessary).
+@end defun
+
+@deffn Command bury-buffer &optional buffer-or-name
+This function puts @var{buffer-or-name} at the end of the buffer list
+without changing the order of any of the other buffers on the list.
+This buffer therefore becomes the least desirable candidate for
+@code{other-buffer} to return.
+
+If @var{buffer-or-name} is @code{nil} or omitted, this means to bury
+the current buffer.  In addition, this switches to some other buffer
+(obtained using @code{other-buffer}) in the selected window.  If the
+buffer is displayed in a window other than the selected one, it remains
+there.
+
+If you wish to replace a buffer in all the windows that display it, use
+@code{replace-buffer-in-windows}.  @xref{Buffers and Windows}.
+@end deffn
+
+@node Creating Buffers
+@section Creating Buffers
+@cindex creating buffers
+@cindex buffers, creating
+
+  This section describes the two primitives for creating buffers.
+@code{get-buffer-create} creates a buffer if it finds no existing
+buffer; @code{generate-new-buffer} always creates a new buffer, and
+gives it a unique name.
+
+  Other functions you can use to create buffers include
+@code{with-output-to-temp-buffer} (@pxref{Temporary Displays}) and
+@code{create-file-buffer} (@pxref{Visiting Files}).  Starting a
+subprocess can also create a buffer (@pxref{Processes}).
+
+@defun get-buffer-create name
+This function returns a buffer named @var{name}.  It returns an existing
+buffer with that name, if one exists; otherwise, it creates a new
+buffer.  The buffer does not become the current buffer---this function
+does not change which buffer is current.
+
+An error is signaled if @var{name} is not a string.
+
+@example
+@group
+(get-buffer-create "foo")
+     @result{} #<buffer foo>
+@end group
+@end example
+
+The major mode for the new buffer is set according to the variable
+@code{default-major-mode}.  @xref{Auto Major Mode}.
+@end defun
+
+@defun generate-new-buffer name
+This function returns a newly created, empty buffer, but does not make
+it current.  If there is no buffer named @var{name}, then that is the
+name of the new buffer.  If that name is in use, this function adds
+suffixes of the form @samp{<@var{n}>} are added to @var{name}, where
+@var{n} is an integer.  It tries successive integers starting with 2
+until it finds an available name.
+
+An error is signaled if @var{name} is not a string.
+
+@example
+@group
+(generate-new-buffer "bar")
+     @result{} #<buffer bar>
+@end group
+@group
+(generate-new-buffer "bar")
+     @result{} #<buffer bar<2>>
+@end group
+@group
+(generate-new-buffer "bar")
+     @result{} #<buffer bar<3>>
+@end group
+@end example
+
+The major mode for the new buffer is set by the value of
+@code{default-major-mode}.  @xref{Auto Major Mode}.
+
+See the related function @code{generate-new-buffer-name} in @ref{Buffer
+Names}.
+@end defun
+
+@node Killing Buffers
+@section Killing Buffers
+@cindex killing buffers
+@cindex buffers, killing
+
+  @dfn{Killing a buffer} makes its name unknown to Emacs and makes its
+space available for other use.
+
+  The buffer object for the buffer which has been killed remains in
+existence as long as anything refers to it, but it is specially marked
+so that you cannot make it current or display it.  Killed buffers retain
+their identity, however; two distinct buffers, when killed, remain
+distinct according to @code{eq}.
+
+  If you kill a buffer that is current or displayed in a window, Emacs
+automatically selects or displays some other buffer instead.  This means
+that killing a buffer can in general change the current buffer.
+Therefore, when you kill a buffer, you should also take the precautions
+associated with changing the current buffer (unless you happen to know
+that the buffer being killed isn't current).  @xref{Current Buffer}.
+
+  The @code{buffer-name} of a killed buffer is @code{nil}.  You can use
+this feature to test whether a buffer has been killed:
+
+@example
+@group
+(defun buffer-killed-p (buffer)
+  "Return t if BUFFER is killed."
+  (not (buffer-name buffer)))
+@end group
+@end example
+
+@deffn Command kill-buffer buffer-or-name
+This function kills the buffer @var{buffer-or-name}, freeing all its
+memory for use as space for other buffers.  (Emacs version 18 and older
+was unable to return the memory to the operating system.)  It returns
+@code{nil}.
+
+Any processes that have this buffer as the @code{process-buffer} are
+sent the @code{SIGHUP} signal, which normally causes them to terminate.
+(The basic meaning of @code{SIGHUP} is that a dialup line has been
+disconnected.)  @xref{Deleting Processes}.
+
+If the buffer is visiting a file and contains unsaved changes,
+@code{kill-buffer} asks the user to confirm before the buffer is killed.
+It does this even if not called interactively.  To prevent the request
+for confirmation, clear the modified flag before calling
+@code{kill-buffer}.  @xref{Buffer Modification}.
+
+@vindex kill-buffer-query-functions
+You can program additional requests for confirmation.  After confirming
+unsaved changes, @code{kill-buffer} calls the functions in the list
+@code{kill-buffer-query-functions}, in order of appearance, with no
+arguments.  The buffer being killed is the current buffer when they are
+called.  The idea is that these functions ask for confirmation from the
+user for various nonstandard reasons.  If any of them returns
+non-@code{nil}, the buffer is not killed.
+
+@c Emacs 19 feature
+@vindex kill-buffer-hook
+Just before actually killing the buffer, after asking all questions,
+@code{kill-buffer} runs the normal hook @code{kill-buffer-hook}.  The
+buffer to be killed is current when the hook functions run.
+@xref{Hooks}.
+
+Killing a buffer that is already dead has no effect.
+
+@smallexample
+(kill-buffer "foo.unchanged")
+     @result{} nil
+(kill-buffer "foo.changed")
+
+---------- Buffer: Minibuffer ----------
+Buffer foo.changed modified; kill anyway? (yes or no) @kbd{yes}
+---------- Buffer: Minibuffer ----------
+
+     @result{} nil
+@end smallexample
+@end deffn
+
+@node Current Buffer
+@section The Current Buffer
+@cindex selecting a buffer
+@cindex changing to another buffer
+@cindex current buffer
+
+  There are, in general, many buffers in an Emacs session.  At any time,
+one of them is designated as the @dfn{current buffer}.  This is the
+buffer in which most editing takes place, because most of the primitives
+for examining or changing text in a buffer operate implicitly on the
+current buffer (@pxref{Text}).  Normally the buffer that is displayed on
+the screen in the selected window is the current buffer, but this is not
+always so: a Lisp program can designate any buffer as current
+temporarily in order to operate on its contents, without changing what
+is displayed on the screen.
+
+  The way to designate a current buffer in a Lisp program is by calling
+@code{set-buffer}.  The specified buffer remains current until a new one
+is designated.
+
+  When an editing command returns to the editor command loop, the
+command loop designates the buffer displayed in the selected window as
+current, to prevent confusion: the buffer that the cursor is in, when
+Emacs reads a command, is the one to which the command will apply.
+(@xref{Command Loop}.)  Therefore, @code{set-buffer} is not the way to
+switch visibly to a different buffer so that the user can edit it.  For
+this, you must use the functions described in @ref{Displaying Buffers}.
+
+  However, Lisp functions that change to a different current buffer
+should not depend on the command loop to set it back afterwards.
+Editing commands written in Emacs Lisp can be called from other programs
+as well as from the command loop.  It is convenient for the caller if
+the subroutine does not change which buffer is current (unless, of
+course, that is the subroutine's purpose).  Therefore, you should
+normally use @code{set-buffer} within a @code{save-excursion} that will
+restore the current buffer when your function is done
+(@pxref{Excursions}).  Here is an example, the code for the command
+@code{append-to-buffer} (with the documentation string abridged):
+
+@example
+@group
+(defun append-to-buffer (buffer start end)
+  "Append to specified buffer the text of the region.
+@dots{}"
+  (interactive "BAppend to buffer: \nr")
+  (let ((oldbuf (current-buffer)))
+    (save-excursion
+      (set-buffer (get-buffer-create buffer))
+      (insert-buffer-substring oldbuf start end))))
+@end group
+@end example
+
+@noindent
+This function binds a local variable to the current buffer, and then
+@code{save-excursion} records the values of point, the mark, and the
+original buffer.  Next, @code{set-buffer} makes another buffer current.
+Finally, @code{insert-buffer-substring} copies the string from the
+original current buffer to the new current buffer.
+
+  If the buffer appended to happens to be displayed in some window, 
+the next redisplay will show how its text has changed.  Otherwise, you
+will not see the change immediately on the screen.  The buffer becomes
+current temporarily during the execution of the command, but this does
+not cause it to be displayed.
+
+  If you make local bindings (with @code{let} or function arguments) for
+a variable that may also have buffer-local bindings, make sure that the
+same buffer is current at the beginning and at the end of the local
+binding's scope.  Otherwise you might bind it in one buffer and unbind
+it in another!  There are two ways to do this.  In simple cases, you may
+see that nothing ever changes the current buffer within the scope of the
+binding.  Otherwise, use @code{save-excursion} to make sure that the
+buffer current at the beginning is current again whenever the variable
+is unbound.
+
+  It is not reliable to change the current buffer back with
+@code{set-buffer}, because that won't do the job if a quit happens while
+the wrong buffer is current.  Here is what not to do:
+
+@example
+@group
+(let (buffer-read-only
+      (obuf (current-buffer)))
+  (set-buffer @dots{})
+  @dots{}
+  (set-buffer obuf))
+@end group
+@end example
+
+@noindent
+Using  @code{save-excursion}, as shown below, handles quitting, errors
+and @code{throw} as well as ordinary evaluation.
+
+@example
+@group
+(let (buffer-read-only)
+  (save-excursion
+    (set-buffer @dots{})
+    @dots{}))
+@end group
+@end example
+
+@defun current-buffer
+This function returns the current buffer.
+
+@example
+@group
+(current-buffer)
+     @result{} #<buffer buffers.texi>
+@end group
+@end example
+@end defun
+
+@defun set-buffer buffer-or-name
+This function makes @var{buffer-or-name} the current buffer.  It does
+not display the buffer in the currently selected window or in any other
+window, so the user cannot necessarily see the buffer.  But Lisp
+programs can in any case work on it.
+
+This function returns the buffer identified by @var{buffer-or-name}.
+An error is signaled if @var{buffer-or-name} does not identify an
+existing buffer.
+@end defun
diff --git a/lispref/windows.texi b/lispref/windows.texi
new file mode 100644
index 00000000000..a859fd9cf20
--- /dev/null
+++ b/lispref/windows.texi
@@ -0,0 +1,1592 @@
+@c -*-texinfo-*-
+@c This is part of the GNU Emacs Lisp Reference Manual.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. 
+@c See the file elisp.texi for copying conditions.
+@setfilename ../info/windows
+@node Windows, Frames, Buffers, Top
+@chapter Windows
+
+  This chapter describes most of the functions and variables related to
+Emacs windows.  See @ref{Display}, for information on how text is
+displayed in windows.
+
+@menu
+* Basic Windows::          Basic information on using windows.
+* Splitting Windows::      Splitting one window into two windows.
+* Deleting Windows::       Deleting a window gives its space to other windows.
+* Selecting Windows::      The selected window is the one that you edit in.
+* Cyclic Window Ordering:: Moving around the existing windows.
+* Buffers and Windows::    Each window displays the contents of a buffer.
+* Displaying Buffers::     Higher-lever functions for displaying a buffer
+                             and choosing a window for it.
+* Choosing Window::        How to choose a window for displaying a buffer.
+* Window Point::           Each window has its own location of point.
+* Window Start::           The display-start position controls which text
+                             is on-screen in the window. 
+* Vertical Scrolling::     Moving text up and down in the window.
+* Horizontal Scrolling::   Moving text sideways on the window.
+* Size of Window::         Accessing the size of a window.
+* Resizing Windows::       Changing the size of a window.
+* Coordinates and Windows::Converting coordinates to windows.
+* Window Configurations::  Saving and restoring the state of the screen.
+@end menu
+
+@node Basic Windows
+@section Basic Concepts of Emacs Windows
+@cindex window
+@cindex selected window
+
+  A @dfn{window} is the physical area of the screen in which a buffer is
+displayed.  The term is also used to refer to a Lisp object which
+represents that screen area in Emacs Lisp.  It should be
+clear from the context which is meant.
+
+  There is always at least one window in any frame.  In each frame, at
+any time, one and only one window is designated as @dfn{selected within
+the frame}.  The frame's cursor appears in that window.  There is also
+one selected frame; and the window selected within that frame is
+@dfn{the selected window}.  The selected window's buffer is usually the
+current buffer (except when @code{set-buffer} has been used).
+@xref{Current Buffer}.
+
+  For all intents, a window only exists while it is displayed on the
+terminal.  Once removed from the display, the window is effectively
+deleted and should not be used, @emph{even though there may still be
+references to it} from other Lisp objects.  Restoring a saved window
+configuration is the only way for a window no longer on the screen to
+come back to life.  (@xref{Deleting Windows}.)
+
+  Each window has the following attributes:
+
+@itemize @bullet
+@item
+containing frame
+
+@item 
+window height
+
+@item 
+window width
+
+@item 
+window edges with respect to the screen or frame
+
+@item 
+the buffer it displays
+
+@item 
+position within the buffer at the upper left of the window
+
+@item 
+the amount of horizontal scrolling, in columns
+
+@item 
+point
+
+@item 
+the mark
+
+@item 
+how recently the window was selected
+@end itemize
+
+@cindex multiple windows
+  Users create multiple windows so they can look at several buffers at
+once.  Lisp libraries use multiple windows for a variety of reasons, but
+most often to give different views of the same information.  In Rmail,
+for example, you can move through a summary buffer in one window while
+the other window shows messages one at a time as they are reached.
+
+  The meaning of ``window'' in Emacs is similar to what it means in the
+context of general purpose window systems such as X, but not identical.
+The X Window System subdivides the screen into X windows; Emacs uses one
+or more X windows, called @dfn{frames} in Emacs terminology, and
+subdivides each of them into (nonoverlapping) Emacs windows.  When you
+use Emacs on an ordinary display terminal, Emacs subdivides the terminal
+screen into Emacs windows.
+
+@cindex terminal screen
+@cindex screen of terminal
+@cindex tiled windows
+  Most window systems support arbitrarily located overlapping windows.
+In contrast, Emacs windows are @dfn{tiled}; they never overlap, and
+together they fill the whole of the screen or frame.  Because of the way
+in which Emacs creates new windows and resizes them, you can't create
+every conceivable tiling of windows on an Emacs frame.  @xref{Splitting
+Windows}, and @ref{Size of Window}.
+
+  @xref{Display}, for information on how the contents of the
+window's buffer are displayed in the window.
+
+@defun windowp object
+  This function returns @code{t} if @var{object} is a window.
+@end defun
+
+@node Splitting Windows
+@section Splitting Windows
+@cindex splitting windows
+@cindex window splitting
+
+  The functions described here are the primitives used to split a window
+into two windows.  Two higher level functions sometimes split a window,
+but not always: @code{pop-to-buffer} and @code{display-buffer}
+(@pxref{Displaying Buffers}).
+
+  The functions described here do not accept a buffer as an argument.
+The two ``halves'' of the split window initially display the same buffer
+previously visible in the window that was split.
+
+@deffn Command split-window &optional window size horizontal
+This function splits @var{window} into two windows.  The original
+window @var{window} remains the selected window, but occupies only
+part of its former screen area.  The rest is occupied by a newly created
+window which is returned as the value of this function.
+
+  If @var{horizontal} is non-@code{nil}, then @var{window} splits into
+two side by side windows.  The original window @var{window} keeps the
+leftmost @var{size} columns, and gives the rest of the columns to the
+new window.  Otherwise, it splits into windows one above the other, and
+@var{window} keeps the upper @var{size} lines and gives the rest of the
+lines to the new window.  The original window is therefore the
+right-hand or upper of the two, and the new window is the left-hand or
+lower.
+
+  If @var{window} is omitted or @code{nil}, then the selected window is
+split.  If @var{size} is omitted or @code{nil}, then @var{window} is
+divided evenly into two parts.  (If there is an odd line, it is
+allocated to the new window.)  When @code{split-window} is called
+interactively, all its arguments are @code{nil}.
+
+  The following example starts with one window on a screen that is 50
+lines high by 80 columns wide; then the window is split.
+
+@smallexample
+@group
+(setq w (selected-window))
+     @result{} #<window 8 on windows.texi>
+(window-edges)          ; @r{Edges in order:}
+     @result{} (0 0 80 50)     ;   @r{left--top--right--bottom}
+@end group
+
+@group
+;; @r{Returns window created}
+(setq w2 (split-window w 15))   
+     @result{} #<window 28 on windows.texi>
+@end group
+@group
+(window-edges w2)
+     @result{} (0 15 80 50)    ; @r{Bottom window;}
+                        ;   @r{top is line 15}
+@end group
+@group
+(window-edges w)
+     @result{} (0 0 80 15)     ; @r{Top window}
+@end group
+@end smallexample
+
+The screen looks like this:
+
+@smallexample
+@group
+         __________ 
+        |          |  line 0  
+        |    w     |
+        |__________|
+        |          |  line 15
+        |    w2    |
+        |__________|
+                      line 50
+ column 0   column 80
+@end group
+@end smallexample
+
+Next, the top window is split horizontally:
+
+@smallexample
+@group
+(setq w3 (split-window w 35 t))
+     @result{} #<window 32 on windows.texi>
+@end group
+@group
+(window-edges w3)
+     @result{} (35 0 80 15)  ; @r{Left edge at column 35}
+@end group
+@group
+(window-edges w)
+     @result{} (0 0 35 15)   ; @r{Right edge at column 35}
+@end group
+@group
+(window-edges w2)
+     @result{} (0 15 80 50)  ; @r{Bottom window unchanged}
+@end group
+@end smallexample
+
+Now, the screen looks like this:
+
+@smallexample
+@group
+     column 35
+         __________ 
+        |   |      |  line 0  
+        | w |  w3  |
+        |___|______|
+        |          |  line 15
+        |    w2    |
+        |__________|
+                      line 50
+ column 0   column 80
+@end group
+@end smallexample
+@end deffn
+
+@deffn Command split-window-vertically size
+This function splits the selected window into two windows, one above
+the other, leaving the selected window with @var{size} lines.
+
+This function is simply an interface to @code{split-windows}.
+Here is the complete function definition for it:
+
+@smallexample
+@group
+(defun split-window-vertically (&optional arg)
+  "Split current window into two windows, one above the other."
+  (interactive "P")
+  (split-window nil (and arg (prefix-numeric-value arg))))
+@end group
+@end smallexample
+@end deffn
+
+@deffn Command split-window-horizontally size
+This function splits the selected window into two windows
+side-by-side, leaving the selected window with @var{size} columns.
+
+This function is simply an interface to @code{split-windows}.  Here is
+the complete definition for @code{split-window-horizontally} (except for
+part of the documentation string):
+
+@smallexample
+@group
+(defun split-window-horizontally (&optional arg)
+  "Split selected window into two windows, side by side..."
+  (interactive "P")
+  (split-window nil (and arg (prefix-numeric-value arg)) t))
+@end group
+@end smallexample
+@end deffn
+
+@defun one-window-p &optional no-mini all-frames
+This function returns non-@code{nil} if there is only one window.  The
+argument @var{no-mini}, if non-@code{nil}, means don't count the
+minibuffer even if it is active; otherwise, the minibuffer window is
+included, if active, in the total number of windows which is compared
+against one.
+
+The argument @var{all-frames} specifies which frames to consider.  Here
+are the possible values and their meanings:
+
+@table @asis
+@item @code{nil}
+Count the windows in the selected frame, plus the minibuffer used
+by that frame even if it lies in some other frame.
+
+@item @code{t}
+Count all windows in all existing frames.
+
+@item @code{visible}
+Count all windows in all visible frames.
+
+@item anything else
+Count precisely the windows in the selected frame, and no others.
+@end table
+@end defun
+
+@node Deleting Windows
+@section Deleting Windows
+@cindex deleting windows
+
+A window remains visible on its frame unless you @dfn{delete} it by
+calling certain functions that delete windows.  A deleted window cannot
+appear on the screen, but continues to exist as a Lisp object until
+there are no references to it.  There is no way to cancel the deletion
+of a window aside from restoring a saved window configuration
+(@pxref{Window Configurations}).  Restoring a window configuration also
+deletes any windows that aren't part of that configuration.
+
+  When you delete a window, the space it took up is given to one
+adjacent sibling.  (In Emacs version 18, the space was divided evenly
+among all the siblings.)
+
+@c Emacs 19 feature
+@defun window-live-p window
+This function returns @code{nil} if @var{window} is deleted, and
+@code{t} otherwise.
+
+@strong{Warning:} erroneous information or fatal errors may result from
+using a deleted window as if it were live.
+@end defun
+
+@deffn Command delete-window &optional window
+This function removes @var{window} from the display.  If @var{window}
+is omitted, then the selected window is deleted.  An error is signaled
+if there is only one window when @code{delete-window} is called.
+
+This function returns @code{nil}.
+
+When @code{delete-window} is called interactively, @var{window}
+defaults to the selected window.
+@end deffn
+
+@deffn Command delete-other-windows &optional window
+This function makes @var{window} the only window on its frame, by
+deleting the other windows in that frame.  If @var{window} is omitted or
+@code{nil}, then the selected window is used by default.
+
+The result is @code{nil}.
+@end deffn
+
+@deffn Command delete-windows-on buffer &optional frame
+This function deletes all windows showing @var{buffer}.  If there are
+no windows showing @var{buffer}, it does nothing.
+
+@code{delete-windows-on} operates frame by frame.  If a frame has
+several windows showing different buffers, then those showing
+@var{buffer} are removed, and the others expand to fill the space.  If
+all windows in some frame are showing @var{buffer} (including the case
+where there is only one window), then the frame reverts to having a
+single window showing another buffer chosen with @code{other-buffer}.
+@xref{The Buffer List}.
+
+The argument @var{frame} controls which frames to operate on:
+
+@itemize @bullet
+@item
+If it is @code{nil}, operate on the selected frame.
+@item
+If it is @code{t}, operate on all frames.
+@item
+If it is @code{visible}, operate on all visible frames.
+@item
+If it is a frame, operate on that frame.
+@end itemize
+
+This function always returns @code{nil}.
+@end deffn
+
+@node Selecting Windows
+@section Selecting Windows
+@cindex selecting windows
+
+  When a window is selected, the buffer in the window becomes the current
+buffer, and the cursor will appear in it.
+
+@defun selected-window
+This function returns the selected window.  This is the window in
+which the cursor appears and to which many commands apply.
+@end defun
+
+@defun select-window window
+This function makes @var{window} the selected window.  The cursor then
+appears in @var{window} (on redisplay).  The buffer being displayed in
+@var{window} is immediately designated the current buffer.
+
+The return value is @var{window}.
+
+@example
+@group
+(setq w (next-window))
+(select-window w)
+     @result{} #<window 65 on windows.texi>
+@end group
+@end example
+@end defun
+
+@cindex finding windows
+  The following functions choose one of the windows on the screen,
+offering various criteria for the choice.
+
+@defun get-lru-window &optional frame
+This function returns the window least recently ``used'' (that is,
+selected).  The selected window is always the most recently used window.
+
+The selected window can be the least recently used window if it is the
+only window.  A newly created window becomes the least recently used
+window until it is selected.  A minibuffer window is never a candidate.
+
+The argument @var{frame} controls which set of windows are
+considered.
+
+@itemize @bullet
+@item
+If it is @code{nil}, consider windows on the selected frame.
+@item
+If it is @code{t}, consider windows on all frames.
+@item
+If it is @code{visible}, consider windows on all visible frames.
+@item
+If it is a frame, consider windows on that frame.
+@end itemize
+@end defun
+
+@defun get-largest-window &optional frame
+This function returns the window with the largest area (height times
+width).  If there are no side-by-side windows, then this is the window
+with the most lines.  A minibuffer window is never a candidate.
+
+If there are two windows of the same size, then the function returns
+the window which is first in the cyclic ordering of windows (see
+following section), starting from the selected window.
+
+The argument @var{frame} controls which set of windows are
+considered.  See @code{get-lru-window}, above.
+@end defun
+
+@node Cyclic Window Ordering
+@comment  node-name,  next,  previous,  up
+@section Cyclic Ordering of Windows
+@cindex cyclic ordering of windows
+@cindex ordering of windows, cyclic
+@cindex window ordering, cyclic 
+
+  When you use the command @kbd{C-x o} (@code{other-window}) to select
+the next window, it moves through all the windows on the screen in a
+specific cyclic order.  For any given configuration of windows, this
+order never varies.  It is called the @dfn{cyclic ordering of windows}.
+
+  This ordering generally goes from top to bottom, and from left to
+right.  But it may go down first or go right first, depending on the
+order in which the windows were split.
+
+  If the first split was vertical (into windows one above each other),
+and then the subwindows were split horizontally, then the ordering is
+left to right in the top of the frame, and then left to right in the
+next lower part of the frame, and so on.  If the first split was
+horizontal, the ordering is top to bottom in the left part, and so on.
+In general, within each set of siblings at any level in the window tree,
+the order is left to right, or top to bottom.
+
+@defun next-window &optional window minibuf all-frames
+@cindex minibuffer window
+This function returns the window following @var{window} in the cyclic
+ordering of windows.  This is the window which @kbd{C-x o} would select
+if done when @var{window} is selected.  If @var{window} is the only
+window visible, then this function returns @var{window}.  If omitted,
+@var{window} defaults to the selected window.
+
+The value of the argument @var{minibuf} determines whether the
+minibuffer is included in the window order.  Normally, when
+@var{minibuf} is @code{nil}, the minibuffer is included if it is
+currently active; this is the behavior of @kbd{C-x o}.  (The minibuffer
+window is active while the minibuffer is in use.  @xref{Minibuffers}.)
+
+If @var{minibuf} is @code{t}, then the cyclic ordering includes the
+minibuffer window even if it is not active.
+
+If @var{minibuf} is neither @code{t} nor @code{nil}, then the minibuffer
+window is not included even if it is active.
+
+The argument @var{all-frames} specifies which frames to consider.  Here
+are the possible values and their meanings:
+
+@table @asis
+@item @code{nil}
+Consider all the windows in @var{window}'s frame, plus the minibuffer
+used by that frame even if it lies in some other frame.
+
+@item @code{t}
+Consider all windows in all existing frames.
+
+@item @code{visible}
+Consider all windows in all visible frames.  (To get useful results, you
+must ensure @var{window} is in a visible frame.)
+
+@item anything else
+Consider precisely the windows in @var{window}'s frame, and no others.
+@end table
+
+This example assumes there are two windows, both displaying the 
+buffer @samp{windows.texi}:
+
+@example
+@group
+(selected-window)
+     @result{} #<window 56 on windows.texi>
+@end group
+@group
+(next-window (selected-window))
+     @result{} #<window 52 on windows.texi>
+@end group
+@group
+(next-window (next-window (selected-window)))
+     @result{} #<window 56 on windows.texi>
+@end group
+@end example
+@end defun
+
+@defun previous-window &optional window minibuf all-frames
+This function returns the window preceding @var{window} in the cyclic
+ordering of windows.  The other arguments specify which windows to
+include in the cycle, as in @code{next-window}.
+@end defun
+
+@deffn Command other-window count
+This function selects the @var{count}th following window in the cyclic
+order.  If count is negative, then it selects the @minus{}@var{count}th
+preceding window.  It returns @code{nil}.
+
+In an interactive call, @var{count} is the numeric prefix argument.
+@end deffn
+
+@c Emacs 19 feature
+@defun walk-windows proc &optional minibuf all-frames
+This function cycles through all windows, calling @code{proc}
+once for each window with the window as its sole argument.
+
+The optional arguments @var{minibuf} and @var{all-frames} specify the
+set of windows to include in the scan.  See @code{next-window}, above,
+for details.
+@end defun
+
+@node Buffers and Windows
+@section Buffers and Windows
+@cindex examining windows
+@cindex windows, controlling precisely
+@cindex buffers, controlled in windows
+
+  This section describes low-level functions to examine windows or to
+display buffers in windows in a precisely controlled fashion.
+@iftex
+See the following section for
+@end iftex
+@ifinfo
+@xref{Displaying Buffers}, for
+@end ifinfo
+related functions that find a window to use and specify a buffer for it.
+The functions described there are easier to use than these, but they
+employ heuristics in choosing or creating a window; use these functions
+when you need complete control.
+
+@defun set-window-buffer window buffer-or-name
+This function makes @var{window} display @var{buffer-or-name} as its
+contents.  It returns @code{nil}.
+
+@example
+@group
+(set-window-buffer (selected-window) "foo")
+     @result{} nil
+@end group
+@end example
+@end defun
+
+@defun window-buffer &optional window
+This function returns the buffer that @var{window} is displaying.  If
+@var{window} is omitted, this function returns the buffer for the
+selected window.
+
+@example
+@group
+(window-buffer)
+     @result{} #<buffer windows.texi>
+@end group
+@end example
+@end defun
+
+@defun get-buffer-window buffer-or-name &optional all-frames
+This function returns a window currently displaying
+@var{buffer-or-name}, or @code{nil} if there is none.  If there are
+several such windows, then the function returns the first one in the
+cyclic ordering of windows, starting from the selected window.
+@xref{Cyclic Window Ordering}.
+
+The argument @var{all-frames} controls which windows to consider.
+
+@itemize @bullet
+@item
+If it is @code{nil}, consider windows on the selected frame.
+@item
+If it is @code{t}, consider windows on all frames.
+@item
+If it is @code{visible}, consider windows on all visible frames.
+@item
+If it is a frame, consider windows on that frame.
+@end itemize
+@end defun
+
+@deffn Command replace-buffer-in-windows buffer
+This function replaces @var{buffer} with some other buffer in all
+windows displaying it.  The other buffer used is chosen with
+@code{other-buffer}.  In the usual applications of this function, you
+don't care which other buffer is used; you just want to make sure that
+@var{buffer} is no longer displayed.
+
+This function returns @code{nil}.
+@end deffn
+
+@node Displaying Buffers
+@section Displaying Buffers in Windows
+@cindex switching to a buffer
+@cindex displaying a buffer
+
+  In this section we describe convenient functions that choose a window
+automatically and use it to display a specified buffer.  These functions
+can also split an existing window in certain circumstances.  We also
+describe variables that parameterize the heuristics used for choosing a
+window.
+@iftex
+See the preceding section for
+@end iftex
+@ifinfo
+@xref{Buffers and Windows}, for
+@end ifinfo
+low-level functions that give you more precise control.
+
+  Do not use the functions in this section in order to make a buffer
+current so that a Lisp program can access or modify it; they are too
+drastic for that purpose, since they change the display of buffers in
+windows, which is gratuitous and will surprise the user.  Instead, use
+@code{set-buffer} (@pxref{Current Buffer}) and @code{save-excursion}
+(@pxref{Excursions}), which designate buffers as current for programmed
+access without affecting the display of buffers in windows.
+
+@deffn Command switch-to-buffer buffer-or-name &optional norecord
+This function makes @var{buffer-or-name} the current buffer, and also
+displays the buffer in the selected window.  This means that a human can
+see the buffer and subsequent keyboard commands will apply to it.
+Contrast this with @code{set-buffer}, which makes @var{buffer-or-name}
+the current buffer but does not display it in the selected window.
+@xref{Current Buffer}.
+
+If @var{buffer-or-name} does not identify an existing buffer, then
+a new buffer by that name is created.
+
+Normally the specified buffer is put at the front of the buffer list.
+This affects the operation of @code{other-buffer}.  However, if
+@var{norecord} is non-@code{nil}, this is not done.  @xref{The Buffer
+List}.
+
+The @code{switch-to-buffer} function is often used interactively, as
+the binding of @kbd{C-x b}.  It is also used frequently in programs.  It
+always returns @code{nil}.
+@end deffn
+
+@deffn Command switch-to-buffer-other-window buffer-or-name
+This function makes @var{buffer-or-name} the current buffer and
+displays it in a window not currently selected.  It then selects that
+window.  The handling of the buffer is the same as in
+@code{switch-to-buffer}.
+
+The previously selected window is absolutely never used to display the
+buffer.  If it is the only window, then it is split to make a distinct
+window for this purpose.  If the selected window is already displaying
+the buffer, then it continues to do so, but another window is
+nonetheless found to display it in as well.
+@end deffn
+
+@defun pop-to-buffer buffer-or-name &optional other-window
+This function makes @var{buffer-or-name} the current buffer and
+switches to it in some window, preferably not the window previously
+selected.  The ``popped-to'' window becomes the selected window within
+its frame.
+
+If the variable @code{pop-up-frames} is non-@code{nil},
+@code{pop-to-buffer} looks for a window in any visible frame already
+displaying the buffer; if there is one, it returns that window and makes
+it be selected within its frame.  If there is none, it creates a new
+frame and displays the buffer in it.
+
+If @code{pop-up-frames} is @code{nil}, then @code{pop-to-buffer}
+operates entirely within the selected frame.  (If the selected frame has
+just a minibuffer, @code{pop-to-buffer} operates within the most
+recently selected frame that was not just a minibuffer.)
+
+If the variable @code{pop-up-windows} is non-@code{nil}, windows may
+be split to create a new window that is different from the original
+window.  For details, see @ref{Choosing Window}.
+
+If @var{other-window} is non-@code{nil}, @code{pop-to-buffer} finds or
+creates another window even if @var{buffer-or-name} is already visible
+in the selected window.  Thus @var{buffer-or-name} could end up
+displayed in two windows.  On the other hand, if @var{buffer-or-name} is
+already displayed in the selected window and @var{other-window} is
+@code{nil}, then the selected window is considered sufficient display
+for @var{buffer-or-name}, so that nothing needs to be done.
+
+If @var{buffer-or-name} is a string that does not name an existing
+buffer, a buffer by that name is created.
+
+An example use of this function is found at the end of @ref{Filter
+Functions}.
+@end defun
+
+@node Choosing Window
+@section Choosing a Window for Display
+
+  This section describes the basic facility which chooses a window to
+display a buffer in---@code{display-buffer}.  All the higher-level
+functions and commands use this subroutine.  Here we describe how to use
+@code{display-buffer} and how to customize it.
+
+@deffn Command display-buffer buffer-or-name &optional not-this-window
+This command makes @var{buffer-or-name} appear in some window, like
+@code{pop-to-buffer}, but it does not select that window and does not
+make the buffer current.  The identity of the selected window is
+unaltered by this function.
+
+If @var{not-this-window} is non-@code{nil}, it means to display the
+specified buffer in a window other than the selected one, even if it is
+already on display in the selected window.  This can cause the buffer to
+appear in two windows at once.  Otherwise, if @var{buffer-or-name} is
+already being displayed in any window, that is good enough, so this
+function does nothing.
+
+@code{display-buffer} returns the window chosen to display
+@var{buffer-or-name}.
+
+Precisely how @code{display-buffer} finds or creates a window depends on
+the variables described below.
+@end deffn
+
+@defopt pop-up-windows
+This variable controls whether @code{display-buffer} makes new windows.
+If it is non-@code{nil} and there is only one window, then that window
+is split.  If it is @code{nil}, then @code{display-buffer} does not
+split the single window, but uses it whole.
+@end defopt
+
+@defopt split-height-threshold
+This variable determines when @code{display-buffer} may split a window,
+if there are multiple windows.  @code{display-buffer} always splits the
+largest window if it has at least this many lines.  If the largest
+window is not this tall, it is split only if it is the sole window and
+@code{pop-up-windows} is non-@code{nil}.
+@end defopt
+
+@c Emacs 19 feature
+@defopt pop-up-frames
+This variable controls whether @code{display-buffer} makes new frames.
+If it is non-@code{nil}, @code{display-buffer} looks for an existing
+window already displaying the desired buffer, on any visible frame.  If
+it finds one, it returns that window.  Otherwise it makes a new frame.
+The variables @code{pop-up-windows} and @code{split-height-threshold} do
+not matter if @code{pop-up-frames} is non-@code{nil}.
+
+If @code{pop-up-frames} is @code{nil}, then @code{display-buffer} either
+splits a window or reuses one.
+
+@xref{Frames}, for more information.
+@end defopt
+
+@c Emacs 19 feature
+@defvar pop-up-frame-function
+This variable specifies how to make a new frame if @code{pop-up-frames}
+is non-@code{nil}.
+
+Its value should be a function of no arguments.  When
+@code{display-buffer} makes a new frame, it does so by calling that
+function, which should return a frame.  The default value of the
+variable is a function which creates a frame using parameters from
+@code{pop-up-frame-alist}.
+@end defvar
+
+@defvar pop-up-frame-alist
+This variable holds an alist specifying frame parameters used when
+@code{display-buffer} makes a new frame.  @xref{Frame Parameters}, for
+more information about frame parameters.
+@end defvar
+
+@c Emacs 19 feature
+@defvar display-buffer-function
+This variable is the most flexible way to customize the behavior of
+@code{display-buffer}.  If it is non-@code{nil}, it should be a function
+that @code{display-buffer} calls to do the work.  The function should
+accept two arguments, the same two arguments that @code{display-buffer}
+received.  It should choose or create a window, display the specified
+buffer, and then return the window.
+
+This hook takes precedence over all the other options and hooks
+described above.
+@end defvar
+
+@c Emacs 19 feature
+@cindex dedicated window
+A window can be marked as ``dedicated'' to its buffer.  Then
+@code{display-buffer} does not try to use that window.
+
+@defun window-dedicated-p window
+This function returns @code{t} if @var{window} is marked as dedicated;
+otherwise @code{nil}.
+@end defun
+
+@defun set-window-dedicated-p window flag
+This function marks @var{window} as dedicated if @var{flag} is
+non-@code{nil}, and nondedicated otherwise.
+@end defun
+
+@node Window Point
+@section Windows and Point
+@cindex window position
+@cindex window point
+@cindex position in window
+@cindex point in window
+
+  Each window has its own value of point, independent of the value of
+point in other windows displaying the same buffer.  This makes it useful
+to have multiple windows showing one buffer.
+
+@itemize @bullet
+@item
+The window point is established when a window is first created; it is
+initialized from the buffer's point, or from the window point of another
+window opened on the buffer if such a window exists.
+
+@item
+Selecting a window sets the value of point in its buffer to the window's
+value of point.  Conversely, deselecting a window sets the window's
+value of point from that of the buffer.  Thus, when you switch between
+windows that display a given buffer, the point value for the selected
+window is in effect in the buffer, while the point values for the other
+windows are stored in those windows.
+
+@item
+As long as the selected window displays the current buffer, the window's
+point and the buffer's point always move together; they remain equal.
+
+@item
+@xref{Positions}, for more details on buffer positions.
+@end itemize
+
+  As far as the user is concerned, point is where the cursor is, and
+when the user switches to another buffer, the cursor jumps to the
+position of point in that buffer.
+
+@defun window-point window
+This function returns the current position of point in @var{window}.
+For a nonselected window, this is the value point would have (in that
+window's buffer) if that window were selected.
+
+When @var{window} is the selected window and its buffer is also the
+current buffer, the value returned is the same as point in that buffer.
+
+Strictly speaking, it would be more correct to return the
+``top-level'' value of point, outside of any @code{save-excursion}
+forms.  But that value is hard to find.
+@end defun
+
+@defun set-window-point window position
+This function positions point in @var{window} at position
+@var{position} in @var{window}'s buffer.
+@end defun
+
+@node Window Start
+@section The Window Start Position
+
+  Each window contains a marker used to keep track of a buffer position
+which specifies where in the buffer display should start.  This position
+is called the @dfn{display-start} position of the window (or just the
+@dfn{start}).  The character after this position is the one that appears
+at the upper left corner of the window.  It is usually, but not
+inevitably, at the beginning of a text line.
+
+@defun window-start &optional window
+@cindex window top line
+This function returns the display-start position of window
+@var{window}.  If @var{window} is @code{nil}, the selected window is
+used.  For example, 
+
+@example
+@group
+(window-start)
+     @result{} 7058
+@end group
+@end example
+
+When you create a window, or display a different buffer in it, the the
+display-start position is set to a display-start position recently used
+for the same buffer, or 1 if the buffer doesn't have any.
+
+For a realistic example, see the description of @code{count-lines} in
+@ref{Text Lines}.
+@end defun
+
+@defun window-end &optional window
+This function returns the position of the end of the display in window
+@var{window}.  If @var{window} is @code{nil}, the selected window is
+used.
+@end defun
+
+@defun set-window-start window position &optional noforce
+This function sets the display-start position of @var{window} to
+@var{position} in @var{window}'s buffer.
+
+The display routines insist that the position of point be visible when a
+buffer is displayed.  Normally, they change the display-start position
+(that is, scroll the window) whenever necessary to make point visible.
+However, if you specify the start position with this function using
+@code{nil} for @var{noforce}, it means you want display to start at
+@var{position} even if that would put the location of point off the
+screen.  If this does place point off screen, the display routines move
+point to the left margin on the middle line in the window.
+
+For example, if point @w{is 1} and you set the start of the window @w{to
+2}, then point would be ``above'' the top of the window.  The display
+routines will automatically move point if it is still 1 when redisplay
+occurs.  Here is an example:
+
+@example
+@group
+;; @r{Here is what @samp{foo} looks like before executing}
+;;   @r{the @code{set-window-start} expression.}
+@end group
+
+@group
+---------- Buffer: foo ----------
+@point{}This is the contents of buffer foo.
+2
+3
+4
+5
+6
+---------- Buffer: foo ----------
+@end group
+
+@group
+(set-window-start
+ (selected-window)
+ (1+ (window-start)))
+@result{} 2
+@end group
+
+@group
+;; @r{Here is what @samp{foo} looks like after executing}
+;;   @r{the @code{set-window-start} expression.}
+---------- Buffer: foo ----------
+his is the contents of buffer foo.
+2
+3
+@point{}4
+5
+6
+---------- Buffer: foo ----------
+@end group
+@end example
+
+If @var{noforce} is non-@code{nil}, and @var{position} would place point
+off screen at the next redisplay, then redisplay computes a new window-start
+position that works well with point, and thus @var{position} is not used.
+
+This function returns @var{position}.
+@end defun
+
+@defun pos-visible-in-window-p &optional position window
+This function returns @code{t} if @var{position} is within the range
+of text currently visible on the screen in @var{window}.  It returns
+@code{nil} if @var{position} is scrolled vertically out of view.  The
+argument @var{position} defaults to the current position of point;
+@var{window}, to the selected window.  Here is an example:
+
+@example
+@group
+(or (pos-visible-in-window-p
+     (point) (selected-window))
+    (recenter 0))
+@end group
+@end example
+
+The @code{pos-visible-in-window-p} function considers only vertical
+scrolling.  If @var{position} is out of view only because @var{window}
+has been scrolled horizontally, @code{pos-visible-in-window-p} returns
+@code{t}.  @xref{Horizontal Scrolling}.
+@end defun
+
+@node Vertical Scrolling
+@section Vertical Scrolling
+@cindex vertical scrolling
+@cindex scrolling vertically
+
+  Vertical scrolling means moving the text up or down in a window.  It
+works by changing the value of the window's display-start location.  It
+may also change the value of @code{window-point} to keep it on the
+screen.
+
+  In the commands @code{scroll-up} and @code{scroll-down}, the directions
+``up'' and ``down'' refer to the motion of the text in the buffer at which
+you are looking through the window.  Imagine that the text is
+written on a long roll of paper and that the scrolling commands move the
+paper up and down.  Thus, if you are looking at text in the middle of a
+buffer and repeatedly call @code{scroll-down}, you will eventually see
+the beginning of the buffer.
+
+  Some people have urged that the opposite convention be used: they
+imagine that the window moves over text that remains in place.  Then
+``down'' commands would take you to the end of the buffer.  This view is
+more consistent with the actual relationship between windows and the
+text in the buffer, but it is less like what the user sees.  The
+position of a window on the terminal does not move, and short scrolling
+commands clearly move the text up or down on the screen.  We have chosen
+names that fit the user's point of view.
+
+  The scrolling functions (aside from @code{scroll-other-window}) have
+unpredictable results if the current buffer is different from the buffer
+that is displayed in the selected window.  @xref{Current Buffer}.
+
+@deffn Command scroll-up &optional count
+This function scrolls the text in the selected window upward
+@var{count} lines.  If @var{count} is negative, scrolling is actually
+downward.
+
+If @var{count} is @code{nil} (or omitted), then the length of scroll
+is @code{next-screen-context-lines} lines less than the usable height of
+the window (not counting its mode line).
+
+@code{scroll-up} returns @code{nil}.
+@end deffn
+
+@deffn Command scroll-down &optional count
+This function scrolls the text in the selected window downward
+@var{count} lines.  If @var{count} is negative, scrolling is actually
+upward.
+
+If @var{count} is omitted or @code{nil}, then the length of the scroll
+is @code{next-screen-context-lines} lines less than the usable height of
+the window.
+
+@code{scroll-down} returns @code{nil}.
+@end deffn
+
+@deffn Command scroll-other-window &optional count
+This function scrolls the text in another window upward @var{count}
+lines.  Negative values of @var{count}, or @code{nil}, are handled
+as in @code{scroll-up}.
+
+The window that is scrolled is normally the one following the selected
+window in the cyclic ordering of windows---the window that
+@code{next-window} would return.  @xref{Cyclic Window Ordering}.
+
+You can specify a buffer to scroll with the variable
+@code{other-window-scroll-buffer}.  When the selected window is the
+minibuffer, the next window is normally the one at the top left corner.
+You can specify a different window to scroll with the variable
+@code{minibuffer-scroll-window}.  This variable has no effect when any
+other window is selected.  @xref{Minibuffer Misc}.
+
+When the minibuffer is active, it is the next window if the selected
+window is the one at the bottom right corner.  In this case,
+@code{scroll-other-window} attempts to scroll the minibuffer.  If the
+minibuffer contains just one line, it has nowhere to scroll to, so the
+line reappears after the echo area momentarily displays the message
+``Beginning of buffer''.
+@end deffn
+
+@c Emacs 19 feature
+@defvar other-window-scroll-buffer
+If this variable is non-@code{nil}, it tells @code{scroll-other-window}
+which buffer to scroll.
+@end defvar
+
+@defopt scroll-step
+This variable controls how scrolling is done automatically when point
+moves off the screen.  If the value is zero, then redisplay scrolls the
+text to center point vertically in the window.  If the value is a
+positive integer @var{n}, then redisplay brings point back on screen by
+scrolling @var{n} lines in either direction, if possible; otherwise, it
+centers point if possible.  The default value is zero.
+@end defopt
+
+@defopt next-screen-context-lines
+The value of this variable is the number of lines of continuity to
+retain when scrolling by full screens.  For example, @code{scroll-up}
+with an argument of @code{nil} scrolls so that this many lines at the
+bottom of the window appear instead at the top.  The default value is
+@code{2}.
+@end defopt
+
+@deffn Command recenter &optional count
+@cindex centering point
+This function scrolls the selected window to put the text where point
+is located at a specified vertical position within the window.
+
+If @var{count} is a nonnegative number, it puts the line containing
+point @var{count} lines down from the top of the window.  If @var{count}
+is a negative number, then it counts upward from the bottom of the
+window, so that @minus{}1 stands for the last usable line in the window.
+If @var{count} is a non-@code{nil} list, then it stands for the line in
+the middle of the window.
+
+If @var{count} is @code{nil}, @code{recenter} puts the line containing
+point in the middle of the window, then clears and redisplays the entire
+selected frame.
+
+When @code{recenter} is called interactively, @var{count} is the raw
+prefix argument.  Thus, typing @kbd{C-u} as the prefix sets the
+@var{count} to a non-@code{nil} list, while typing @kbd{C-u 4} sets
+@var{count} to 4, which positions the current line four lines from the
+top.
+
+Typing @kbd{C-u 0 C-l} positions the current line at the top of the
+window.  This action is so handy that some people bind the command to a
+function key.  For example,
+
+@example
+@group
+(defun line-to-top-of-window ()
+  "Scroll current line to top of window.
+Replaces three keystroke sequence C-u 0 C-l."
+  (interactive) 
+  (recenter 0))
+
+(global-set-key "\C-cl" 'line-to-top-of-window)  
+@end group
+@end example
+@end deffn
+
+@node Horizontal Scrolling
+@section Horizontal Scrolling
+@cindex horizontal scrolling
+
+  Because we read English first from top to bottom and second from left
+to right, horizontal scrolling is not like vertical scrolling.  Vertical
+scrolling involves selection of a contiguous portion of text to display.
+Horizontal scrolling causes part of each line to go off screen.  The
+amount of horizontal scrolling is therefore specified as a number of
+columns rather than as a position in the buffer.  It has nothing to do
+with the display-start position returned by @code{window-start}.
+
+  Usually, no horizontal scrolling is in effect; then the leftmost
+column is at the left edge of the window.  In this state, scrolling to
+the right is meaningless, since there is no data to the left of the
+screen to be revealed by it; so this is not allowed.  Scrolling to the
+left is allowed; it scrolls the first columns of text off the edge of
+the window and can reveal additional columns on the right that were
+truncated before.  Once a window has a nonzero amount of leftward
+horizontal scrolling, you can scroll it back to the right, but only so
+far as to reduce the net horizontal scroll to zero.  There is no limit
+to how far left you can scroll, but eventually all the text will
+disappear off the left edge.
+
+@deffn Command scroll-left count
+This function scrolls the selected window @var{count} columns to the
+left (or to the right if @var{count} is negative).  The return value is
+the total amount of leftward horizontal scrolling in effect after the
+change---just like the value returned by @code{window-hscroll}.
+@end deffn
+
+@deffn Command scroll-right count
+This function scrolls the selected window @var{count} columns to the
+right (or to the left if @var{count} is negative).  The return value is
+the total amount of leftward horizontal scrolling in effect after the
+change---just like the value returned by @code{window-hscroll}.
+
+Once you scroll a window as far right as it can go, back to its normal
+position where the total leftward scrolling is zero, attempts to scroll
+any farther right have no effect.
+@end deffn
+
+@defun window-hscroll &optional window
+This function returns the total leftward horizontal scrolling of
+@var{window}---the number of columns by which the text in @var{window}
+is scrolled left past the left margin.
+
+The value is never negative.  It is zero when no horizontal scrolling
+has been done in @var{window} (which is usually the case).
+
+If @var{window} is @code{nil}, the selected window is used.
+
+@example
+@group
+(window-hscroll)
+     @result{} 0
+@end group
+@group
+(scroll-left 5)
+     @result{} 5
+@end group
+@group
+(window-hscroll)
+     @result{} 5
+@end group
+@end example
+@end defun
+
+@defun set-window-hscroll window columns
+This function sets the number of columns from the left margin that
+@var{window} is scrolled to the value of @var{columns}.  The argument
+@var{columns} should be zero or positive; if not, it is taken as zero.
+
+The value returned is @var{columns}.
+
+@example
+@group
+(set-window-hscroll (selected-window) 10)
+     @result{} 10
+@end group
+@end example
+@end defun
+
+  Here is how you can determine whether a given position @var{position}
+is off the screen due to horizontal scrolling:
+
+@example
+@group
+(save-excursion 
+  (goto-char @var{position})
+  (and 
+   (>= (- (current-column) (window-hscroll @var{window})) 0)
+   (< (- (current-column) (window-hscroll @var{window}))
+      (window-width @var{window}))))
+@end group
+@end example
+
+@node Size of Window
+@section The Size of a Window
+@cindex window size
+@cindex size of window
+
+  An Emacs window is rectangular, and its size information consists of
+the height (the number of lines) and the width (the number of character
+positions in each line).  The mode line is included in the height.  But
+the width does not count the scroll bar or the column of @samp{|}
+characters separates side-by-side windows.
+
+  The following three functions return size information about a window:
+
+@defun window-height &optional window
+This function returns the number of lines in @var{window}, including
+its mode line.  If @var{window} fills its entire frame, this is one less
+than the value of @code{frame-height} on that frame (since the last line
+is always reserved for the minibuffer).
+
+If @var{window} is @code{nil}, the function uses the selected window.
+
+@example
+@group
+(window-height)
+     @result{} 23
+@end group
+@group
+(split-window-vertically)
+     @result{} #<window 4 on windows.texi>
+@end group
+@group
+(window-height)
+     @result{} 11
+@end group
+@end example
+@end defun
+
+@defun window-width &optional window
+This function returns the number of columns in @var{window}.  If
+@var{window} fills its entire frame, this is the same as the value of
+@code{frame-width} on that frame.  The width does not include the
+window's scroll bar or the column of @samp{|} characters that separates
+side-by-side windows.
+
+If @var{window} is @code{nil}, the function uses the selected window.
+
+@example
+@group
+(window-width)
+     @result{} 80
+@end group
+@end example
+@end defun
+
+@defun window-edges &optional window
+This function returns a list of the edge coordinates of @var{window}.
+If @var{window} is @code{nil}, the selected window is used.
+
+The order of the list is @code{(@var{left} @var{top} @var{right}
+@var{bottom})}, all elements relative to 0, 0 at the top left corner of
+the frame.  The element @var{right} of the value is one more than the
+rightmost column used by @var{window}, and @var{bottom} is one more than
+the bottommost row used by @var{window} and its mode-line.
+
+When you have side-by-side windows, the right edge value for a window
+with a neighbor on the right includes the width of the separator between
+the window and that neighbor.  This separator may be a column of
+@samp{|} characters or it may be a scroll bar.  Since the width of the
+window does not include this separator, the width does not equal the
+difference between the right and left edges in this case.
+
+Here is the result obtained on a typical 24-line terminal with just one
+window:
+
+@example
+@group
+(window-edges (selected-window))
+     @result{} (0 0 80 23)
+@end group
+@end example
+
+If @var{window} is at the upper left corner of its frame, @var{right}
+and @var{bottom} are the same as the values returned by
+@code{(window-width)} and @code{(window-height)} respectively, and
+@var{top} and @var{bottom} are zero.  For example, the edges of the
+following window are @w{@samp{0 0 5 8}}.  Assuming that the frame has
+more than 8 columns, the last column of the window (column 7) holds a
+border rather than text.  The last row (row 4) holds the mode line,
+shown here with @samp{xxxxxxxxx}.
+
+@example
+@group
+           0    
+           _______
+        0 |       | 
+          |       |   
+          |       | 
+          |       | 
+          xxxxxxxxx  4
+
+                  7  
+@end group
+@end example
+
+When there are side-by-side windows, any window not at the right edge of
+its frame has a separator in its last column or columns.  The separator
+counts as one or two columns in the width of the window.  A window never
+includes a separator on its left, since that belongs to the window to
+the left.
+
+In the following example, let's suppose that the frame is 7
+columns wide.  Then the edges of the left window are @w{@samp{0 0 4 3}}
+and the edges of the right window are @w{@samp{4 0 7 3}}.
+
+@example
+@group
+           ___ ___
+          |   |   |    
+          |   |   |    
+          xxxxxxxxx 
+
+           0  34  7
+@end group
+@end example
+@end defun
+
+@node Resizing Windows
+@section Changing the Size of a Window
+@cindex window resizing
+@cindex changing window size
+@cindex window size, changing
+
+  The window size functions fall into two classes: high-level commands
+that change the size of windows and low-level functions that access
+window size.  Emacs does not permit overlapping windows or gaps between
+windows, so resizing one window affects other windows.
+
+@deffn Command enlarge-window size &optional horizontal
+This function makes the selected window @var{size} lines bigger,
+stealing lines from neighboring windows.  It takes the lines from one
+window at a time until that window is used up, then takes from another.
+If a window from which lines are stolen shrinks below
+@code{window-min-height} lines, that window disappears.
+
+If @var{horizontal} is non-@code{nil}, this function makes
+@var{window} wider by @var{size} columns, stealing columns instead of
+lines.  If a window from which columns are stolen shrinks below
+@code{window-min-width} columns, that window disappears.
+
+If the window's frame is smaller than @var{size} lines (or columns),
+then the function makes the window occupy the entire height (or width)
+of the frame.
+
+If @var{size} is negative, this function shrinks the window by
+@minus{}@var{size} lines or columns.  If that makes the window smaller
+than the minimum size (@code{window-min-height} and
+@code{window-min-width}), @code{enlarge-window} deletes the window.
+
+@code{enlarge-window} returns @code{nil}.  
+@end deffn
+
+@deffn Command enlarge-window-horizontally columns
+This function makes the selected window @var{columns} wider.
+It could be defined as follows:
+
+@example
+@group
+(defun enlarge-window-horizontally (columns)
+  (enlarge-window columns t))
+@end group
+@end example
+@end deffn
+
+@deffn Command shrink-window size &optional horizontal
+This function is like @code{enlarge-window} but negates the argument
+@var{size}, making the selected window smaller by giving lines (or
+columns) to the other windows.  If the window shrinks below
+@code{window-min-height} or @code{window-min-width}, then it disappears.
+
+If @var{size} is negative, the window is enlarged by @minus{}@var{size}
+lines or columns.
+@end deffn
+
+@deffn Command shrink-window-horizontally columns
+This function makes the selected window @var{columns} narrower.
+It could be defined as follows:
+
+@example
+@group
+(defun shrink-window-horizontally (columns)
+  (shrink-window columns t))
+@end group
+@end example
+@end deffn
+
+@cindex minimum window size
+  The following two variables constrain the window size changing
+functions to a minimum height and width.
+
+@defopt window-min-height
+The value of this variable determines how short a window may become
+before it is automatically deleted.  Making a window smaller than
+@code{window-min-height} automatically deletes it, and no window may be
+created shorter than this.  The absolute minimum height is two (allowing
+one line for the mode line, and one line for the buffer display).
+Actions which change window sizes reset this variable to two if it is
+less than two.  The default value is 4.
+@end defopt
+
+@defopt window-min-width
+The value of this variable determines how narrow a window may become
+before it automatically deleted.  Making a window smaller than
+@code{window-min-width} automatically deletes it, and no window may be
+created narrower than this.  The absolute minimum width is one; any
+value below that is ignored.  The default value is 10.
+@end defopt
+
+@node Coordinates and Windows
+@section Coordinates and Windows
+
+This section describes how to compare screen coordinates with windows.
+
+@defun window-at x y &optional frame
+This function returns the window containing the specified cursor
+position in the frame @var{frame}.  The coordinates @var{x} and @var{y}
+are measured in characters and count from the top left corner of the
+frame.  If they are out of range, @code{window-at} returns @code{nil}.
+
+If you omit @var{frame}, the selected frame is used.
+@end defun
+
+@defun coordinates-in-window-p coordinates window
+This function checks whether a particular frame position falls within
+the window @var{window}.
+
+The argument @var{coordinates} is a cons cell of this form:
+
+@example
+(@var{x} . @var{y})
+@end example
+
+@noindent
+The coordinates @var{x} and @var{y} are measured in characters, and
+count from the top left corner of the screen or frame.
+
+The value of @code{coordinates-in-window-p} is non-@code{nil} if the
+coordinates are inside @var{window}.  The value also indicates what part
+of the window the position is in, as follows:
+
+@table @code
+@item (@var{relx} . @var{rely})
+The coordinates are inside @var{window}.  The numbers @var{relx} and
+@var{rely} are the equivalent window-relative coordinates for the
+specified position, counting from 0 at the top left corner of the
+window.
+
+@item mode-line
+The coordinates are in the mode line of @var{window}.
+
+@item vertical-split
+The coordinates are in the vertical line between @var{window} and its
+neighbor to the right.  This value occurs only if the window doesn't 
+have a scroll bar; positions in a scroll bar are considered outside the
+window.
+
+@item nil
+The coordinates are not in any part of @var{window}.
+@end table
+
+The function @code{coordinates-in-window-p} does not require a frame as
+argument because it always uses the frame that @var{window} is on.
+@end defun
+
+@node Window Configurations
+@section Window Configurations
+@cindex window configurations
+@cindex saving window information
+
+  A @dfn{window configuration} records the entire layout of a
+frame---all windows, their sizes, which buffers they contain, what part
+of each buffer is displayed, and the values of point and the mark.  You
+can bring back an entire previous layout by restoring a window
+configuration previously saved.
+
+  If you want to record all frames instead of just one, use a frame
+configuration instead of a window configuration.  @xref{Frame
+Configurations}.
+
+@defun current-window-configuration
+This function returns a new object representing Emacs's current window
+configuration, namely the number of windows, their sizes and current
+buffers, which window is the selected window, and for each window the
+displayed buffer, the display-start position, and the positions of point
+and the mark.  An exception is made for point in the current buffer,
+whose value is not saved.
+@end defun
+
+@defun set-window-configuration configuration
+This function restores the configuration of Emacs's windows and
+buffers to the state specified by @var{configuration}.  The argument
+@var{configuration} must be a value that was previously returned by
+@code{current-window-configuration}.
+
+Here is a way of using this function to get the same effect
+as @code{save-window-excursion}:
+
+@example
+@group
+(let ((config (current-window-configuration)))
+  (unwind-protect
+      (progn (split-window-vertically nil)
+             @dots{})
+    (set-window-configuration config)))
+@end group
+@end example
+@end defun
+
+@defspec save-window-excursion forms@dots{}
+This special form records the window configuration, executes @var{forms}
+in sequence, then restores the earlier window configuration.  The window
+configuration includes the value of point and the portion of the buffer
+which is visible.  It also includes the choice of selected window.
+However, it does not include the value of point in the current buffer;
+use @code{save-excursion} if you wish to preserve that.
+
+The return value is the value of the final form in @var{forms}.
+For example:
+
+@example
+@group
+(split-window)
+     @result{} #<window 25 on control.texi>
+@end group
+@group
+(setq w (selected-window))
+     @result{} #<window 19 on control.texi>
+@end group
+@group
+(save-window-excursion
+  (delete-other-windows w)
+  (switch-to-buffer "foo")
+  'do-something)
+     @result{} do-something
+     ;; @r{The screen is now split again.}
+@end group
+@end example
+@end defspec
+
+@defun window-configuration-p object
+This function returns @code{t} if @var{object} is a window configuration.
+@end defun
+
+  Primitives to look inside of window configurations would make sense,
+but none are implemented.  It is not clear they are useful enough to be
+worth implementing.