Linux Cubed Series 2: Applications

home *** CD-ROM | disk | FTP | other *** search

/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / emacs-19.000 / emacs-19 / usr / local / info / emacs-7 < prev next >

Wrap

GNU Info File | 1995-09-11 | 48.2 KB | 1,131 lines

This is Info file ../info/emacs, produced by Makeinfo-1.55 from the input file emacs.texi. File: emacs, Node: Editing with VC, Next: Log Entries, Prev: VC Concepts, Up: Version Control Editing with Version Control ---------------------------- These are the commands for editing a file maintained with version control: `C-x C-q' `C-x v v' Check the visited file in or out. `C-x v u' Revert the buffer and the file to the last checked in version. `C-x v c' Remove the last-entered change from the master for the visited file. This undoes your last check-in. `C-x v i' Register the visited file for version control. (`C-x v' is the prefix key for version control commands; all of these commands except for `C-x C-q' start with `C-x v'.) * Menu: * Check-Out:: Checking out a file so you can edit it. * Check-In:: After you edit, you check in your changes to make a new version. * Version Control Undo:: Canceling changes before or after checkin. * Registering:: How to start using version control for a file. * VC Mode Line:: Mode line indicates version and lock status. * CVS and VC:: Checkout and checkin work differently in CVS. File: emacs, Node: Check-Out, Next: Check-In, Up: Editing with VC Check-Out ......... When you want to modify a file maintained with version control, type `C-x C-q' (`vc-toggle-read-only'). This "checks out" the file, and tells RCS or SCCS to lock the file. This means making the file writable for you (but not for anyone else). If you specify a prefix argument (`C-u C-x C-q') for checkout, Emacs asks you for a version number, and checks out that version *unlocked*. This lets you move to old versions, or existing branches of the file (*note Branches::.). You can then start editing the selected version by typing `C-x C-q' again. (If you edit an old version of a file this way, checking it in again creates a new branch.) File: emacs, Node: Check-In, Next: Version Control Undo, Prev: Check-Out, Up: Editing with VC Check-In ........ When you are finished editing the file, type `C-x C-q' again. When used on a file that is checked out, this command checks the file in. But check-in does not start immediately; first, you must enter the "log entry"--a description of the changes in the new version. `C-x C-q' pops up a buffer for you to enter this in. When you are finished typing in the log entry, type `C-c C-c' to terminate it; this is when actual check-in takes place. *Note Log Entries::. With RCS and SCCS, a checked-out file is also "locked", which means it is writable for you, but not for anyone else. As long as you own the lock on the file, nobody else can modify it, and nobody can check in any changes to that particular version. Checking in your changes unlocks the file, so that other users can lock it and modify it. CVS, on the contrary, doesn't have a concept of locking. The working files are always modifiable, allowing concurrent development, with possible conflicts being resolved at check-in time. *Note CVS and VC::. To specify the version number for the new version, type `C-u C-x C-q' to check in a file. Then Emacs asks you for the new version number in the minibuffer. This can be used to create a new "branch" of the file (*note Branches::.), or to increment the file's major version number. It is not impossible to lock a file that someone else has locked. If you try to check out a file that is locked, `C-x C-q' asks you whether you want to "steal the lock." If you say yes, the file becomes locked by you, but a message is sent to the person who had formerly locked the file, to inform him of what has happened. The mode line indicates that a file is locked by someone else by displaying the login name of that person, before the version number. File: emacs, Node: Registering, Next: VC Mode Line, Prev: Version Control Undo, Up: Editing with VC Registering a File for Version Control ...................................... `C-x v i' Register the visited file for version control. You can put any file under version control by simply visiting it, and then typing `C-x v i' (`vc-register'). After `C-x v i', the file is unlocked and read-only. Type `C-x C-q' if you wish to start editing it. When you register the file, Emacs must choose which version control system to use for it. You can specify your choice explicitly by setting `vc-default-back-end' to `RCS', `CVS' or `SCCS'. Otherwise, if there is a subdirectory named `RCS', `SCCS', or `CVS', Emacs uses the corresponding version control system. In the absence of any specification, the default choice is RCS if RCS is installed, otherwise SCCS. After registering a file with CVS, you must subsequently commit the initial version by typing `C-x C-q'. *Note CVS and VC::. The initial version number for a newly registered file is 1.1, by default. To specify a different number, give `C-x v i' a numeric argument; then it reads the initial version number using the minibuffer. If `vc-initial-comment' is non-`nil', `C-x v i' reads an initial comment (much like a log entry) to describe the purpose of this source file. File: emacs, Node: Version Control Undo, Next: Registering, Prev: Check-In, Up: Editing with VC Undoing Version Control Actions ............................... `C-x v u' Revert the buffer and the file to the last checked in version. `C-x v c' Remove the last-entered change from the master for the visited file. This undoes your last checkin. If you want to discard your current set of changes and revert to the last version checked in, use `C-x v u' (`vc-revert-buffer'). This cancels your last check-out, leaving the file unlocked. If you want to make a different set of changes, you must first check the file out again. `C-x v u' requires confirmation, unless it sees that you haven't made any changes since the last checked-in version. `C-x v u' is also the command to use to unlock a file if you lock it and then decide not to change it. You can cancel a change after checking it in, with `C-x v c' (`vc-cancel-version'). This command discards all record of the most recent checked in version. `C-x v c' also offers to revert your work file and buffer to the previous version (the one that precedes the version that is deleted). If you say `no', then the buffer and work file do not change. Be careful when invoking `C-x v c', as it is easy to throw away a lot of work with it. To help you be careful, this command always requires confirmation with `yes'. File: emacs, Node: VC Mode Line, Next: CVS and VC, Prev: Registering, Up: Editing with VC The VC Mode Line ................ When you visit a file that is under version control, the mode line indicates the current status of the file: the name of the version control back end system, the locking state, and the version. The locking state is displayed as a single character, which can be either `-' or `:'. `-' means the file is not locked or not modified by you. Once you lock the file, the state indicator changes to `:'. If the file is locked by someone else, that user's name appears after the version number. For example, `RCS-1.3' means you are looking at RCS version 1.3, which is not locked. `RCS:1.3' means that you have locked the file, and possibly already changed it. `RCS:jim:1.3' means that the file is locked by jim. File: emacs, Node: CVS and VC, Prev: VC Mode Line, Up: Editing with VC Using VC with CVS ................. In CVS, files are never locked. Two users can check out the same file at the same time; each user has a separate copy and can edit it. Work files are always writable; once you have one, you need not type a VC command to start editing the file. You can edit it at any time. CVS terminology speaks of "committing" a change rather than checking it in. But in practical terms they work the same way: Emacs asks you to type in a log entry, and you finish it with `C-c C-c'. When using RCS and SCCS, you normally use `C-x C-q' twice for each change; once before the change, for checkout, and once after, for checkin. With CVS, it's different: you normally use `C-x C-q' just once for each change, to commit the change when it is done. The work file remains writable, so you can begin editing again with no special commands. When you commit a change in a file, and someone else has committed another change in the meanwhile, that creates a "conflict". Then `C-x C-q' asks you to resolve the conflict and try again. VC does not provide a way to check out a working copy of an existing file in the repository. You have to use the CVS shell commands to do that. Once you have a work file, you can start using VC for that file. You can turn off use of VC for CVS-managed files by setting the variable `vc-handle-cvs' to `nil'. If you do this, Emacs treats these files as if they were not managed, and the VC commands are not available for them. You must do all CVS operations manually. File: emacs, Node: Log Entries, Next: Change Logs and VC, Prev: Editing with VC, Up: Version Control Log Entries ----------- When you're editing an initial comment or log entry for inclusion in a master file, finish your entry by typing `C-c C-c'. `C-c C-c' Finish the comment edit normally (`vc-finish-logentry'). This finishes check-in. To abort check-in, just *don't* type `C-c C-c' in that buffer. You can switch buffers and do other editing. As long as you don't try to check in another file, the entry you were editing remains in its buffer, and you can go back to that buffer at any time to complete the check-in. If you change several source files for the same reason, it is often convenient to specify the same log entry for many of the files. To do this, use the history of previous log entries. The commands `M-n', `M-p', `M-s' and `M-r' for doing this work just like the minibuffer history commands (except that these versions are used outside the minibuffer). Each time you check in a file, the log entry buffer is put into VC Log mode, which involves running two hooks: `text-mode-hook' and `vc-log-mode-hook'. *Note Hooks::. File: emacs, Node: Change Logs and VC, Next: Old Versions, Prev: Log Entries, Up: Version Control Change Logs and VC ------------------ If you use RCS 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 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 only; it does not work with CVS or SCCS. For example, suppose the first line of `ChangeLog' is dated 10 April 1992, and that the only check-in since then was by Nathaniel Bowditch to `rcs2log' on 8 May 1992 with log text `Ignore log messages that start with `#'.'. Then `C-x v a' visits `ChangeLog' and inserts text like this: Fri May 8 21:45:00 1992 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. 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: Wed May 6 10:53:00 1992 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 checkins 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': Wed Apr 1 08:57:59 1992 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: Wed Apr 1 08:57:59 1992 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: Old Versions, Next: Branches, Prev: Change Logs and VC, Up: Version Control Examining And Comparing Old Versions ------------------------------------ `C-u C-x C-q VERSION RET' Select version VERSION as the current work file version. `C-x v ~ VERSION RET' Examine version VERSION of the visited file, in a buffer of its own. `C-x v =' Compare the current buffer contents with the latest checked-in version of the file. `C-u C-x v = FILE RET OLDVERS RET NEWVERS RET' Compare the specified two versions of FILE. There are two ways to work with an old version of a file. You can make the old version your current work file, for example if you want to reproduce a former stage of development, or if you want to create a branch from the old version (*note Branches::.). To do this, visit the file and type `C-u C-x C-q VERSION RET'. (This works only with RCS.) If you want only to examine an old version, without changing your work file, visit the file and then type `C-x v ~ VERSION RET' (`vc-version-other-window'). This puts the text of version VERSION in a file named `FILENAME.~VERSION~', and visits it in its own buffer in a separate window. To compare two versions of a file, use the command `C-x v =' (`vc-diff'). Plain `C-x v =' compares the current buffer contents (saving them in the file if necessary) with the last checked-in version of the file. `C-u C-x v =', with a numeric argument, reads a file name and two version numbers, then compares those versions of the specified file. If you supply a directory name instead of the name of a work file, this command compares the two specified versions of all registered files in that directory and its subdirectories. You can also specify a snapshot name (*note Snapshots::.) instead of one or both version numbers. You can specify a checked-in version by its number; an empty input specifies the current contents of the work file (which may be different from all the checked-in versions). This command works by running the `diff' utility, getting the options from the variable `diff-switches'. It displays the output in a special buffer in another window. Unlike the `M-x diff' command, `C-x v =' does not try to locate the changes in the old and new versions. This is because normally one or both versions do not exist as files when you compare them; they exist only in the records of the master file. *Note Comparing Files::, for more information about `M-x diff'. File: emacs, Node: Branches, Next: Status in VC, Prev: Old Versions, Up: Version Control Multiple Branches of a File --------------------------- One use of version control is to maintain multiple "current" versions of a file. For example, you might have different versions of a program in which you are gradually adding various unfinished new features. Each such independent line of development is called a "branch". VC allows you to create branches, and switch between existing branches. Note, however, that branches are supported only with RCS. A file's main line of development is usually called the "trunk". The versions on the trunk are normally numbered 1.1, 1.2, 1.3, etc. At any such version, you may start an independent branch. A branch starting at version 1.2 would have version number 1.2.1.1. Consecutive versions on this branch would have numbers 1.2.1.2, 1.2.1.3, 1.2.1.4, and so on. If there is a second branch also starting at version 1.2; it would consist of versions 1.2.2.1, 1.2.2.2, 1.2.2.3, and so on. If you omit the final component of a version number, that is called a "branch number". It refers to the highest existing version on that branch. The branches in the example above have branch numbers 1.2.1 and 1.2.2. A version which is the last in its branch is called a "head" version. * Menu: * Switching Branches:: How to get to another existing branch. * Creating Branches:: How to start a new branch. * Multi-User Branching:: Multiple users working at multiple branches in parallel. File: emacs, Node: Switching Branches, Next: Creating Branches, Up: Branches Switching between Branches .......................... To switch between branches, type `C-u C-x C-q' and specify the version number you want to select. This version is then checked out *unlocked* (write-protected), so you can examine it before really checking it out. Switching branches in this way is allowed only when the file is not locked. You may omit the minor version number, thus giving only the branch number; this takes you to the highest version on the indicated branch. If you only type `RET', Emacs goes to the highest version on the trunk. After you have switched to any branch (including the main branch), you stay on it for subsequent VC commands, until you explicitly select some other branch. File: emacs, Node: Creating Branches, Next: Multi-User Branching, Prev: Switching Branches, Up: Branches Creating New Branches ..................... To create a new branch from a head version (one that is the latest in the branch that contains it), first select that version if necessary, lock it with `C-x C-q', and make whatever changes you want. Then, when you check in the changes, use `C-u C-x C-q'. This lets you specify the version number for the new version. You should specify a suitable branch number for a branch starting at the current version. For example, if the current version is 2.5, the branch number should be 2.5.1, 2.5.2, and so on, depending on the number of existing branches at that point. To create a new branch at an older version (one that is no longer the head of a branch), first select that version, lock it with `C-x C-q', and make your changes. Then type `C-x C-q' again to check in a new version. This automatically creates a new branch starting from the selected version. You need not specially request a new branch, because that's the only way to add a new version at a point that is not the head of a branch. After the branch is created, you "stay" on it. That means that subsequent checkouts and checkins create new versions on that branch. To leave the branch, you must explicitly select a different version with `C-u C-x C-q' for checkout. File: emacs, Node: Multi-User Branching, Prev: Creating Branches, Up: Branches Multi-User Branching .................... It is sometimes useful for multiple developers to work simultaneously on different branches of a file. This is possible if you create multiple source directories. Each source directory should have a link named `RCS' which points to a common directory of RCS master files. Then each source directory can have its own choice of versions checked out, but all share the same common RCS records. This technique works reliably and automatically, provided that the source files contain RCS version headers (*note Version Headers::.). The headers enable Emacs to be sure, at all times, which version number is present in the work file. If the files do not have version headers, you must instead tell Emacs explicitly in each session which branch you are working on. To do this, first find the file, then type `C-u C-x C-q' and specify the correct branch number. This ensures that Emacs knows which branch it is using during this particular editing session. File: emacs, Node: Status in VC, Next: Renaming and VC, Prev: Branches, Up: Version Control VC Status Commands ------------------ To view the detailed version control status and history of a file, type `C-x v l' (`vc-print-log'). It displays the history of changes to the current file, including the text of the log entries. The output appears in a separate window. When you are working on a large program, it's often useful to find all the files that are currently locked, or all the files maintained in version control at all. You can use `C-x v d' (`vc-directory') to show all the locked files in or beneath the current directory. This includes all files that are locked by any user. `C-u C-x v d' lists all files in or beneath the current directory that are maintained with version control. The list of files is displayed as a buffer that uses an augmented Dired mode. The names of the users locking various files are shown (in parentheses) in place of the owner and group. All the normal Dired commands work in this buffer. Most interactive VC commands work also, and apply to the file name on the current line. The `C-x v v' command (`vc-next-action'), when used in the augmented Dired buffer, operates on all the marked files (or the file on the current line). If it operates on more than one file, it handles each file according to its current state; thus, it may check out one file and check in another (because it is already checked out). If it has to check in any files, it reads a single log entry, then uses that text for all the files being checked in. This can be convenient for registering or checking in several files at once, as part of the same change. File: emacs, Node: Renaming and VC, Next: Snapshots, Prev: Status in VC, Up: Version Control 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: Snapshots, Next: Version Headers, Prev: Renaming and VC, 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' Check out all registered files at or below the current directory level using 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 the 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: Version Headers, Next: Customizing VC, Prev: Snapshots, Up: Version Control 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', 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. This is to prevent the string in the constant from being interpreted as a header itself 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 the start of the buffer. 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: Version Headers, Up: Version Control Customizing VC -------------- 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.) 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. When deducing the locked/unlocked state of a file, VC first looks for an RCS version header string in the file (*note Version Headers::.). If there is no header string (or if the backend system is SCCS), 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 lock status by setting `vc-consult-headers' to `nil'. VC then always uses the file permissions (if it can 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 may 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', `CVS' or `SCCS' 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. 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. But the proper files are usually found automatically. 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' prints 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 authors (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', whose value should be a string. 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. See also *Note Emerge::, for convenient facilities for merging two similar files. File: emacs, Node: Misc File Ops, 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 wild card 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 `C-h' while viewing for a list of them. They are mostly the same as normal Emacs cursor motion commands. To exit from viewing, type `C-c'. 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' 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 a file named 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 must belong on the same file system that the file is on. `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 OLD and LINKNAME, then creates a symbolic link named LINKNAME and pointing at OLD. The effect is that future attempts to open file LINKNAME will refer to whatever file is named OLD at the time the opening is done, or will get an error if the name OLD is not in use at that time. This command does not expand the argument FILENAME, 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. 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 "selected". It is also called the "current 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 selected buffer (most commands do). When Emacs has multiple windows, each window has a chosen buffer which is displayed there, but at any time only one of the windows is selected and its chosen buffer is the selected buffer. Each window's mode line displays the name of the buffer that the window is displaying (*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::. * 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-onliness; 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. 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 most recently selected buffer that is not displayed in any window. 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 which 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::. 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, most recently visited 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 selected 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/'. 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, the value of point that resulted from your perusal remains 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::. File: emacs, Node: Kill Buffer, Next: Several Buffers, Prev: Misc Buffer, Up: Buffers Killing Buffers =============== If you continue an Emacs session for a while, you may accumulate a large number of buffers. You may then find it convenient to "kill" the buffers you no longer need. On most operating systems, killing a buffer releases its space back to the operating system so that other programs can use it. Here are some commands for killing buffers: `C-x k BUFNAME RET' Kill buffer BUFNAME (`kill-buffer'). `M-x kill-some-buffers' Offer to kill each buffer, one by one. `C-x k' (`kill-buffer') kills one buffer, whose name you specify in the minibuffer. The default, used if you type just RET in the minibuffer, is to kill the current buffer. If you kill the current buffer, another buffer is selected; one that has been selected recently but does not appear in any window now. If you ask to kill a file-visiting buffer that is modified (has unsaved editing), then you must confirm with `yes' before the buffer is killed. The command `M-x kill-some-buffers' asks about each buffer, one by one. An answer of `y' means to kill the buffer. Killing the current buffer or a buffer containing unsaved changes selects a new buffer or asks for confirmation just like `kill-buffer'. The buffer menu feature (*note Several Buffers::.) is also convenient for killing various buffers. If you want to do something special every time a buffer is killed, you can add hook functions to the hook `kill-buffer-hook' (*note Hooks::.).