This is Info file ../../info/lispref.info, produced by Makeinfo version 1.68 from the input file lispref.texi. Edition History: GNU Emacs Lisp Reference Manual Second Edition (v2.01), May 1993 GNU Emacs Lisp Reference Manual Further Revised (v2.02), August 1993 Lucid Emacs Lisp Reference Manual (for 19.10) First Edition, March 1994 XEmacs Lisp Programmer's Manual (for 19.12) Second Edition, April 1995 GNU Emacs Lisp Reference Manual v2.4, June 1995 XEmacs Lisp Programmer's Manual (for 19.13) Third Edition, July 1995 XEmacs Lisp Reference Manual (for 19.14 and 20.0) v3.1, March 1996 XEmacs Lisp Reference Manual (for 19.15 and 20.1, 20.2) v3.2, April, May 1997 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc. Copyright (C) 1994, 1995 Sun Microsystems, Inc. Copyright (C) 1995, 1996 Ben Wing. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the section entitled "GNU General Public License" is included exactly as in the original, and provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that the section entitled "GNU General Public License" may be included in a translation approved by the Free Software Foundation instead of in the original English.  File: lispref.info, Node: Format Conversion, Next: Files and MS-DOS, Prev: Partial Files, Up: Files File Format Conversion ====================== The variable `format-alist' defines a list of "file formats", which describe textual representations used in files for the data (text, text-properties, and possibly other information) in an Emacs buffer. Emacs performs format conversion if appropriate when reading and writing files. - Variable: format-alist This list contains one format definition for each defined file format. Each format definition is a list of this form: (NAME DOC-STRING REGEXP FROM-FN TO-FN MODIFY MODE-FN) Here is what the elements in a format definition mean: NAME The name of this format. DOC-STRING A documentation string for the format. REGEXP A regular expression which is used to recognize files represented in this format. FROM-FN A function to call to decode data in this format (to convert file data into the usual Emacs data representation). The FROM-FN is called with two args, BEGIN and END, which specify the part of the buffer it should convert. It should convert the text by editing it in place. Since this can change the length of the text, FROM-FN should return the modified end position. One responsibility of FROM-FN is to make sure that the beginning of the file no longer matches REGEXP. Otherwise it is likely to get called again. TO-FN A function to call to encode data in this format (to convert the usual Emacs data representation into this format). The TO-FN is called with two args, BEGIN and END, which specify the part of the buffer it should convert. There are two ways it can do the conversion: * By editing the buffer in place. In this case, TO-FN should return the end-position of the range of text, as modified. * By returning a list of annotations. This is a list of elements of the form `(POSITION . STRING)', where POSITION is an integer specifying the relative position in the text to be written, and STRING is the annotation to add there. The list must be sorted in order of position when TO-FN returns it. When `write-region' actually writes the text from the buffer to the file, it intermixes the specified annotations at the corresponding positions. All this takes place without modifying the buffer. MODIFY A flag, `t' if the encoding function modifies the buffer, and `nil' if it works by returning a list of annotations. MODE A mode function to call after visiting a file converted from this format. The function `insert-file-contents' automatically recognizes file formats when it reads the specified file. It checks the text of the beginning of the file against the regular expressions of the format definitions, and if it finds a match, it calls the decoding function for that format. Then it checks all the known formats over again. It keeps checking them until none of them is applicable. Visiting a file, with `find-file-noselect' or the commands that use it, performs conversion likewise (because it calls `insert-file-contents'); it also calls the mode function for each format that it decodes. It stores a list of the format names in the buffer-local variable `buffer-file-format'. - Variable: buffer-file-format This variable states the format of the visited file. More precisely, this is a list of the file format names that were decoded in the course of visiting the current buffer's file. It is always local in all buffers. When `write-region' writes data into a file, it first calls the encoding functions for the formats listed in `buffer-file-format', in the order of appearance in the list. - Function: format-write-file FILE FORMAT This command writes the current buffer contents into the file FILE in format FORMAT, and makes that format the default for future saves of the buffer. The argument FORMAT is a list of format names. - Function: format-find-file FILE FORMAT This command finds the file FILE, converting it according to format FORMAT. It also makes FORMAT the default if the buffer is saved later. The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just for FORMAT specifies `nil'. - Function: format-insert-file FILE FORMAT &optional BEG END This command inserts the contents of file FILE, converting it according to format FORMAT. If BEG and END are non-`nil', they specify which part of the file to read, as in `insert-file-contents' (*note Reading from Files::.). The return value is like what `insert-file-contents' returns: a list of the absolute file name and the length of the data inserted (after conversion). The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just for FORMAT specifies `nil'. - Function: format-find-file FILE FORMAT This command finds the file FILE, converting it according to format FORMAT. It also makes FORMAT the default if the buffer is saved later. The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just for FORMAT specifies `nil'. - Function: format-insert-file FILE FORMAT &optional BEG END This command inserts the contents of file FILE, converting it according to format FORMAT. If BEG and END are non-`nil', they specify which part of the file to read, as in `insert-file-contents' (*note Reading from Files::.). The return value is like what `insert-file-contents' returns: a list of the absolute file name and the length of the data inserted (after conversion). The argument FORMAT is a list of format names. If FORMAT is `nil', no conversion takes place. Interactively, typing just for FORMAT specifies `nil'. - Variable: auto-save-file-format This variable specifies the format to use for auto-saving. Its value is a list of format names, just like the value of `buffer-file-format'; but it is used instead of `buffer-file-format' for writing auto-save files. This variable is always local in all buffers.  File: lispref.info, Node: Files and MS-DOS, Prev: Format Conversion, Up: Files Files and MS-DOS ================ Emacs on MS-DOS makes a distinction between text files and binary files. This is necessary because ordinary text files on MS-DOS use a two character sequence between lines: carriage-return and linefeed (CRLF). Emacs expects just a newline character (a linefeed) between lines. When Emacs reads or writes a text file on MS-DOS, it needs to convert the line separators. This means it needs to know which files are text files and which are binary. It makes this decision when visiting a file, and records the decision in the variable `buffer-file-type' for use when the file is saved. *Note MS-DOS Subprocesses::, for a related feature for subprocesses. - Variable: buffer-file-type This variable, automatically local in each buffer, records the file type of the buffer's visited file. The value is `nil' for text, `t' for binary. - Function: find-buffer-file-type FILENAME This function determines whether file FILENAME is a text file or a binary file. It returns `nil' for text, `t' for binary. - User Option: file-name-buffer-file-type-alist This variable holds an alist for distinguishing text files from binary files. Each element has the form (REGEXP . TYPE), where REGEXP is matched against the file name, and TYPE may be is `nil' for text, `t' for binary, or a function to call to compute which. If it is a function, then it is called with a single argument (the file name) and should return `t' or `nil'. - User Option: default-buffer-file-type This variable specifies the default file type for files whose names don't indicate anything in particular. Its value should be `nil' for text, or `t' for binary. - Command: find-file-text FILENAME Like `find-file', but treat the file as text regardless of its name. - Command: find-file-binary FILENAME Like `find-file', but treat the file as binary regardless of its name.  File: lispref.info, Node: Backups and Auto-Saving, Next: Buffers, Prev: Files, Up: Top Backups and Auto-Saving *********************** Backup files and auto-save files are two methods by which XEmacs tries to protect the user from the consequences of crashes or of the user's own errors. Auto-saving preserves the text from earlier in the current editing session; backup files preserve file contents prior to the current session. * Menu: * Backup Files:: How backup files are made; how their names are chosen. * Auto-Saving:: How auto-save files are made; how their names are chosen. * Reverting:: `revert-buffer', and how to customize what it does.  File: lispref.info, Node: Backup Files, Next: Auto-Saving, Up: Backups and Auto-Saving Backup Files ============ A "backup file" is a copy of the old contents of a file you are editing. XEmacs makes a backup file the first time you save a buffer into its visited file. Normally, this means that the backup file contains the contents of the file as it was before the current editing session. The contents of the backup file normally remain unchanged once it exists. Backups are usually made by renaming the visited file to a new name. Optionally, you can specify that backup files should be made by copying the visited file. This choice makes a difference for files with multiple names; it also can affect whether the edited file remains owned by the original owner or becomes owned by the user editing it. By default, XEmacs makes a single backup file for each file edited. You can alternatively request numbered backups; then each new backup file gets a new name. You can delete old numbered backups when you don't want them any more, or XEmacs can delete them automatically. * Menu: * Making Backups:: How XEmacs makes backup files, and when. * Rename or Copy:: Two alternatives: renaming the old file or copying it. * Numbered Backups:: Keeping multiple backups for each source file. * Backup Names:: How backup file names are computed; customization.  File: lispref.info, Node: Making Backups, Next: Rename or Copy, Up: Backup Files Making Backup Files ------------------- - Function: backup-buffer This function makes a backup of the file visited by the current buffer, if appropriate. It is called by `save-buffer' before saving the buffer the first time. - Variable: buffer-backed-up This buffer-local variable indicates whether this buffer's file has been backed up on account of this buffer. If it is non-`nil', then the backup file has been written. Otherwise, the file should be backed up when it is next saved (if backups are enabled). This is a permanent local; `kill-local-variables' does not alter it. - User Option: make-backup-files This variable determines whether or not to make backup files. If it is non-`nil', then XEmacs creates a backup of each file when it is saved for the first time--provided that `backup-inhibited' is `nil' (see below). The following example shows how to change the `make-backup-files' variable only in the `RMAIL' buffer and not elsewhere. Setting it `nil' stops XEmacs from making backups of the `RMAIL' file, which may save disk space. (You would put this code in your `.emacs' file.) (add-hook 'rmail-mode-hook (function (lambda () (make-local-variable 'make-backup-files) (setq make-backup-files nil)))) - Variable: backup-enable-predicate This variable's value is a function to be called on certain occasions to decide whether a file should have backup files. The function receives one argument, a file name to consider. If the function returns `nil', backups are disabled for that file. Otherwise, the other variables in this section say whether and how to make backups. The default value is this: (lambda (name) (or (< (length name) 5) (not (string-equal "/tmp/" (substring name 0 5))))) - Variable: backup-inhibited If this variable is non-`nil', backups are inhibited. It records the result of testing `backup-enable-predicate' on the visited file name. It can also coherently be used by other mechanisms that inhibit backups based on which file is visited. For example, VC sets this variable non-`nil' to prevent making backups for files managed with a version control system. This is a permanent local, so that changing the major mode does not lose its value. Major modes should not set this variable--they should set `make-backup-files' instead.  File: lispref.info, Node: Rename or Copy, Next: Numbered Backups, Prev: Making Backups, Up: Backup Files Backup by Renaming or by Copying? --------------------------------- There are two ways that XEmacs can make a backup file: * XEmacs can rename the original file so that it becomes a backup file, and then write the buffer being saved into a new file. After this procedure, any other names (i.e., hard links) of the original file now refer to the backup file. The new file is owned by the user doing the editing, and its group is the default for new files written by the user in that directory. * XEmacs can copy the original file into a backup file, and then overwrite the original file with new contents. After this procedure, any other names (i.e., hard links) of the original file still refer to the current version of the file. The file's owner and group will be unchanged. The first method, renaming, is the default. The variable `backup-by-copying', if non-`nil', says to use the second method, which is to copy the original file and overwrite it with the new buffer contents. The variable `file-precious-flag', if non-`nil', also has this effect (as a sideline of its main significance). *Note Saving Buffers::. - Variable: backup-by-copying If this variable is non-`nil', XEmacs always makes backup files by copying. The following two variables, when non-`nil', cause the second method to be used in certain special cases. They have no effect on the treatment of files that don't fall into the special cases. - Variable: backup-by-copying-when-linked If this variable is non-`nil', XEmacs makes backups by copying for files with multiple names (hard links). This variable is significant only if `backup-by-copying' is `nil', since copying is always used when that variable is non-`nil'. - Variable: backup-by-copying-when-mismatch If this variable is non-`nil', XEmacs makes backups by copying in cases where renaming would change either the owner or the group of the file. The value has no effect when renaming would not alter the owner or group of the file; that is, for files which are owned by the user and whose group matches the default for a new file created there by the user. This variable is significant only if `backup-by-copying' is `nil', since copying is always used when that variable is non-`nil'.  File: lispref.info, Node: Numbered Backups, Next: Backup Names, Prev: Rename or Copy, Up: Backup Files Making and Deleting Numbered Backup Files ----------------------------------------- If a file's name is `foo', the names of its numbered backup versions are `foo.~V~', for various integers V, like this: `foo.~1~', `foo.~2~', `foo.~3~', ..., `foo.~259~', and so on. - User Option: version-control This variable controls whether to make a single non-numbered backup file or multiple numbered backups. `nil' Make numbered backups if the visited file already has numbered backups; otherwise, do not. `never' Do not make numbered backups. ANYTHING ELSE Make numbered backups. The use of numbered backups ultimately leads to a large number of backup versions, which must then be deleted. XEmacs can do this automatically or it can ask the user whether to delete them. - User Option: kept-new-versions The value of this variable is the number of newest versions to keep when a new numbered backup is made. The newly made backup is included in the count. The default value is 2. - User Option: kept-old-versions The value of this variable is the number of oldest versions to keep when a new numbered backup is made. The default value is 2. If there are backups numbered 1, 2, 3, 5, and 7, and both of these variables have the value 2, then the backups numbered 1 and 2 are kept as old versions and those numbered 5 and 7 are kept as new versions; backup version 3 is excess. The function `find-backup-file-name' (*note Backup Names::.) is responsible for determining which backup versions to delete, but does not delete them itself. - User Option: trim-versions-without-asking If this variable is non-`nil', then saving a file deletes excess backup versions silently. Otherwise, it asks the user whether to delete them. - User Option: dired-kept-versions This variable specifies how many of the newest backup versions to keep in the Dired command `.' (`dired-clean-directory'). That's the same thing `kept-new-versions' specifies when you make a new backup file. The default value is 2.  File: lispref.info, Node: Backup Names, Prev: Numbered Backups, Up: Backup Files Naming Backup Files ------------------- The functions in this section are documented mainly because you can customize the naming conventions for backup files by redefining them. If you change one, you probably need to change the rest. - Function: backup-file-name-p FILENAME This function returns a non-`nil' value if FILENAME is a possible name for a backup file. A file with the name FILENAME need not exist; the function just checks the name. (backup-file-name-p "foo") => nil (backup-file-name-p "foo~") => 3 The standard definition of this function is as follows: (defun backup-file-name-p (file) "Return non-nil if FILE is a backup file \ name (numeric or not)..." (string-match "~$" file)) Thus, the function returns a non-`nil' value if the file name ends with a `~'. (We use a backslash to split the documentation string's first line into two lines in the text, but produce just one line in the string itself.) This simple expression is placed in a separate function to make it easy to redefine for customization. - Function: make-backup-file-name FILENAME This function returns a string that is the name to use for a non-numbered backup file for file FILENAME. On Unix, this is just FILENAME with a tilde appended. The standard definition of this function is as follows: (defun make-backup-file-name (file) "Create the non-numeric backup file name for FILE. ..." (concat file "~")) You can change the backup-file naming convention by redefining this function. The following example redefines `make-backup-file-name' to prepend a `.' in addition to appending a tilde: (defun make-backup-file-name (filename) (concat "." filename "~")) (make-backup-file-name "backups.texi") => ".backups.texi~" - Function: find-backup-file-name FILENAME This function computes the file name for a new backup file for FILENAME. It may also propose certain existing backup files for deletion. `find-backup-file-name' returns a list whose CAR is the name for the new backup file and whose CDR is a list of backup files whose deletion is proposed. Two variables, `kept-old-versions' and `kept-new-versions', determine which backup versions should be kept. This function keeps those versions by excluding them from the CDR of the value. *Note Numbered Backups::. In this example, the value says that `~rms/foo.~5~' is the name to use for the new backup file, and `~rms/foo.~3~' is an "excess" version that the caller should consider deleting now. (find-backup-file-name "~rms/foo") => ("~rms/foo.~5~" "~rms/foo.~3~") - Function: file-newest-backup FILENAME This function returns the name of the most recent backup file for FILENAME, or `nil' if that file has no backup files. Some file comparison commands use this function so that they can automatically compare a file with its most recent backup.  File: lispref.info, Node: Auto-Saving, Next: Reverting, Prev: Backup Files, Up: Backups and Auto-Saving Auto-Saving =========== XEmacs periodically saves all files that you are visiting; this is called "auto-saving". Auto-saving prevents you from losing more than a limited amount of work if the system crashes. By default, auto-saves happen every 300 keystrokes, or after around 30 seconds of idle time. *Note Auto-Save: (emacs)Auto-Save, for information on auto-save for users. Here we describe the functions used to implement auto-saving and the variables that control them. - Variable: buffer-auto-save-file-name This buffer-local variable is the name of the file used for auto-saving the current buffer. It is `nil' if the buffer should not be auto-saved. buffer-auto-save-file-name => "/xcssun/users/rms/lewis/#files.texi#" - Command: auto-save-mode ARG When used interactively without an argument, this command is a toggle switch: it turns on auto-saving of the current buffer if it is off, and vice-versa. With an argument ARG, the command turns auto-saving on if the value of ARG is `t', a nonempty list, or a positive integer. Otherwise, it turns auto-saving off. - Function: auto-save-file-name-p FILENAME This function returns a non-`nil' value if FILENAME is a string that could be the name of an auto-save file. It works based on knowledge of the naming convention for auto-save files: a name that begins and ends with hash marks (`#') is a possible auto-save file name. The argument FILENAME should not contain a directory part. (make-auto-save-file-name) => "/xcssun/users/rms/lewis/#files.texi#" (auto-save-file-name-p "#files.texi#") => 0 (auto-save-file-name-p "files.texi") => nil The standard definition of this function is as follows: (defun auto-save-file-name-p (filename) "Return non-nil if FILENAME can be yielded by..." (string-match "^#.*#$" filename)) This function exists so that you can customize it if you wish to change the naming convention for auto-save files. If you redefine it, be sure to redefine the function `make-auto-save-file-name' correspondingly. - Function: make-auto-save-file-name This function returns the file name to use for auto-saving the current buffer. This is just the file name with hash marks (`#') appended and prepended to it. This function does not look at the variable `auto-save-visited-file-name' (described below); you should check that before calling this function. (make-auto-save-file-name) => "/xcssun/users/rms/lewis/#backup.texi#" The standard definition of this function is as follows: (defun make-auto-save-file-name () "Return file name to use for auto-saves \ of current buffer. ..." (if buffer-file-name (concat (file-name-directory buffer-file-name) "#" (file-name-nondirectory buffer-file-name) "#") (expand-file-name (concat "#%" (buffer-name) "#")))) This exists as a separate function so that you can redefine it to customize the naming convention for auto-save files. Be sure to change `auto-save-file-name-p' in a corresponding way. - Variable: auto-save-visited-file-name If this variable is non-`nil', XEmacs auto-saves buffers in the files they are visiting. That is, the auto-save is done in the same file that you are editing. Normally, this variable is `nil', so auto-save files have distinct names that are created by `make-auto-save-file-name'. When you change the value of this variable, the value does not take effect until the next time auto-save mode is reenabled in any given buffer. If auto-save mode is already enabled, auto-saves continue to go in the same file name until `auto-save-mode' is called again. - Function: recent-auto-save-p This function returns `t' if the current buffer has been auto-saved since the last time it was read in or saved. - Function: set-buffer-auto-saved This function marks the current buffer as auto-saved. The buffer will not be auto-saved again until the buffer text is changed again. The function returns `nil'. - User Option: auto-save-interval The value of this variable is the number of characters that XEmacs reads from the keyboard between auto-saves. Each time this many more characters are read, auto-saving is done for all buffers in which it is enabled. - User Option: auto-save-timeout The value of this variable is the number of seconds of idle time that should cause auto-saving. Each time the user pauses for this long, XEmacs auto-saves any buffers that need it. (Actually, the specified timeout is multiplied by a factor depending on the size of the current buffer.) - Variable: auto-save-hook This normal hook is run whenever an auto-save is about to happen. - User Option: auto-save-default If this variable is non-`nil', buffers that are visiting files have auto-saving enabled by default. Otherwise, they do not. - Command: do-auto-save &optional NO-MESSAGE CURRENT-ONLY This function auto-saves all buffers that need to be auto-saved. It saves all buffers for which auto-saving is enabled and that have been changed since the previous auto-save. Normally, if any buffers are auto-saved, a message that says `Auto-saving...' is displayed in the echo area while auto-saving is going on. However, if NO-MESSAGE is non-`nil', the message is inhibited. If CURRENT-ONLY is non-`nil', only the current buffer is auto-saved. - Function: delete-auto-save-file-if-necessary This function deletes the current buffer's auto-save file if `delete-auto-save-files' is non-`nil'. It is called every time a buffer is saved. - Variable: delete-auto-save-files This variable is used by the function `delete-auto-save-file-if-necessary'. If it is non-`nil', Emacs deletes auto-save files when a true save is done (in the visited file). This saves disk space and unclutters your directory. - Function: rename-auto-save-file This function adjusts the current buffer's auto-save file name if the visited file name has changed. It also renames an existing auto-save file. If the visited file name has not changed, this function does nothing. - Variable: buffer-saved-size The value of this buffer-local variable is the length of the current buffer as of the last time it was read in, saved, or auto-saved. This is used to detect a substantial decrease in size, and turn off auto-saving in response. If it is -1, that means auto-saving is temporarily shut off in this buffer due to a substantial deletion. Explicitly saving the buffer stores a positive value in this variable, thus reenabling auto-saving. Turning auto-save mode off or on also alters this variable. - Variable: auto-save-list-file-name This variable (if non-`nil') specifies a file for recording the names of all the auto-save files. Each time XEmacs does auto-saving, it writes two lines into this file for each buffer that has auto-saving enabled. The first line gives the name of the visited file (it's empty if the buffer has none), and the second gives the name of the auto-save file. If XEmacs exits normally, it deletes this file. If XEmacs crashes, you can look in the file to find all the auto-save files that might contain work that was otherwise lost. The `recover-session' command uses these files. The default name for this file is in your home directory and starts with `.saves-'. It also contains the XEmacs process ID and the host name.  File: lispref.info, Node: Reverting, Prev: Auto-Saving, Up: Backups and Auto-Saving Reverting ========= If you have made extensive changes to a file and then change your mind about them, you can get rid of them by reading in the previous version of the file with the `revert-buffer' command. *Note Reverting a Buffer: (emacs)Reverting. - Command: revert-buffer &optional CHECK-AUTO-SAVE NOCONFIRM This command replaces the buffer text with the text of the visited file on disk. This action undoes all changes since the file was visited or saved. If the argument CHECK-AUTO-SAVE is non-`nil', and the latest auto-save file is more recent than the visited file, `revert-buffer' asks the user whether to use that instead. Otherwise, it always uses the text of the visited file itself. Interactively, CHECK-AUTO-SAVE is set if there is a numeric prefix argument. Normally, `revert-buffer' asks for confirmation before it changes the buffer; but if the argument NOCONFIRM is non-`nil', `revert-buffer' does not ask for confirmation. Reverting tries to preserve marker positions in the buffer by using the replacement feature of `insert-file-contents'. If the buffer contents and the file contents are identical before the revert operation, reverting preserves all the markers. If they are not identical, reverting does change the buffer; then it preserves the markers in the unchanged text (if any) at the beginning and end of the buffer. Preserving any additional markers would be problematical. You can customize how `revert-buffer' does its work by setting these variables--typically, as buffer-local variables. - Variable: revert-buffer-function The value of this variable is the function to use to revert this buffer. If non-`nil', it is called as a function with no arguments to do the work of reverting. If the value is `nil', reverting works the usual way. Modes such as Dired mode, in which the text being edited does not consist of a file's contents but can be regenerated in some other fashion, give this variable a buffer-local value that is a function to regenerate the contents. - Variable: revert-buffer-insert-file-contents-function The value of this variable, if non-`nil', is the function to use to insert the updated contents when reverting this buffer. The function receives two arguments: first the file name to use; second, `t' if the user has asked to read the auto-save file. - Variable: before-revert-hook This normal hook is run by `revert-buffer' before actually inserting the modified contents--but only if `revert-buffer-function' is `nil'. Font Lock mode uses this hook to record that the buffer contents are no longer fontified. - Variable: after-revert-hook This normal hook is run by `revert-buffer' after actually inserting the modified contents--but only if `revert-buffer-function' is `nil'. Font Lock mode uses this hook to recompute the fonts for the updated buffer contents.  File: lispref.info, Node: Buffers, Next: Windows, Prev: Backups and Auto-Saving, Up: Top Buffers ******* A "buffer" is a Lisp object containing text to be edited. Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files. While several buffers may exist at one time, exactly one buffer is designated the "current buffer" at any time. Most editing commands act on the contents of the current buffer. Each buffer, including the current buffer, may or may not be displayed in any windows. * Menu: * Buffer Basics:: What is a buffer? * Current Buffer:: Designating a buffer as current so primitives will access its contents. * Buffer Names:: Accessing and changing buffer names. * Buffer File Name:: The buffer file name indicates which file is visited. * Buffer Modification:: A buffer is "modified" if it needs to be saved. * Modification Time:: Determining whether the visited file was changed "behind XEmacs's back". * Read Only Buffers:: Modifying text is not allowed in a read-only buffer. * The Buffer List:: How to look at all the existing buffers. * Creating Buffers:: Functions that create buffers. * Killing Buffers:: Buffers exist until explicitly killed. * Indirect Buffers:: An indirect buffer shares text with some other buffer.  File: lispref.info, Node: Buffer Basics, Next: Current Buffer, Up: Buffers Buffer Basics ============= A "buffer" is a Lisp object containing text to be edited. Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files. While several buffers may exist at one time, exactly one buffer is designated the "current buffer" at any time. Most editing commands act on the contents of the current buffer. Each buffer, including the current buffer, may or may not be displayed in any windows. Buffers in Emacs editing are objects that have distinct names and hold text that can be edited. Buffers appear to Lisp programs as a special data type. You can think of the contents of a buffer as an extendable string; insertions and deletions may occur in any part of the buffer. *Note Text::. A Lisp buffer object contains numerous pieces of information. Some of this information is directly accessible to the programmer through variables, while other information is accessible only through special-purpose functions. For example, the visited file name is directly accessible through a variable, while the value of point is accessible only through a primitive function. Buffer-specific information that is directly accessible is stored in "buffer-local" variable bindings, which are variable values that are effective only in a particular buffer. This feature allows each buffer to override the values of certain variables. Most major modes override variables such as `fill-column' or `comment-column' in this way. For more information about buffer-local variables and functions related to them, see *Note Buffer-Local Variables::. For functions and variables related to visiting files in buffers, see *Note Visiting Files:: and *Note Saving Buffers::. For functions and variables related to the display of buffers in windows, see *Note Buffers and Windows::. - Function: bufferp OBJECT This function returns `t' if OBJECT is a buffer, `nil' otherwise.  File: lispref.info, Node: Current Buffer, Next: Buffer Names, Prev: Buffer Basics, Up: Buffers The Current Buffer ================== There are, in general, many buffers in an Emacs session. At any time, one of them is designated as the "current buffer". This is the buffer in which most editing takes place, because most of the primitives for examining or changing text in a buffer operate implicitly on the current buffer (*note Text::.). Normally the buffer that is displayed on the screen in the selected window is the current buffer, but this is not always so: a Lisp program can designate any buffer as current temporarily in order to operate on its contents, without changing what is displayed on the screen. The way to designate a current buffer in a Lisp program is by calling `set-buffer'. The specified buffer remains current until a new one is designated. When an editing command returns to the editor command loop, the command loop designates the buffer displayed in the selected window as current, to prevent confusion: the buffer that the cursor is in when Emacs reads a command is the buffer that the command will apply to. (*Note Command Loop::.) Therefore, `set-buffer' is not the way to switch visibly to a different buffer so that the user can edit it. For this, you must use the functions described in *Note Displaying Buffers::. However, Lisp functions that change to a different current buffer should not depend on the command loop to set it back afterwards. Editing commands written in XEmacs Lisp can be called from other programs as well as from the command loop. It is convenient for the caller if the subroutine does not change which buffer is current (unless, of course, that is the subroutine's purpose). Therefore, you should normally use `set-buffer' within a `save-excursion' that will restore the current buffer when your function is done (*note Excursions::.). Here is an example, the code for the command `append-to-buffer' (with the documentation string abridged): (defun append-to-buffer (buffer start end) "Append to specified buffer the text of the region. ..." (interactive "BAppend to buffer: \nr") (let ((oldbuf (current-buffer))) (save-excursion (set-buffer (get-buffer-create buffer)) (insert-buffer-substring oldbuf start end)))) This function binds a local variable to the current buffer, and then `save-excursion' records the values of point, the mark, and the original buffer. Next, `set-buffer' makes another buffer current. Finally, `insert-buffer-substring' copies the string from the original current buffer to the new current buffer. If the buffer appended to happens to be displayed in some window, the next redisplay will show how its text has changed. Otherwise, you will not see the change immediately on the screen. The buffer becomes current temporarily during the execution of the command, but this does not cause it to be displayed. If you make local bindings (with `let' or function arguments) for a variable that may also have buffer-local bindings, make sure that the same buffer is current at the beginning and at the end of the local binding's scope. Otherwise you might bind it in one buffer and unbind it in another! There are two ways to do this. In simple cases, you may see that nothing ever changes the current buffer within the scope of the binding. Otherwise, use `save-excursion' to make sure that the buffer current at the beginning is current again whenever the variable is unbound. It is not reliable to change the current buffer back with `set-buffer', because that won't do the job if a quit happens while the wrong buffer is current. Here is what *not* to do: (let (buffer-read-only (obuf (current-buffer))) (set-buffer ...) ... (set-buffer obuf)) Using `save-excursion', as shown below, handles quitting, errors, and `throw', as well as ordinary evaluation. (let (buffer-read-only) (save-excursion (set-buffer ...) ...)) - Function: current-buffer This function returns the current buffer. (current-buffer) => # - Function: set-buffer BUFFER-OR-NAME This function makes BUFFER-OR-NAME the current buffer. It does not display the buffer in the currently selected window or in any other window, so the user cannot necessarily see the buffer. But Lisp programs can in any case work on it. This function returns the buffer identified by BUFFER-OR-NAME. An error is signaled if BUFFER-OR-NAME does not identify an existing buffer.  File: lispref.info, Node: Buffer Names, Next: Buffer File Name, Prev: Current Buffer, Up: Buffers Buffer Names ============ Each buffer has a unique name, which is a string. Many of the functions that work on buffers accept either a buffer or a buffer name as an argument. Any argument called BUFFER-OR-NAME is of this sort, and an error is signaled if it is neither a string nor a buffer. Any argument called BUFFER must be an actual buffer object, not a name. Buffers that are ephemeral and generally uninteresting to the user have names starting with a space, so that the `list-buffers' and `buffer-menu' commands don't mention them. A name starting with space also initially disables recording undo information; see *Note Undo::. - Function: buffer-name &optional BUFFER This function returns the name of BUFFER as a string. If BUFFER is not supplied, it defaults to the current buffer. If `buffer-name' returns `nil', it means that BUFFER has been killed. *Note Killing Buffers::. (buffer-name) => "buffers.texi" (setq foo (get-buffer "temp")) => # (kill-buffer foo) => nil (buffer-name foo) => nil foo => # - Command: rename-buffer NEWNAME &optional UNIQUE This function renames the current buffer to NEWNAME. An error is signaled if NEWNAME is not a string, or if there is already a buffer with that name. The function returns `nil'. Ordinarily, `rename-buffer' signals an error if NEWNAME is already in use. However, if UNIQUE is non-`nil', it modifies NEWNAME to make a name that is not in use. Interactively, you can make UNIQUE non-`nil' with a numeric prefix argument. One application of this command is to rename the `*shell*' buffer to some other name, thus making it possible to create a second shell buffer under the name `*shell*'. - Function: get-buffer BUFFER-OR-NAME This function returns the buffer specified by BUFFER-OR-NAME. If BUFFER-OR-NAME is a string and there is no buffer with that name, the value is `nil'. If BUFFER-OR-NAME is a buffer, it is returned as given. (That is not very useful, so the argument is usually a name.) For example: (setq b (get-buffer "lewis")) => # (get-buffer b) => # (get-buffer "Frazzle-nots") => nil See also the function `get-buffer-create' in *Note Creating Buffers::. - Function: generate-new-buffer-name STARTING-NAME &optional IGNORE This function returns a name that would be unique for a new buffer--but does not create the buffer. It starts with STARTING-NAME, and produces a name not currently in use for any buffer by appending a number inside of `<...>'. If IGNORE is given, it specifies a name that is okay to use (if it is in the sequence to be tried), even if a buffer with that name exists. See the related function `generate-new-buffer' in *Note Creating Buffers::.  File: lispref.info, Node: Buffer File Name, Next: Buffer Modification, Prev: Buffer Names, Up: Buffers Buffer File Name ================ The "buffer file name" is the name of the file that is visited in that buffer. When a buffer is not visiting a file, its buffer file name is `nil'. Most of the time, the buffer name is the same as the nondirectory part of the buffer file name, but the buffer file name and the buffer name are distinct and can be set independently. *Note Visiting Files::. - Function: buffer-file-name &optional BUFFER This function returns the absolute file name of the file that BUFFER is visiting. If BUFFER is not visiting any file, `buffer-file-name' returns `nil'. If BUFFER is not supplied, it defaults to the current buffer. (buffer-file-name (other-buffer)) => "/usr/user/lewis/manual/files.texi" - Variable: buffer-file-name This buffer-local variable contains the name of the file being visited in the current buffer, or `nil' if it is not visiting a file. It is a permanent local, unaffected by `kill-local-variables'. buffer-file-name => "/usr/user/lewis/manual/buffers.texi" It is risky to change this variable's value without doing various other things. See the definition of `set-visited-file-name' in `files.el'; some of the things done there, such as changing the buffer name, are not strictly necessary, but others are essential to avoid confusing XEmacs. - Variable: buffer-file-truename This buffer-local variable holds the truename of the file visited in the current buffer, or `nil' if no file is visited. It is a permanent local, unaffected by `kill-local-variables'. *Note Truenames::. - Variable: buffer-file-number This buffer-local variable holds the file number and directory device number of the file visited in the current buffer, or `nil' if no file or a nonexistent file is visited. It is a permanent local, unaffected by `kill-local-variables'. *Note Truenames::. The value is normally a list of the form `(FILENUM DEVNUM)'. This pair of numbers uniquely identifies the file among all files accessible on the system. See the function `file-attributes', in *Note File Attributes::, for more information about them. - Function: get-file-buffer FILENAME This function returns the buffer visiting file FILENAME. If there is no such buffer, it returns `nil'. The argument FILENAME, which must be a string, is expanded (*note File Name Expansion::.), then compared against the visited file names of all live buffers. (get-file-buffer "buffers.texi") => # In unusual circumstances, there can be more than one buffer visiting the same file name. In such cases, this function returns the first such buffer in the buffer list. - Command: set-visited-file-name FILENAME If FILENAME is a non-empty string, this function changes the name of the file visited in current buffer to FILENAME. (If the buffer had no visited file, this gives it one.) The *next time* the buffer is saved it will go in the newly-specified file. This command marks the buffer as modified, since it does not (as far as XEmacs knows) match the contents of FILENAME, even if it matched the former visited file. If FILENAME is `nil' or the empty string, that stands for "no visited file". In this case, `set-visited-file-name' marks the buffer as having no visited file. When the function `set-visited-file-name' is called interactively, it prompts for FILENAME in the minibuffer. See also `clear-visited-file-modtime' and `verify-visited-file-modtime' in *Note Buffer Modification::. - Variable: list-buffers-directory This buffer-local variable records a string to display in a buffer listing in place of the visited file name, for buffers that don't have a visited file name. Dired buffers use this variable.