This is ../info/emacs, produced by makeinfo version 4.3 from emacs.texi.

   This is the Fourteenth edition of the `GNU Emacs Manual', updated
for Emacs version 21.3.

INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Emacs: (emacs).	The extensible self-documenting text editor.
END-INFO-DIR-ENTRY

   Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA  02111-1307 USA

   Copyright (C)
1985,1986,1987,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002
Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "The GNU Manifesto", "Distribution" and "GNU
GENERAL PUBLIC LICENSE", with the Front-Cover texts being "A GNU
Manual," and with the Back-Cover Texts as in (a) below.  A copy of the
license is included in the section entitled "GNU Free Documentation
License."

   (a) The FSF's Back-Cover Text is: "You have freedom to copy and
modify this GNU Manual, like GNU software.  Copies published by the Free
Software Foundation raise funds for GNU development."


File: emacs,  Node: Snapshots,  Next: Miscellaneous VC,  Prev: Remote Repositories,  Up: Version Control

Snapshots
---------

   A "snapshot" is a named set of file versions (one for each
registered file) that you can treat as a unit.  One important kind of
snapshot is a "release", a (theoretically) stable version of the system
that is ready for distribution to users.

* Menu:

* Making Snapshots::		The snapshot facilities.
* Snapshot Caveats::		Things to be careful of when using snapshots.


File: emacs,  Node: Making Snapshots,  Next: Snapshot Caveats,  Up: Snapshots

Making and Using Snapshots
..........................

   There are two basic commands for snapshots; one makes a snapshot
with a given name, the other retrieves a named snapshot.

`C-x v s NAME <RET>'
     Define the last saved versions of every registered file in or
     under the current directory as a snapshot named NAME
     (`vc-create-snapshot').

`C-x v r NAME <RET>'
     For all registered files at or below the current directory level,
     select whatever versions correspond to the snapshot NAME
     (`vc-retrieve-snapshot').

     This command reports an error if any files are locked at or below
     the current directory, without changing anything; this is to avoid
     overwriting work in progress.

   A snapshot uses a very small amount of resources--just enough to
record the list of file names and which version belongs to the
snapshot.  Thus, you need not hesitate to create snapshots whenever
they are useful.

   You can give a snapshot name as an argument to `C-x v =' or `C-x v
~' (*note Old Versions::).  Thus, you can use it to compare a snapshot
against the current files, or two snapshots against each other, or a
snapshot against a named version.


File: emacs,  Node: Snapshot Caveats,  Prev: Making Snapshots,  Up: Snapshots

Snapshot Caveats
................

   VC's snapshot facilities are modeled on RCS's named-configuration
support.  They use RCS's native facilities for this, so under VC
snapshots made using RCS are visible even when you bypass VC.

   For SCCS, VC implements snapshots itself.  The files it uses contain
name/file/version-number triples.  These snapshots are visible only
through VC.

   A snapshot is a set of checked-in versions.  So make sure that all
the files are checked in and not locked when you make a snapshot.

   File renaming and deletion can create some difficulties with
snapshots.  This is not a VC-specific problem, but a general design
issue in version control systems that no one has solved very well yet.

   If you rename a registered file, you need to rename its master along
with it (the command `vc-rename-file' does this automatically).  If you
are using SCCS, you must also update the records of the snapshot, to
mention the file by its new name (`vc-rename-file' does this, too).  An
old snapshot that refers to a master file that no longer exists under
the recorded name is invalid; VC can no longer retrieve it.  It would
be beyond the scope of this manual to explain enough about RCS and SCCS
to explain how to update the snapshots by hand.

   Using `vc-rename-file' makes the snapshot remain valid for
retrieval, but it does not solve all problems.  For example, some of the
files in your program probably refer to others by name.  At the very
least, the makefile probably mentions the file that you renamed.  If you
retrieve an old snapshot, the renamed file is retrieved under its new
name, which is not the name that the makefile expects.  So the program
won't really work as retrieved.


File: emacs,  Node: Miscellaneous VC,  Next: Customizing VC,  Prev: Snapshots,  Up: Version Control

Miscellaneous Commands and Features of VC
-----------------------------------------

   This section explains the less-frequently-used features of VC.

* Menu:

* Change Logs and VC::  Generating a change log file from log entries.
* Renaming and VC::     A command to rename both the source and master
                          file correctly.
* Version Headers::     Inserting version control headers into working files.


File: emacs,  Node: Change Logs and VC,  Next: Renaming and VC,  Up: Miscellaneous VC

Change Logs and VC
..................

   If you use RCS or CVS for a program and also maintain a change log
file for it (*note Change Log::), you can generate change log entries
automatically from the version control log entries:

`C-x v a'
     Visit the current directory's change log file and, for registered
     files in that directory, create new entries for versions checked
     in since the most recent entry in the change log file.
     (`vc-update-change-log').

     This command works with RCS or CVS only, not with SCCS.

`C-u C-x v a'
     As above, but only find entries for the current buffer's file.

`M-1 C-x v a'
     As above, but find entries for all the currently visited files
     that are maintained with version control.  This works only with
     RCS, and it puts all entries in the log for the default directory,
     which may not be appropriate.

   For example, suppose the first line of `ChangeLog' is dated
1999-04-10, and that the only check-in since then was by Nathaniel
Bowditch to `rcs2log' on 1999-05-22 with log text `Ignore log messages
that start with `#'.'.  Then `C-x v a' visits `ChangeLog' and inserts
text like this:

     1999-05-22  Nathaniel Bowditch  <nat@apn.org>
     
             * rcs2log: Ignore log messages that start with `#'.

You can then edit the new change log entry further as you wish.

   Some of the new change log entries may duplicate what's already in
ChangeLog.  You will have to remove these duplicates by hand.

   Normally, the log entry for file `foo' is displayed as `* foo: TEXT
OF LOG ENTRY'.  The `:' after `foo' is omitted if the text of the log
entry starts with `(FUNCTIONNAME): '.  For example, if the log entry
for `vc.el' is `(vc-do-command): Check call-process status.', then the
text in `ChangeLog' looks like this:

     1999-05-06  Nathaniel Bowditch  <nat@apn.org>
     
             * vc.el (vc-do-command): Check call-process status.

   When `C-x v a' adds several change log entries at once, it groups
related log entries together if they all are checked in by the same
author at nearly the same time.  If the log entries for several such
files all have the same text, it coalesces them into a single entry.
For example, suppose the most recent check-ins have the following log
entries:

* For `vc.texinfo': `Fix expansion typos.'
* For `vc.el': `Don't call expand-file-name.'
* For `vc-hooks.el': `Don't call expand-file-name.'

They appear like this in `ChangeLog':

     1999-04-01  Nathaniel Bowditch  <nat@apn.org>
     
             * vc.texinfo: Fix expansion typos.
     
             * vc.el, vc-hooks.el: Don't call expand-file-name.

   Normally, `C-x v a' separates log entries by a blank line, but you
can mark several related log entries to be clumped together (without an
intervening blank line) by starting the text of each related log entry
with a label of the form `{CLUMPNAME} '.  The label itself is not
copied to `ChangeLog'.  For example, suppose the log entries are:

* For `vc.texinfo': `{expand} Fix expansion typos.'
* For `vc.el': `{expand} Don't call expand-file-name.'
* For `vc-hooks.el': `{expand} Don't call expand-file-name.'

Then the text in `ChangeLog' looks like this:

     1999-04-01  Nathaniel Bowditch  <nat@apn.org>
     
             * vc.texinfo: Fix expansion typos.
             * vc.el, vc-hooks.el: Don't call expand-file-name.

   A log entry whose text begins with `#' is not copied to `ChangeLog'.
For example, if you merely fix some misspellings in comments, you can
log the change with an entry beginning with `#' to avoid putting such
trivia into `ChangeLog'.


File: emacs,  Node: Renaming and VC,  Next: Version Headers,  Prev: Change Logs and VC,  Up: Miscellaneous VC

Renaming VC Work Files and Master Files
.......................................

   When you rename a registered file, you must also rename its master
file correspondingly to get proper results.  Use `vc-rename-file' to
rename the source file as you specify, and rename its master file
accordingly.  It also updates any snapshots (*note Snapshots::) that
mention the file, so that they use the new name; despite this, the
snapshot thus modified may not completely work (*note Snapshot
Caveats::).

   You cannot use `vc-rename-file' on a file that is locked by someone
else.


File: emacs,  Node: Version Headers,  Prev: Renaming and VC,  Up: Miscellaneous VC

Inserting Version Control Headers
.................................

   Sometimes it is convenient to put version identification strings
directly into working files.  Certain special strings called "version
headers" are replaced in each successive version by the number of that
version.

   If you are using RCS, and version headers are present in your working
files, Emacs can use them to determine the current version and the
locking state of the files.  This is more reliable than referring to the
master files, which is done when there are no version headers.  Note
that in a multi-branch environment, version headers are necessary to
make VC behave correctly (*note Multi-User Branching::).

   Searching for version headers is controlled by the variable
`vc-consult-headers'.  If it is non-`nil' (the default), Emacs searches
for headers to determine the version number you are editing.  Setting
it to `nil' disables this feature.

   You can use the `C-x v h' command (`vc-insert-headers') to insert a
suitable header string.

`C-x v h'
     Insert headers in a file for use with your version-control system.

   The default header string is `$Id$' for RCS and `%W%' for SCCS.  You
can specify other headers to insert by setting the variable
`vc-header-alist'.  Its value is a list of elements of the form
`(PROGRAM . STRING)' where PROGRAM is `RCS' or `SCCS' and STRING is the
string to use.

   Instead of a single string, you can specify a list of strings; then
each string in the list is inserted as a separate header on a line of
its own.

   It is often necessary to use "superfluous" backslashes when writing
the strings that you put in this variable.  For instance, you might
write `"$Id\$"' rather than `"$Id$"'.  The extra backslash prevents the
string constant from being interpreted as a header, if the Emacs Lisp
file containing it is maintained with version control.

   Each header is inserted surrounded by tabs, inside comment
delimiters, on a new line at point.  Normally the ordinary comment
start and comment end strings of the current mode are used, but for
certain modes, there are special comment delimiters for this purpose;
the variable `vc-comment-alist' specifies them.  Each element of this
list has the form `(MODE STARTER ENDER)'.

   The variable `vc-static-header-alist' specifies further strings to
add based on the name of the buffer.  Its value should be a list of
elements of the form `(REGEXP . FORMAT)'.  Whenever REGEXP matches the
buffer name, FORMAT is inserted as part of the header.  A header line
is inserted for each element that matches the buffer name, and for each
string specified by `vc-header-alist'.  The header line is made by
processing the string from `vc-header-alist' with the format taken from
the element.  The default value for `vc-static-header-alist' is as
follows:

     (("\\.c$" .
       "\n#ifndef lint\nstatic char vcid[] = \"\%s\";\n\
     #endif /* lint */\n"))

It specifies insertion of text of this form:


     #ifndef lint
     static char vcid[] = "STRING";
     #endif /* lint */

Note that the text above starts with a blank line.

   If you use more than one version header in a file, put them close
together in the file.  The mechanism in `revert-buffer' that preserves
markers may not handle markers positioned between two version headers.


File: emacs,  Node: Customizing VC,  Prev: Miscellaneous VC,  Up: Version Control

Customizing VC
--------------

   The variable `vc-handled-backends' determines which version control
systems VC should handle.  The default value is `(RCS CVS SCCS)', so it
contains all three version systems that are currently supported.  If
you want VC to ignore one or more of these systems, exclude its name
from the list.

   The order of systems in the list is significant: when you visit a
file registered in more than one system (*note Local Version Control::),
VC uses the system that comes first in `vc-handled-backends' by
default.  The order is also significant when you register a file for
the first time, *note Registering:: for details.

* Menu:

* General VC Options::  Options that apply to multiple back ends.
* RCS and SCCS::        Options for RCS and SCCS.
* CVS Options::         Options for CVS.


File: emacs,  Node: General VC Options,  Next: RCS and SCCS,  Up: Customizing VC

General Options
...............

   Emacs normally does not save backup files for source files that are
maintained with version control.  If you want to make backup files even
for files that use version control, set the variable
`vc-make-backup-files' to a non-`nil' value.

   Normally the work file exists all the time, whether it is locked or
not.  If you set `vc-keep-workfiles' to `nil', then checking in a new
version with `C-x C-q' deletes the work file; but any attempt to visit
the file with Emacs creates it again.  (With CVS, work files are always
kept.)

   Editing a version-controlled file through a symbolic link can be
dangerous.  It bypasses the version control system--you can edit the
file without locking it, and fail to check your changes in.  Also, your
changes might overwrite those of another user.  To protect against
this, VC checks each symbolic link that you visit, to see if it points
to a file under version control.

   The variable `vc-follow-symlinks' controls what to do when a
symbolic link points to a version-controlled file.  If it is `nil', VC
only displays a warning message.  If it is `t', VC automatically
follows the link, and visits the real file instead, telling you about
this in the echo area.  If the value is `ask' (the default), VC asks
you each time whether to follow the link.

   If `vc-suppress-confirm' is non-`nil', then `C-x C-q' and `C-x v i'
can save the current buffer without asking, and `C-x v u' also operates
without asking for confirmation.  (This variable does not affect `C-x v
c'; that operation is so drastic that it should always ask for
confirmation.)

   VC mode does much of its work by running the shell commands for RCS,
CVS and SCCS.  If `vc-command-messages' is non-`nil', VC displays
messages to indicate which shell commands it runs, and additional
messages when the commands finish.

   You can specify additional directories to search for version control
programs by setting the variable `vc-path'.  These directories are
searched before the usual search path.  It is rarely necessary to set
this variable, because VC normally finds the proper files automatically.


File: emacs,  Node: RCS and SCCS,  Next: CVS Options,  Prev: General VC Options,  Up: Customizing VC

Options for RCS and SCCS
........................

   By default, RCS uses locking to coordinate the activities of several
users, but there is a mode called "non-strict locking" in which you can
check-in changes without locking the file first.  Use `rcs -U' to
switch to non-strict locking for a particular file, see the `rcs'
manual page for details.

   When deducing the version control state of an RCS file, VC first
looks for an RCS version header string in the file (*note Version
Headers::).  If there is no header string, VC normally looks at the
file permissions of the work file; this is fast.  But there might be
situations when the file permissions cannot be trusted.  In this case
the master file has to be consulted, which is rather expensive.  Also
the master file can only tell you _if_ there's any lock on the file,
but not whether your work file really contains that locked version.

   You can tell VC not to use version headers to determine the file
status by setting `vc-consult-headers' to `nil'.  VC then always uses
the file permissions (if it is supposed to trust them), or else checks
the master file.

   You can specify the criterion for whether to trust the file
permissions by setting the variable `vc-mistrust-permissions'.  Its
value can be `t' (always mistrust the file permissions and check the
master file), `nil' (always trust the file permissions), or a function
of one argument which makes the decision.  The argument is the
directory name of the `RCS' subdirectory.  A non-`nil' value from the
function says to mistrust the file permissions.  If you find that the
file permissions of work files are changed erroneously, set
`vc-mistrust-permissions' to `t'.  Then VC always checks the master
file to determine the file's status.

   VC determines the version control state of files under SCCS much as
with RCS.  It does not consider SCCS version headers, though.  Thus,
the variable `vc-mistrust-permissions' affects SCCS use, but
`vc-consult-headers' does not.


File: emacs,  Node: CVS Options,  Prev: RCS and SCCS,  Up: Customizing VC

Options specific for CVS
........................

   By default, CVS does not use locking to coordinate the activities of
several users; anyone can change a work file at any time.  However,
there are ways to restrict this, resulting in behavior that resembles
locking.

   For one thing, you can set the `CVSREAD' environment variable (the
value you use makes no difference).  If this variable is defined, CVS
makes your work files read-only by default.  In Emacs, you must type
`C-x C-q' to make the file writable, so that editing works in fact
similar as if locking was used.  Note however, that no actual locking
is performed, so several users can make their files writable at the
same time.  When setting `CVSREAD' for the first time, make sure to
check out all your modules anew, so that the file protections are set
correctly.

   Another way to achieve something similar to locking is to use the
"watch" feature of CVS.  If a file is being watched, CVS makes it
read-only by default, and you must also use `C-x C-q' in Emacs to make
it writable.  VC calls `cvs edit' to make the file writable, and CVS
takes care to notify other developers of the fact that you intend to
change the file.  See the CVS documentation for details on using the
watch feature.

   When a file's repository is on a remote machine, VC tries to keep
network interactions to a minimum.  This is controlled by the variable
`vc-cvs-stay-local'.  If it is `t' (the default), then VC uses only the
entry in the local CVS subdirectory to determine the file's state (and
possibly information returned by previous CVS commands).  One
consequence of this is that when you have modified a file, and somebody
else has already checked in other changes to the file, you are not
notified of it until you actually try to commit.  (But you can try to
pick up any recent changes from the repository first, using `C-x v m
<RET>', *note Merging::).

   When `vc-cvs-stay-local' is `t', VC also makes local version
backups, so that simple diff and revert operations are completely local
(*note Version Backups::).

   On the other hand, if you set `vc-cvs-stay-local' to `nil', then VC
queries the remote repository _before_ it decides what to do in
`vc-next-action' (`C-x v v'), just as it does for local repositories.
It also does not make any version backups.

   You can also set `vc-cvs-stay-local' to a regular expression that is
matched against the repository host name; VC then stays local only for
repositories from hosts that match the pattern.


File: emacs,  Node: Directories,  Next: Comparing Files,  Prev: Version Control,  Up: Files

File Directories
================

   The file system groups files into "directories".  A "directory
listing" is a list of all the files in a directory.  Emacs provides
commands to create and delete directories, and to make directory
listings in brief format (file names only) and verbose format (sizes,
dates, and authors included).  There is also a directory browser called
Dired; see *Note Dired::.

`C-x C-d DIR-OR-PATTERN <RET>'
     Display a brief directory listing (`list-directory').

`C-u C-x C-d DIR-OR-PATTERN <RET>'
     Display a verbose directory listing.

`M-x make-directory <RET> DIRNAME <RET>'
     Create a new directory named DIRNAME.

`M-x delete-directory <RET> DIRNAME <RET>'
     Delete the directory named DIRNAME.  It must be empty, or you get
     an error.

   The command to display a directory listing is `C-x C-d'
(`list-directory').  It reads using the minibuffer a file name which is
either a directory to be listed or a wildcard-containing pattern for
the files to be listed.  For example,

     C-x C-d /u2/emacs/etc <RET>

lists all the files in directory `/u2/emacs/etc'.  Here is an example
of specifying a file name pattern:

     C-x C-d /u2/emacs/src/*.c <RET>

   Normally, `C-x C-d' displays a brief directory listing containing
just file names.  A numeric argument (regardless of value) tells it to
make a verbose listing including sizes, dates, and owners (like `ls
-l').

   The text of a directory listing is obtained by running `ls' in an
inferior process.  Two Emacs variables control the switches passed to
`ls': `list-directory-brief-switches' is a string giving the switches
to use in brief listings (`"-CF"' by default), and
`list-directory-verbose-switches' is a string giving the switches to
use in a verbose listing (`"-l"' by default).


File: emacs,  Node: Comparing Files,  Next: Misc File Ops,  Prev: Directories,  Up: Files

Comparing Files
===============

   The command `M-x diff' compares two files, displaying the
differences in an Emacs buffer named `*diff*'.  It works by running the
`diff' program, using options taken from the variable `diff-switches'.
The value of `diff-switches' should be a string; the default is `"-c"'
to specify a context diff.

   The buffer `*diff*' has Compilation mode as its major mode, so you
can use `C-x `' to visit successive changed locations in the two source
files.  You can also move to a particular hunk of changes and type
<RET> or `C-c C-c', or click `Mouse-2' on it, to move to the
corresponding source location.  You can also use the other special
commands of Compilation mode: <SPC> and <DEL> for scrolling, and `M-p'
and `M-n' for cursor motion.  *Note Compilation::.

   The command `M-x diff-backup' compares a specified file with its most
recent backup.  If you specify the name of a backup file, `diff-backup'
compares it with the source file that it is a backup of.

   The command `M-x compare-windows' compares the text in the current
window with that in the next window.  Comparison starts at point in each
window, and each starting position is pushed on the mark ring in its
respective buffer.  Then point moves forward in each window, a character
at a time, until a mismatch between the two windows is reached.  Then
the command is finished.  For more information about windows in Emacs,
*Note Windows::.

   With a numeric argument, `compare-windows' ignores changes in
whitespace.  If the variable `compare-ignore-case' is non-`nil', it
ignores differences in case as well.

   Differences between versions of files are often distributed as
"patches", which are the output from `diff' or a version control system
that uses `diff'.  `M-x diff-mode' turns on Diff mode, a major mode for
viewing and editing patches, either as "unified diffs" or "context
diffs."

   You can use `M-x smerge-mode' to turn on Smerge mode, a minor mode
for editing output from the `diff3' program.  This is typically the
result of a failed merge from a version control system "update" outside
VC, due to conflicting changes to a file.  Smerge mode provides
commands to resolve conflicts by selecting specific changes.

   See also *Note Emerge::, and *Note Top: (ediff)Top, for convenient
facilities for merging two similar files.


File: emacs,  Node: Misc File Ops,  Next: Compressed Files,  Prev: Comparing Files,  Up: Files

Miscellaneous File Operations
=============================

   Emacs has commands for performing many other operations on files.
All operate on one file; they do not accept wildcard file names.

   `M-x view-file' allows you to scan or read a file by sequential
screenfuls.  It reads a file name argument using the minibuffer.  After
reading the file into an Emacs buffer, `view-file' displays the
beginning.  You can then type <SPC> to scroll forward one windowful, or
<DEL> to scroll backward.  Various other commands are provided for
moving around in the file, but none for changing it; type `?' while
viewing for a list of them.  They are mostly the same as normal Emacs
cursor motion commands.  To exit from viewing, type `q'.  The commands
for viewing are defined by a special major mode called View mode.

   A related command, `M-x view-buffer', views a buffer already present
in Emacs.  *Note Misc Buffer::.

   `M-x insert-file' (also `C-x i') inserts a copy of the contents of
the specified file into the current buffer at point, leaving point
unchanged before the contents and the mark after them.

   `M-x write-region' is the inverse of `M-x insert-file'; it copies
the contents of the region into the specified file.  `M-x
append-to-file' adds the text of the region to the end of the specified
file.  *Note Accumulating Text::.

   `M-x delete-file' deletes the specified file, like the `rm' command
in the shell.  If you are deleting many files in one directory, it may
be more convenient to use Dired (*note Dired::).

   `M-x rename-file' reads two file names OLD and NEW using the
minibuffer, then renames file OLD as NEW.  If the file name NEW already
exists, you must confirm with `yes' or renaming is not done; this is
because renaming causes the old meaning of the name NEW to be lost.  If
OLD and NEW are on different file systems, the file OLD is copied and
deleted.

   The similar command `M-x add-name-to-file' is used to add an
additional name to an existing file without removing its old name.  The
new name is created as a "hard link" to the existing file.  The new
name must belong on the same file system that the file is on.  On
Windows, this command works only if the file resides in an NTFS file
system.  On MS-DOS, it works by copying the file.

   `M-x copy-file' reads the file OLD and writes a new file named NEW
with the same contents.  Confirmation is required if a file named NEW
already exists, because copying has the consequence of overwriting the
old contents of the file NEW.

   `M-x make-symbolic-link' reads two file names TARGET and LINKNAME,
then creates a symbolic link named LINKNAME, which points at TARGET.
The effect is that future attempts to open file LINKNAME will refer to
whatever file is named TARGET at the time the opening is done, or will
get an error if the name TARGET is not in use at that time.  This
command does not expand the argument TARGET, so that it allows you to
specify a relative name as the target of the link.

   Confirmation is required when creating the link if LINKNAME is in
use.  Note that not all systems support symbolic links; on systems that
don't support them, this command is not defined.


File: emacs,  Node: Compressed Files,  Next: File Archives,  Prev: Misc File Ops,  Up: Files

Accessing Compressed Files
==========================

   Emacs comes with a library that can automatically uncompress
compressed files when you visit them, and automatically recompress them
if you alter them and save them.  To enable this feature, type the
command `M-x auto-compression-mode'.  You can enable it permanently by
customizing the option `auto-compression-mode'.

   When automatic compression (which implies automatic uncompression as
well) is enabled, Emacs recognizes compressed files by their file names.
File names ending in `.gz' indicate a file compressed with `gzip'.
Other endings indicate other compression programs.

   Automatic uncompression and compression apply to all the operations
in which Emacs uses the contents of a file.  This includes visiting it,
saving it, inserting its contents into a buffer, loading it, and byte
compiling it.


File: emacs,  Node: File Archives,  Next: Remote Files,  Prev: Compressed Files,  Up: Files

File Archives
=============

   A file whose name ends in `.tar' is normally an "archive" made by
the `tar' program.  Emacs views these files in a special mode called
Tar mode which provides a Dired-like list of the contents (*note
Dired::).  You can move around through the list just as you would in
Dired, and visit the subfiles contained in the archive.  However, not
all Dired commands are available in Tar mode.

   If you enable Auto Compression mode (*note Compressed Files::), then
Tar mode is used also for compressed archives--files with extensions
`.tgz', `.tar.Z' and `.tar.gz'.

   The keys `e', `f' and <RET> all extract a component file into its
own buffer.  You can edit it there and when you save the buffer the
edited version will replace the version in the Tar buffer.  `v'
extracts a file into a buffer in View mode.  `o' extracts the file and
displays it in another window, so you could edit the file and operate
on the archive simultaneously.  `d' marks a file for deletion when you
later use `x', and `u' unmarks a file, as in Dired.  `C' copies a file
from the archive to disk and `R' renames a file.  `g' reverts the
buffer from the archive on disk.

   The keys `M', `G', and `O' change the file's permission bits, group,
and owner, respectively.

   If your display supports colors and the mouse, moving the mouse
pointer across a file name highlights that file name, indicating that
you can click on it.  Clicking `Mouse-2' on the highlighted file name
extracts the file into a buffer and displays that buffer.

   Saving the Tar buffer writes a new version of the archive to disk
with the changes you made to the components.

   You don't need the `tar' program to use Tar mode--Emacs reads the
archives directly.  However, accessing compressed archives requires the
appropriate uncompression program.

   A separate but similar Archive mode is used for archives produced by
the programs `arc', `jar', `lzh', `zip', and `zoo', which have
extensions corresponding to the program names.

   The key bindings of Archive mode are similar to those in Tar mode,
with the addition of the `m' key which marks a file for subsequent
operations, and `M-<DEL>' which unmarks all the marked files.  Also,
the `a' key toggles the display of detailed file information, for those
archive types where it won't fit in a single line.  Operations such as
renaming a subfile, or changing its mode or owner, are supported only
for some of the archive formats.

   Unlike Tar mode, Archive mode runs the archiving program to unpack
and repack archives.  Details of the program names and their options
can be set in the `Archive' Customize group.  However, you don't need
these programs to look at the archive table of contents, only to
extract or manipulate the subfiles in the archive.


File: emacs,  Node: Remote Files,  Next: Quoted File Names,  Prev: File Archives,  Up: Files

Remote Files
============

   You can refer to files on other machines using a special file name
syntax:

     /HOST:FILENAME
     /USER@HOST:FILENAME
     /USER@HOST#PORT:FILENAME

When you do this, Emacs uses the FTP program to read and write files on
the specified host.  It logs in through FTP using your user name or the
name USER.  It may ask you for a password from time to time; this is
used for logging in on HOST.  The form using PORT allows you to access
servers running on a non-default TCP port.

   If you want to disable backups for remote files, set the variable
`ange-ftp-make-backup-files' to `nil'.

   Normally, if you do not specify a user name in a remote file name,
that means to use your own user name.  But if you set the variable
`ange-ftp-default-user' to a string, that string is used instead.  (The
Emacs package that implements FTP file access is called `ange-ftp'.)

   To visit files accessible by anonymous FTP, you use special user
names `anonymous' or `ftp'.  Passwords for these user names are handled
specially.  The variable `ange-ftp-generate-anonymous-password'
controls what happens: if the value of this variable is a string, then
that string is used as the password; if non-`nil' (the default), then
the value of `user-mail-address' is used; if `nil', the user is prompted
for a password as normal.

   Sometimes you may be unable to access files on a remote machine
because a "firewall" in between blocks the connection for security
reasons.  If you can log in on a "gateway" machine from which the
target files _are_ accessible, and whose FTP server supports gatewaying
features, you can still use remote file names; all you have to do is
specify the name of the gateway machine by setting the variable
`ange-ftp-gateway-host', and set `ange-ftp-smart-gateway' to `t'.
Otherwise you may be able to make remote file names work, but the
procedure is complex.  You can read the instructions by typing `M-x
finder-commentary <RET> ange-ftp <RET>'.

   You can entirely turn off the FTP file name feature by removing the
entries `ange-ftp-completion-hook-function' and
`ange-ftp-hook-function' from the variable `file-name-handler-alist'.
You can turn off the feature in individual cases by quoting the file
name with `/:' (*note Quoted File Names::).


File: emacs,  Node: Quoted File Names,  Next: File Name Cache,  Prev: Remote Files,  Up: Files

Quoted File Names
=================

   You can "quote" an absolute file name to prevent special characters
and syntax in it from having their special effects.  The way to do this
is to add `/:' at the beginning.

   For example, you can quote a local file name which appears remote, to
prevent it from being treated as a remote file name.  Thus, if you have
a directory named `/foo:' and a file named `bar' in it, you can refer
to that file in Emacs as `/:/foo:/bar'.

   `/:' can also prevent `~' from being treated as a special character
for a user's home directory.  For example, `/:/tmp/~hack' refers to a
file whose name is `~hack' in directory `/tmp'.

   Likewise, quoting with `/:' is one way to enter in the minibuffer a
file name that contains `$'.  However, the `/:' must be at the
beginning of the minibuffer in order to quote `$'.

   You can also quote wildcard characters with `/:', for visiting.  For
example, `/:/tmp/foo*bar' visits the file `/tmp/foo*bar'.  However, in
most cases you can simply type the wildcard characters for themselves.
For example, if the only file name in `/tmp' that starts with `foo' and
ends with `bar' is `foo*bar', then specifying `/tmp/foo*bar' will visit
just `/tmp/foo*bar'.  Another way is to specify `/tmp/foo[*]bar'.


File: emacs,  Node: File Name Cache,  Next: File Conveniences,  Prev: Quoted File Names,  Up: Files

File Name Cache
===============

   You can use the "file name cache" to make it easy to locate a file
by name, without having to remember exactly where it is located.  When
typing a file name in the minibuffer, `C-<tab>'
(`file-cache-minibuffer-complete') completes it using the file name
cache.  If you repeat `C-<tab>', that cycles through the possible
completions of what you had originally typed.  Note that the `C-<tab>'
character cannot be typed on most text-only terminals.

   The file name cache does not fill up automatically.  Instead, you
load file names into the cache using these commands:

`M-x file-cache-add-directory <RET> DIRECTORY <RET>'
     Add each file name in DIRECTORY to the file name cache.

`M-x file-cache-add-directory-using-find <RET> DIRECTORY <RET>'
     Add each file name in DIRECTORY and all of its nested
     subdirectories to the file name cache.

`M-x file-cache-add-directory-using-locate <RET> DIRECTORY <RET>'
     Add each file name in DIRECTORY and all of its nested
     subdirectories to the file name cache, using `locate' to find them
     all.

`M-x file-cache-add-directory-list <RET> VARIABLE <RET>'
     Add each file name in each directory listed in VARIABLE to the
     file name cache.  VARIABLE should be a Lisp variable such as
     `load-path' or `exec-path', whose value is a list of directory
     names.

`M-x file-cache-clear-cache <RET>'
     Clear the cache; that is, remove all file names from it.


File: emacs,  Node: File Conveniences,  Prev: File Name Cache,  Up: Files

Convenience Features for Finding Files
======================================

   If you enable Recentf mode, with `M-x recentf-mode', the `File' menu
includes a submenu containing a list of recently opened files.  `M-x
recentf-save-list' saves the current `recent-file-list' to a file, and
`M-x recentf-edit-list' edits it.

   When Auto-image-file minor mode is enabled, visiting an image file
displays it as an image, not as text.  Likewise, inserting an image
file into a buffer inserts it as an image.  This works only when Emacs
can display the relevant image type.  The variables
`image-file-name-extensions' or `image-file-name-regexps' control which
file names are recognized as containing images.

   The `M-x ffap' command generalizes `find-file' with more powerful
heuristic defaults (*note FFAP::), often based on the text at point.
Partial Completion mode offers other features extending `find-file',
which can be used with `ffap'.  *Note Completion Options::.


File: emacs,  Node: Buffers,  Next: Windows,  Prev: Files,  Up: Top

Using Multiple Buffers
**********************

   The text you are editing in Emacs resides in an object called a
"buffer".  Each time you visit a file, a buffer is created to hold the
file's text.  Each time you invoke Dired, a buffer is created to hold
the directory listing.  If you send a message with `C-x m', a buffer
named `*mail*' is used to hold the text of the message.  When you ask
for a command's documentation, that appears in a buffer called `*Help*'.

   At any time, one and only one buffer is "current".  It is also
called the "selected buffer".  Often we say that a command operates on
"the buffer" as if there were only one; but really this means that the
command operates on the current buffer (most commands do).

   When Emacs has multiple windows, each window has its own chosen
buffer and displays it; at any time, only one of the windows is
selected, and its chosen buffer is the current buffer.  Each window's
mode line normally displays the name of the window's chosen buffer
(*note Windows::).

   Each buffer has a name, which can be of any length, and you can
select any buffer by giving its name.  Most buffers are made by
visiting files, and their names are derived from the files' names.  But
you can also create an empty buffer with any name you want.  A newly
started Emacs has a buffer named `*scratch*' which can be used for
evaluating Lisp expressions in Emacs.  The distinction between upper
and lower case matters in buffer names.

   Each buffer records individually what file it is visiting, whether
it is modified, and what major mode and minor modes are in effect in it
(*note Major Modes::).  Any Emacs variable can be made "local to" a
particular buffer, meaning its value in that buffer can be different
from the value in other buffers.  *Note Locals::.

   A buffer's size cannot be larger than some maximum, which is defined
by the largest buffer position representable by the "Emacs integer"
data type.  This is because Emacs tracks buffer positions using that
data type.  For 32-bit machines, the largest buffer size is 128
megabytes.

* Menu:

* Select Buffer::       Creating a new buffer or reselecting an old one.
* List Buffers::        Getting a list of buffers that exist.
* Misc Buffer::	        Renaming; changing read-onlyness; copying text.
* Kill Buffer::	        Killing buffers you no longer need.
* Several Buffers::     How to go through the list of all buffers
			  and operate variously on several of them.
* Indirect Buffers::    An indirect buffer shares the text of another buffer.
* Buffer Convenience::  Convenience and customization features for
                          buffer handling.


File: emacs,  Node: Select Buffer,  Next: List Buffers,  Up: Buffers

Creating and Selecting Buffers
==============================

`C-x b BUFFER <RET>'
     Select or create a buffer named BUFFER (`switch-to-buffer').

`C-x 4 b BUFFER <RET>'
     Similar, but select BUFFER in another window
     (`switch-to-buffer-other-window').

`C-x 5 b BUFFER <RET>'
     Similar, but select BUFFER in a separate frame
     (`switch-to-buffer-other-frame').

   To select the buffer named BUFNAME, type `C-x b BUFNAME <RET>'.
This runs the command `switch-to-buffer' with argument BUFNAME.  You
can use completion on an abbreviation for the buffer name you want
(*note Completion::).  An empty argument to `C-x b' specifies the
buffer that was current most recently among those not now displayed in
any window.

   To select a buffer in a window other than the current one, type `C-x
4 b BUFNAME <RET>'.  This runs the command
`switch-to-buffer-other-window' which displays the buffer BUFNAME in
another window.  By default, if displaying the buffer causes two
vertically adjacent windows to be displayed, the heights of those
windows are evened out; to countermand that and preserve the window
configuration, set the variable `even-window-heights' to `nil'.

   Similarly, `C-x 5 b BUFFER <RET>' runs the command
`switch-to-buffer-other-frame' which selects a buffer in another frame.

   You can control how certain buffers are handled by these commands by
customizing the variables `special-display-buffer-names',
`special-display-regexps', `same-window-buffer-names', and
`same-window-regexps'.  See *Note Force Same Window::, and *Note
Special Buffer Frames::, for more about these variables.  In addition,
if the value of `display-buffer-reuse-frames' is non-`nil', and the
buffer you want to switch to is already displayed in some frame, Emacs
will raise that frame.

   Most buffers are created by visiting files, or by Emacs commands that
want to display some text, but you can also create a buffer explicitly
by typing `C-x b BUFNAME <RET>'.  This makes a new, empty buffer that
is not visiting any file, and selects it for editing.  Such buffers are
used for making notes to yourself.  If you try to save one, you are
asked for the file name to use.  The new buffer's major mode is
determined by the value of `default-major-mode' (*note Major Modes::).

   Note that `C-x C-f', and any other command for visiting a file, can
also be used to switch to an existing file-visiting buffer.  *Note
Visiting::.

   Emacs uses buffer names that start with a space for internal
purposes.  It treats these buffers specially in minor ways--for
example, by default they do not record undo information.  It is best to
avoid using such buffer names yourself.


File: emacs,  Node: List Buffers,  Next: Misc Buffer,  Prev: Select Buffer,  Up: Buffers

Listing Existing Buffers
========================

`C-x C-b'
     List the existing buffers (`list-buffers').

   To display a list of all the buffers that exist, type `C-x C-b'.
Each line in the list shows one buffer's name, major mode and visited
file.  The buffers are listed in the order that they were current; the
buffers that were current most recently come first.

   `*' at the beginning of a line indicates the buffer is "modified."
If several buffers are modified, it may be time to save some with `C-x
s' (*note Saving::).  `%' indicates a read-only buffer.  `.' marks the
current buffer.  Here is an example of a buffer list:

      MR Buffer         Size  Mode           File
      -- ------         ----  ----           ----
     .*  emacs.tex      383402 Texinfo       /u2/emacs/man/emacs.tex
         *Help*         1287  Fundamental
         files.el       23076 Emacs-Lisp     /u2/emacs/lisp/files.el
       % RMAIL          64042 RMAIL          /u/rms/RMAIL
      *% man            747   Dired          /u2/emacs/man/
         net.emacs      343885 Fundamental   /u/rms/net.emacs
         fileio.c       27691 C              /u2/emacs/src/fileio.c
         NEWS           67340 Text           /u2/emacs/etc/NEWS
         *scratch*	   0	 Lisp Interaction

Note that the buffer `*Help*' was made by a help request; it is not
visiting any file.  The buffer `man' was made by Dired on the directory
`/u2/emacs/man/'.  You can list only buffers that are visiting files by
giving the command a prefix; for instance, by typing `C-u C-x C-b'.


File: emacs,  Node: Misc Buffer,  Next: Kill Buffer,  Prev: List Buffers,  Up: Buffers

Miscellaneous Buffer Operations
===============================

`C-x C-q'
     Toggle read-only status of buffer (`vc-toggle-read-only').

`M-x rename-buffer <RET> NAME <RET>'
     Change the name of the current buffer.

`M-x rename-uniquely'
     Rename the current buffer by adding `<NUMBER>' to the end.

`M-x view-buffer <RET> BUFFER <RET>'
     Scroll through buffer BUFFER.

   A buffer can be "read-only", which means that commands to change its
contents are not allowed.  The mode line indicates read-only buffers
with `%%' or `%*' near the left margin.  Read-only buffers are usually
made by subsystems such as Dired and Rmail that have special commands
to operate on the text; also by visiting a file whose access control
says you cannot write it.

   If you wish to make changes in a read-only buffer, use the command
`C-x C-q' (`vc-toggle-read-only').  It makes a read-only buffer
writable, and makes a writable buffer read-only.  In most cases, this
works by setting the variable `buffer-read-only', which has a local
value in each buffer and makes the buffer read-only if its value is
non-`nil'.  If the file is maintained with version control, `C-x C-q'
works through the version control system to change the read-only status
of the file as well as the buffer.  *Note Version Control::.

   `M-x rename-buffer' changes the name of the current buffer.  Specify
the new name as a minibuffer argument.  There is no default.  If you
specify a name that is in use for some other buffer, an error happens
and no renaming is done.

   `M-x rename-uniquely' renames the current buffer to a similar name
with a numeric suffix added to make it both different and unique.  This
command does not need an argument.  It is useful for creating multiple
shell buffers: if you rename the `*Shell*' buffer, then do `M-x shell'
again, it makes a new shell buffer named `*Shell*'; meanwhile, the old
shell buffer continues to exist under its new name.  This method is
also good for mail buffers, compilation buffers, and most Emacs
features that create special buffers with particular names.

   `M-x view-buffer' is much like `M-x view-file' (*note Misc File
Ops::) except that it examines an already existing Emacs buffer.  View
mode provides commands for scrolling through the buffer conveniently
but not for changing it.  When you exit View mode with `q', that
switches back to the buffer (and the position) which was previously
displayed in the window.  Alternatively, if you exit View mode with
`e', the buffer and the value of point that resulted from your perusal
remain in effect.

   The commands `M-x append-to-buffer' and `M-x insert-buffer' can be
used to copy text from one buffer to another.  *Note Accumulating
Text::.

