2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2001,
4 @c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 @c Free Software Foundation, Inc.
6 @c See the file elisp.texi for copying conditions.
7 @setfilename ../../info/files
8 @node Files, Backups and Auto-Saving, Documentation, Top
9 @comment node-name, next, previous, up
12 In Emacs, you can find, create, view, save, and otherwise work with
13 files and file directories. This chapter describes most of the
14 file-related functions of Emacs Lisp, but a few others are described in
15 @ref{Buffers}, and those related to backups and auto-saving are
16 described in @ref{Backups and Auto-Saving}.
18 Many of the file functions take one or more arguments that are file
19 names. A file name is actually a string. Most of these functions
20 expand file name arguments by calling @code{expand-file-name}, so that
21 @file{~} is handled correctly, as are relative file names (including
22 @samp{../}). These functions don't recognize environment variable
23 substitutions such as @samp{$HOME}. @xref{File Name Expansion}.
25 When file I/O functions signal Lisp errors, they usually use the
26 condition @code{file-error} (@pxref{Handling Errors}). The error
27 message is in most cases obtained from the operating system, according
28 to locale @code{system-message-locale}, and decoded using coding system
29 @code{locale-coding-system} (@pxref{Locales}).
32 * Visiting Files:: Reading files into Emacs buffers for editing.
33 * Saving Buffers:: Writing changed buffers back into files.
34 * Reading from Files:: Reading files into buffers without visiting.
35 * Writing to Files:: Writing new files from parts of buffers.
36 * File Locks:: Locking and unlocking files, to prevent
37 simultaneous editing by two people.
38 * Information about Files:: Testing existence, accessibility, size of files.
39 * Changing Files:: Renaming files, changing protection, etc.
40 * File Names:: Decomposing and expanding file names.
41 * Contents of Directories:: Getting a list of the files in a directory.
42 * Create/Delete Dirs:: Creating and Deleting Directories.
43 * Magic File Names:: Defining "magic" special handling
44 for certain file names.
45 * Format Conversion:: Conversion to and from various file formats.
49 @section Visiting Files
51 @cindex visiting files
53 Visiting a file means reading a file into a buffer. Once this is
54 done, we say that the buffer is @dfn{visiting} that file, and call the
55 file ``the visited file'' of the buffer.
57 A file and a buffer are two different things. A file is information
58 recorded permanently in the computer (unless you delete it). A buffer,
59 on the other hand, is information inside of Emacs that will vanish at
60 the end of the editing session (or when you kill the buffer). Usually,
61 a buffer contains information that you have copied from a file; then we
62 say the buffer is visiting that file. The copy in the buffer is what
63 you modify with editing commands. Such changes to the buffer do not
64 change the file; therefore, to make the changes permanent, you must
65 @dfn{save} the buffer, which means copying the altered buffer contents
68 In spite of the distinction between files and buffers, people often
69 refer to a file when they mean a buffer and vice-versa. Indeed, we say,
70 ``I am editing a file,'' rather than, ``I am editing a buffer that I
71 will soon save as a file of the same name.'' Humans do not usually need
72 to make the distinction explicit. When dealing with a computer program,
73 however, it is good to keep the distinction in mind.
76 * Visiting Functions:: The usual interface functions for visiting.
77 * Subroutines of Visiting:: Lower-level subroutines that they use.
80 @node Visiting Functions
81 @subsection Functions for Visiting Files
83 This section describes the functions normally used to visit files.
84 For historical reasons, these functions have names starting with
85 @samp{find-} rather than @samp{visit-}. @xref{Buffer File Name}, for
86 functions and variables that access the visited file name of a buffer or
87 that find an existing buffer by its visited file name.
89 In a Lisp program, if you want to look at the contents of a file but
90 not alter it, the fastest way is to use @code{insert-file-contents} in a
91 temporary buffer. Visiting the file is not necessary and takes longer.
92 @xref{Reading from Files}.
94 @deffn Command find-file filename &optional wildcards
95 This command selects a buffer visiting the file @var{filename},
96 using an existing buffer if there is one, and otherwise creating a
97 new buffer and reading the file into it. It also returns that buffer.
99 Aside from some technical details, the body of the @code{find-file}
100 function is basically equivalent to:
103 (switch-to-buffer (find-file-noselect filename nil nil wildcards))
107 (See @code{switch-to-buffer} in @ref{Displaying Buffers}.)
109 If @var{wildcards} is non-@code{nil}, which is always true in an
110 interactive call, then @code{find-file} expands wildcard characters in
111 @var{filename} and visits all the matching files.
113 When @code{find-file} is called interactively, it prompts for
114 @var{filename} in the minibuffer.
117 @deffn Command find-file-literally filename
118 This command visits @var{filename}, like @code{find-file} does, but it
119 does not perform any format conversions (@pxref{Format Conversion}),
120 character code conversions (@pxref{Coding Systems}), or end-of-line
121 conversions (@pxref{Coding System Basics, End of line conversion}).
122 The buffer visiting the file is made unibyte, and its major mode is
123 Fundamental mode, regardless of the file name. File local variable
124 specifications in the file (@pxref{File Local Variables}) are
125 ignored, and automatic decompression and adding a newline at the end
126 of the file due to @code{require-final-newline} (@pxref{Saving
127 Buffers, require-final-newline}) are also disabled.
129 Note that if Emacs already has a buffer visiting the same file
130 non-literally, it will not visit the same file literally, but instead
131 just switch to the existing buffer. If you want to be sure of
132 accessing a file's contents literally, you should create a temporary
133 buffer and then read the file contents into it using
134 @code{insert-file-contents-literally} (@pxref{Reading from Files}).
137 @defun find-file-noselect filename &optional nowarn rawfile wildcards
138 This function is the guts of all the file-visiting functions. It
139 returns a buffer visiting the file @var{filename}. You may make the
140 buffer current or display it in a window if you wish, but this
141 function does not do so.
143 The function returns an existing buffer if there is one; otherwise it
144 creates a new buffer and reads the file into it. When
145 @code{find-file-noselect} uses an existing buffer, it first verifies
146 that the file has not changed since it was last visited or saved in
147 that buffer. If the file has changed, this function asks the user
148 whether to reread the changed file. If the user says @samp{yes}, any
149 edits previously made in the buffer are lost.
151 Reading the file involves decoding the file's contents (@pxref{Coding
152 Systems}), including end-of-line conversion, and format conversion
153 (@pxref{Format Conversion}). If @var{wildcards} is non-@code{nil},
154 then @code{find-file-noselect} expands wildcard characters in
155 @var{filename} and visits all the matching files.
157 This function displays warning or advisory messages in various peculiar
158 cases, unless the optional argument @var{nowarn} is non-@code{nil}. For
159 example, if it needs to create a buffer, and there is no file named
160 @var{filename}, it displays the message @samp{(New file)} in the echo
161 area, and leaves the buffer empty.
163 The @code{find-file-noselect} function normally calls
164 @code{after-find-file} after reading the file (@pxref{Subroutines of
165 Visiting}). That function sets the buffer major mode, parses local
166 variables, warns the user if there exists an auto-save file more recent
167 than the file just visited, and finishes by running the functions in
168 @code{find-file-hook}.
170 If the optional argument @var{rawfile} is non-@code{nil}, then
171 @code{after-find-file} is not called, and the
172 @code{find-file-not-found-functions} are not run in case of failure.
173 What's more, a non-@code{nil} @var{rawfile} value suppresses coding
174 system conversion and format conversion.
176 The @code{find-file-noselect} function usually returns the buffer that
177 is visiting the file @var{filename}. But, if wildcards are actually
178 used and expanded, it returns a list of buffers that are visiting the
183 (find-file-noselect "/etc/fstab")
184 @result{} #<buffer fstab>
189 @deffn Command find-file-other-window filename &optional wildcards
190 This command selects a buffer visiting the file @var{filename}, but
191 does so in a window other than the selected window. It may use another
192 existing window or split a window; see @ref{Displaying Buffers}.
194 When this command is called interactively, it prompts for
198 @deffn Command find-file-read-only filename &optional wildcards
199 This command selects a buffer visiting the file @var{filename}, like
200 @code{find-file}, but it marks the buffer as read-only. @xref{Read Only
201 Buffers}, for related functions and variables.
203 When this command is called interactively, it prompts for
207 @deffn Command view-file filename
208 This command visits @var{filename} using View mode, returning to the
209 previous buffer when you exit View mode. View mode is a minor mode that
210 provides commands to skim rapidly through the file, but does not let you
211 modify the text. Entering View mode runs the normal hook
212 @code{view-mode-hook}. @xref{Hooks}.
214 When @code{view-file} is called interactively, it prompts for
218 @defopt find-file-wildcards
219 If this variable is non-@code{nil}, then the various @code{find-file}
220 commands check for wildcard characters and visit all the files that
221 match them (when invoked interactively or when their @var{wildcards}
222 argument is non-@code{nil}). If this option is @code{nil}, then
223 the @code{find-file} commands ignore their @var{wildcards} argument
224 and never treat wildcard characters specially.
227 @defopt find-file-hook
228 The value of this variable is a list of functions to be called after a
229 file is visited. The file's local-variables specification (if any) will
230 have been processed before the hooks are run. The buffer visiting the
231 file is current when the hook functions are run.
233 This variable is a normal hook. @xref{Hooks}.
236 @defvar find-file-not-found-functions
237 The value of this variable is a list of functions to be called when
238 @code{find-file} or @code{find-file-noselect} is passed a nonexistent
239 file name. @code{find-file-noselect} calls these functions as soon as
240 it detects a nonexistent file. It calls them in the order of the list,
241 until one of them returns non-@code{nil}. @code{buffer-file-name} is
244 This is not a normal hook because the values of the functions are
245 used, and in many cases only some of the functions are called.
248 @defvar find-file-literally
249 This buffer-local variable, if set to a non-@code{nil} value, makes
250 @code{save-buffer} behave as if the buffer were visiting its file
251 literally, i.e. without conversions of any kind. The command
252 @code{find-file-literally} sets this variable's local value, but other
253 equivalent functions and commands can do that as well, e.g.@: to avoid
254 automatic addition of a newline at the end of the file. This variable
255 us permanent local, so it is unaffected by changes of major modes.
258 @node Subroutines of Visiting
259 @comment node-name, next, previous, up
260 @subsection Subroutines of Visiting
262 The @code{find-file-noselect} function uses two important subroutines
263 which are sometimes useful in user Lisp code: @code{create-file-buffer}
264 and @code{after-find-file}. This section explains how to use them.
266 @defun create-file-buffer filename
267 This function creates a suitably named buffer for visiting
268 @var{filename}, and returns it. It uses @var{filename} (sans directory)
269 as the name if that name is free; otherwise, it appends a string such as
270 @samp{<2>} to get an unused name. See also @ref{Creating Buffers}.
272 @strong{Please note:} @code{create-file-buffer} does @emph{not}
273 associate the new buffer with a file and does not select the buffer.
274 It also does not use the default major mode.
278 (create-file-buffer "foo")
279 @result{} #<buffer foo>
282 (create-file-buffer "foo")
283 @result{} #<buffer foo<2>>
286 (create-file-buffer "foo")
287 @result{} #<buffer foo<3>>
291 This function is used by @code{find-file-noselect}.
292 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
295 @defun after-find-file &optional error warn noauto after-find-file-from-revert-buffer nomodes
296 This function sets the buffer major mode, and parses local variables
297 (@pxref{Auto Major Mode}). It is called by @code{find-file-noselect}
298 and by the default revert function (@pxref{Reverting}).
300 @cindex new file message
301 @cindex file open error
302 If reading the file got an error because the file does not exist, but
303 its directory does exist, the caller should pass a non-@code{nil} value
304 for @var{error}. In that case, @code{after-find-file} issues a warning:
305 @samp{(New file)}. For more serious errors, the caller should usually not
306 call @code{after-find-file}.
308 If @var{warn} is non-@code{nil}, then this function issues a warning
309 if an auto-save file exists and is more recent than the visited file.
311 If @var{noauto} is non-@code{nil}, that says not to enable or disable
312 Auto-Save mode. The mode remains enabled if it was enabled before.
314 If @var{after-find-file-from-revert-buffer} is non-@code{nil}, that
315 means this call was from @code{revert-buffer}. This has no direct
316 effect, but some mode functions and hook functions check the value
319 If @var{nomodes} is non-@code{nil}, that means don't alter the buffer's
320 major mode, don't process local variables specifications in the file,
321 and don't run @code{find-file-hook}. This feature is used by
322 @code{revert-buffer} in some cases.
324 The last thing @code{after-find-file} does is call all the functions
325 in the list @code{find-file-hook}.
329 @section Saving Buffers
330 @cindex saving buffers
332 When you edit a file in Emacs, you are actually working on a buffer
333 that is visiting that file---that is, the contents of the file are
334 copied into the buffer and the copy is what you edit. Changes to the
335 buffer do not change the file until you @dfn{save} the buffer, which
336 means copying the contents of the buffer into the file.
338 @deffn Command save-buffer &optional backup-option
339 This function saves the contents of the current buffer in its visited
340 file if the buffer has been modified since it was last visited or saved.
341 Otherwise it does nothing.
343 @code{save-buffer} is responsible for making backup files. Normally,
344 @var{backup-option} is @code{nil}, and @code{save-buffer} makes a backup
345 file only if this is the first save since visiting the file. Other
346 values for @var{backup-option} request the making of backup files in
351 With an argument of 4 or 64, reflecting 1 or 3 @kbd{C-u}'s, the
352 @code{save-buffer} function marks this version of the file to be
353 backed up when the buffer is next saved.
356 With an argument of 16 or 64, reflecting 2 or 3 @kbd{C-u}'s, the
357 @code{save-buffer} function unconditionally backs up the previous
358 version of the file before saving it.
361 With an argument of 0, unconditionally do @emph{not} make any backup file.
365 @deffn Command save-some-buffers &optional save-silently-p pred
366 @anchor{Definition of save-some-buffers}
367 This command saves some modified file-visiting buffers. Normally it
368 asks the user about each buffer. But if @var{save-silently-p} is
369 non-@code{nil}, it saves all the file-visiting buffers without querying
372 The optional @var{pred} argument controls which buffers to ask about
373 (or to save silently if @var{save-silently-p} is non-@code{nil}).
374 If it is @code{nil}, that means to ask only about file-visiting buffers.
375 If it is @code{t}, that means also offer to save certain other non-file
376 buffers---those that have a non-@code{nil} buffer-local value of
377 @code{buffer-offer-save} (@pxref{Killing Buffers}). A user who says
378 @samp{yes} to saving a non-file buffer is asked to specify the file
379 name to use. The @code{save-buffers-kill-emacs} function passes the
380 value @code{t} for @var{pred}.
382 If @var{pred} is neither @code{t} nor @code{nil}, then it should be
383 a function of no arguments. It will be called in each buffer to decide
384 whether to offer to save that buffer. If it returns a non-@code{nil}
385 value in a certain buffer, that means do offer to save that buffer.
388 @deffn Command write-file filename &optional confirm
389 @anchor{Definition of write-file}
390 This function writes the current buffer into file @var{filename}, makes
391 the buffer visit that file, and marks it not modified. Then it renames
392 the buffer based on @var{filename}, appending a string like @samp{<2>}
393 if necessary to make a unique buffer name. It does most of this work by
394 calling @code{set-visited-file-name} (@pxref{Buffer File Name}) and
397 If @var{confirm} is non-@code{nil}, that means to ask for confirmation
398 before overwriting an existing file. Interactively, confirmation is
399 required, unless the user supplies a prefix argument.
401 If @var{filename} is an existing directory, or a symbolic link to one,
402 @code{write-file} uses the name of the visited file, in directory
403 @var{filename}. If the buffer is not visiting a file, it uses the
407 Saving a buffer runs several hooks. It also performs format
408 conversion (@pxref{Format Conversion}).
410 @defvar write-file-functions
411 The value of this variable is a list of functions to be called before
412 writing out a buffer to its visited file. If one of them returns
413 non-@code{nil}, the file is considered already written and the rest of
414 the functions are not called, nor is the usual code for writing the file
417 If a function in @code{write-file-functions} returns non-@code{nil}, it
418 is responsible for making a backup file (if that is appropriate).
419 To do so, execute the following code:
422 (or buffer-backed-up (backup-buffer))
425 You might wish to save the file modes value returned by
426 @code{backup-buffer} and use that (if non-@code{nil}) to set the mode
427 bits of the file that you write. This is what @code{save-buffer}
428 normally does. @xref{Making Backups,, Making Backup Files}.
430 The hook functions in @code{write-file-functions} are also responsible
431 for encoding the data (if desired): they must choose a suitable coding
432 system and end-of-line conversion (@pxref{Lisp and Coding Systems}),
433 perform the encoding (@pxref{Explicit Encoding}), and set
434 @code{last-coding-system-used} to the coding system that was used
435 (@pxref{Encoding and I/O}).
437 If you set this hook locally in a buffer, it is assumed to be
438 associated with the file or the way the contents of the buffer were
439 obtained. Thus the variable is marked as a permanent local, so that
440 changing the major mode does not alter a buffer-local value. On the
441 other hand, calling @code{set-visited-file-name} will reset it.
442 If this is not what you want, you might like to use
443 @code{write-contents-functions} instead.
445 Even though this is not a normal hook, you can use @code{add-hook} and
446 @code{remove-hook} to manipulate the list. @xref{Hooks}.
450 @defvar write-contents-functions
451 This works just like @code{write-file-functions}, but it is intended
452 for hooks that pertain to the buffer's contents, not to the particular
453 visited file or its location. Such hooks are usually set up by major
454 modes, as buffer-local bindings for this variable. This variable
455 automatically becomes buffer-local whenever it is set; switching to a
456 new major mode always resets this variable, but calling
457 @code{set-visited-file-name} does not.
459 If any of the functions in this hook returns non-@code{nil}, the file
460 is considered already written and the rest are not called and neither
461 are the functions in @code{write-file-functions}.
464 @defopt before-save-hook
465 This normal hook runs before a buffer is saved in its visited file,
466 regardless of whether that is done normally or by one of the hooks
467 described above. For instance, the @file{copyright.el} program uses
468 this hook to make sure the file you are saving has the current year in
469 its copyright notice.
473 @defopt after-save-hook
474 This normal hook runs after a buffer has been saved in its visited file.
475 One use of this hook is in Fast Lock mode; it uses this hook to save the
476 highlighting information in a cache file.
479 @defopt file-precious-flag
480 If this variable is non-@code{nil}, then @code{save-buffer} protects
481 against I/O errors while saving by writing the new file to a temporary
482 name instead of the name it is supposed to have, and then renaming it to
483 the intended name after it is clear there are no errors. This procedure
484 prevents problems such as a lack of disk space from resulting in an
487 As a side effect, backups are necessarily made by copying. @xref{Rename
488 or Copy}. Yet, at the same time, saving a precious file always breaks
489 all hard links between the file you save and other file names.
491 Some modes give this variable a non-@code{nil} buffer-local value
492 in particular buffers.
495 @defopt require-final-newline
496 This variable determines whether files may be written out that do
497 @emph{not} end with a newline. If the value of the variable is
498 @code{t}, then @code{save-buffer} silently adds a newline at the end of
499 the file whenever the buffer being saved does not already end in one.
500 If the value of the variable is non-@code{nil}, but not @code{t}, then
501 @code{save-buffer} asks the user whether to add a newline each time the
504 If the value of the variable is @code{nil}, then @code{save-buffer}
505 doesn't add newlines at all. @code{nil} is the default value, but a few
506 major modes set it to @code{t} in particular buffers.
509 See also the function @code{set-visited-file-name} (@pxref{Buffer File
512 @node Reading from Files
513 @comment node-name, next, previous, up
514 @section Reading from Files
515 @cindex reading from files
517 You can copy a file from the disk and insert it into a buffer
518 using the @code{insert-file-contents} function. Don't use the user-level
519 command @code{insert-file} in a Lisp program, as that sets the mark.
521 @defun insert-file-contents filename &optional visit beg end replace
522 This function inserts the contents of file @var{filename} into the
523 current buffer after point. It returns a list of the absolute file name
524 and the length of the data inserted. An error is signaled if
525 @var{filename} is not the name of a file that can be read.
527 The function @code{insert-file-contents} checks the file contents
528 against the defined file formats, and converts the file contents if
529 appropriate and also calls the functions in
530 the list @code{after-insert-file-functions}. @xref{Format Conversion}.
531 Normally, one of the functions in the
532 @code{after-insert-file-functions} list determines the coding system
533 (@pxref{Coding Systems}) used for decoding the file's contents,
534 including end-of-line conversion. However, if the file contains null
535 bytes, it is by default visited without any code conversions; see
536 @ref{Lisp and Coding Systems, inhibit-null-byte-detection}, for how to
537 control this behavior.
539 If @var{visit} is non-@code{nil}, this function additionally marks the
540 buffer as unmodified and sets up various fields in the buffer so that it
541 is visiting the file @var{filename}: these include the buffer's visited
542 file name and its last save file modtime. This feature is used by
543 @code{find-file-noselect} and you probably should not use it yourself.
545 If @var{beg} and @var{end} are non-@code{nil}, they should be integers
546 specifying the portion of the file to insert. In this case, @var{visit}
547 must be @code{nil}. For example,
550 (insert-file-contents filename nil 0 500)
554 inserts the first 500 characters of a file.
556 If the argument @var{replace} is non-@code{nil}, it means to replace the
557 contents of the buffer (actually, just the accessible portion) with the
558 contents of the file. This is better than simply deleting the buffer
559 contents and inserting the whole file, because (1) it preserves some
560 marker positions and (2) it puts less data in the undo list.
562 It is possible to read a special file (such as a FIFO or an I/O device)
563 with @code{insert-file-contents}, as long as @var{replace} and
564 @var{visit} are @code{nil}.
567 @defun insert-file-contents-literally filename &optional visit beg end replace
568 This function works like @code{insert-file-contents} except that it does
569 not do format decoding (@pxref{Format Conversion}), does not do
570 character code conversion (@pxref{Coding Systems}), does not run
571 @code{find-file-hook}, does not perform automatic uncompression, and so
575 If you want to pass a file name to another process so that another
576 program can read the file, use the function @code{file-local-copy}; see
577 @ref{Magic File Names}.
579 @node Writing to Files
580 @comment node-name, next, previous, up
581 @section Writing to Files
582 @cindex writing to files
584 You can write the contents of a buffer, or part of a buffer, directly
585 to a file on disk using the @code{append-to-file} and
586 @code{write-region} functions. Don't use these functions to write to
587 files that are being visited; that could cause confusion in the
588 mechanisms for visiting.
590 @deffn Command append-to-file start end filename
591 This function appends the contents of the region delimited by
592 @var{start} and @var{end} in the current buffer to the end of file
593 @var{filename}. If that file does not exist, it is created. This
594 function returns @code{nil}.
596 An error is signaled if @var{filename} specifies a nonwritable file,
597 or a nonexistent file in a directory where files cannot be created.
599 When called from Lisp, this function is completely equivalent to:
602 (write-region start end filename t)
606 @deffn Command write-region start end filename &optional append visit lockname mustbenew
607 This function writes the region delimited by @var{start} and @var{end}
608 in the current buffer into the file specified by @var{filename}.
610 If @var{start} is @code{nil}, then the command writes the entire buffer
611 contents (@emph{not} just the accessible portion) to the file and
615 If @var{start} is a string, then @code{write-region} writes or appends
616 that string, rather than text from the buffer. @var{end} is ignored in
619 If @var{append} is non-@code{nil}, then the specified text is appended
620 to the existing file contents (if any). If @var{append} is an
621 integer, @code{write-region} seeks to that byte offset from the start
622 of the file and writes the data from there.
624 If @var{mustbenew} is non-@code{nil}, then @code{write-region} asks
625 for confirmation if @var{filename} names an existing file. If
626 @var{mustbenew} is the symbol @code{excl}, then @code{write-region}
627 does not ask for confirmation, but instead it signals an error
628 @code{file-already-exists} if the file already exists.
630 The test for an existing file, when @var{mustbenew} is @code{excl}, uses
631 a special system feature. At least for files on a local disk, there is
632 no chance that some other program could create a file of the same name
633 before Emacs does, without Emacs's noticing.
635 If @var{visit} is @code{t}, then Emacs establishes an association
636 between the buffer and the file: the buffer is then visiting that file.
637 It also sets the last file modification time for the current buffer to
638 @var{filename}'s modtime, and marks the buffer as not modified. This
639 feature is used by @code{save-buffer}, but you probably should not use
643 If @var{visit} is a string, it specifies the file name to visit. This
644 way, you can write the data to one file (@var{filename}) while recording
645 the buffer as visiting another file (@var{visit}). The argument
646 @var{visit} is used in the echo area message and also for file locking;
647 @var{visit} is stored in @code{buffer-file-name}. This feature is used
648 to implement @code{file-precious-flag}; don't use it yourself unless you
649 really know what you're doing.
651 The optional argument @var{lockname}, if non-@code{nil}, specifies the
652 file name to use for purposes of locking and unlocking, overriding
653 @var{filename} and @var{visit} for that purpose.
655 The function @code{write-region} converts the data which it writes to
656 the appropriate file formats specified by @code{buffer-file-format}
657 and also calls the functions in the list
658 @code{write-region-annotate-functions}.
659 @xref{Format Conversion}.
661 Normally, @code{write-region} displays the message @samp{Wrote
662 @var{filename}} in the echo area. If @var{visit} is neither @code{t}
663 nor @code{nil} nor a string, then this message is inhibited. This
664 feature is useful for programs that use files for internal purposes,
665 files that the user does not need to know about.
668 @defmac with-temp-file file body@dots{}
669 @anchor{Definition of with-temp-file}
670 The @code{with-temp-file} macro evaluates the @var{body} forms with a
671 temporary buffer as the current buffer; then, at the end, it writes the
672 buffer contents into file @var{file}. It kills the temporary buffer
673 when finished, restoring the buffer that was current before the
674 @code{with-temp-file} form. Then it returns the value of the last form
677 The current buffer is restored even in case of an abnormal exit via
678 @code{throw} or error (@pxref{Nonlocal Exits}).
680 See also @code{with-temp-buffer} in @ref{Definition of
681 with-temp-buffer,, The Current Buffer}.
689 When two users edit the same file at the same time, they are likely
690 to interfere with each other. Emacs tries to prevent this situation
691 from arising by recording a @dfn{file lock} when a file is being
692 modified. (File locks are not implemented on Microsoft systems.)
693 Emacs can then detect the first attempt to modify a buffer visiting a
694 file that is locked by another Emacs job, and ask the user what to do.
695 The file lock is really a file, a symbolic link with a special name,
696 stored in the same directory as the file you are editing.
698 When you access files using NFS, there may be a small probability that
699 you and another user will both lock the same file ``simultaneously.''
700 If this happens, it is possible for the two users to make changes
701 simultaneously, but Emacs will still warn the user who saves second.
702 Also, the detection of modification of a buffer visiting a file changed
703 on disk catches some cases of simultaneous editing; see
704 @ref{Modification Time}.
706 @defun file-locked-p filename
707 This function returns @code{nil} if the file @var{filename} is not
708 locked. It returns @code{t} if it is locked by this Emacs process, and
709 it returns the name of the user who has locked it if it is locked by
714 (file-locked-p "foo")
720 @defun lock-buffer &optional filename
721 This function locks the file @var{filename}, if the current buffer is
722 modified. The argument @var{filename} defaults to the current buffer's
723 visited file. Nothing is done if the current buffer is not visiting a
724 file, or is not modified, or if the system does not support locking.
728 This function unlocks the file being visited in the current buffer,
729 if the buffer is modified. If the buffer is not modified, then
730 the file should not be locked, so this function does nothing. It also
731 does nothing if the current buffer is not visiting a file, or if the
732 system does not support locking.
735 File locking is not supported on some systems. On systems that do not
736 support it, the functions @code{lock-buffer}, @code{unlock-buffer} and
737 @code{file-locked-p} do nothing and return @code{nil}.
739 @defun ask-user-about-lock file other-user
740 This function is called when the user tries to modify @var{file}, but it
741 is locked by another user named @var{other-user}. The default
742 definition of this function asks the user to say what to do. The value
743 this function returns determines what Emacs does next:
747 A value of @code{t} says to grab the lock on the file. Then
748 this user may edit the file and @var{other-user} loses the lock.
751 A value of @code{nil} says to ignore the lock and let this
752 user edit the file anyway.
756 This function may instead signal a @code{file-locked} error, in which
757 case the change that the user was about to make does not take place.
759 The error message for this error looks like this:
762 @error{} File is locked: @var{file} @var{other-user}
766 where @code{file} is the name of the file and @var{other-user} is the
767 name of the user who has locked the file.
770 If you wish, you can replace the @code{ask-user-about-lock} function
771 with your own version that makes the decision in another way. The code
772 for its usual definition is in @file{userlock.el}.
775 @node Information about Files
776 @section Information about Files
777 @cindex file, information about
779 The functions described in this section all operate on strings that
780 designate file names. With a few exceptions, all the functions have
781 names that begin with the word @samp{file}. These functions all
782 return information about actual files or directories, so their
783 arguments must all exist as actual files or directories unless
787 * Testing Accessibility:: Is a given file readable? Writable?
788 * Kinds of Files:: Is it a directory? A symbolic link?
789 * Truenames:: Eliminating symbolic links from a file name.
790 * File Attributes:: How large is it? Any other names? Etc.
791 * Locating Files:: How to find a file in standard places.
794 @node Testing Accessibility
795 @comment node-name, next, previous, up
796 @subsection Testing Accessibility
797 @cindex accessibility of a file
798 @cindex file accessibility
800 These functions test for permission to access a file in specific
801 ways. Unless explicitly stated otherwise, they recursively follow
802 symbolic links for their file name arguments, at all levels (at the
803 level of the file itself and at all levels of parent directories).
805 @defun file-exists-p filename
806 This function returns @code{t} if a file named @var{filename} appears
807 to exist. This does not mean you can necessarily read the file, only
808 that you can find out its attributes. (On Unix and GNU/Linux, this is
809 true if the file exists and you have execute permission on the
810 containing directories, regardless of the protection of the file
813 If the file does not exist, or if fascist access control policies
814 prevent you from finding the attributes of the file, this function
817 Directories are files, so @code{file-exists-p} returns @code{t} when
818 given a directory name. However, symbolic links are treated
819 specially; @code{file-exists-p} returns @code{t} for a symbolic link
820 name only if the target file exists.
823 @defun file-readable-p filename
824 This function returns @code{t} if a file named @var{filename} exists
825 and you can read it. It returns @code{nil} otherwise.
829 (file-readable-p "files.texi")
833 (file-exists-p "/usr/spool/mqueue")
837 (file-readable-p "/usr/spool/mqueue")
844 @defun file-executable-p filename
845 This function returns @code{t} if a file named @var{filename} exists and
846 you can execute it. It returns @code{nil} otherwise. On Unix and
847 GNU/Linux, if the file is a directory, execute permission means you can
848 check the existence and attributes of files inside the directory, and
849 open those files if their modes permit.
852 @defun file-writable-p filename
853 This function returns @code{t} if the file @var{filename} can be written
854 or created by you, and @code{nil} otherwise. A file is writable if the
855 file exists and you can write it. It is creatable if it does not exist,
856 but the specified directory does exist and you can write in that
859 In the third example below, @file{foo} is not writable because the
860 parent directory does not exist, even though the user could create such
865 (file-writable-p "~/foo")
869 (file-writable-p "/foo")
873 (file-writable-p "~/no-such-dir/foo")
880 @defun file-accessible-directory-p dirname
881 This function returns @code{t} if you have permission to open existing
882 files in the directory whose name as a file is @var{dirname};
883 otherwise (or if there is no such directory), it returns @code{nil}.
884 The value of @var{dirname} may be either a directory name (such as
885 @file{/foo/}) or the file name of a file which is a directory
886 (such as @file{/foo}, without the final slash).
888 Example: after the following,
891 (file-accessible-directory-p "/foo")
896 we can deduce that any attempt to read a file in @file{/foo/} will
900 @defun access-file filename string
901 This function opens file @var{filename} for reading, then closes it and
902 returns @code{nil}. However, if the open fails, it signals an error
903 using @var{string} as the error message text.
906 @defun file-ownership-preserved-p filename
907 This function returns @code{t} if deleting the file @var{filename} and
908 then creating it anew would keep the file's owner unchanged. It also
909 returns @code{t} for nonexistent files.
911 If @var{filename} is a symbolic link, then, unlike the other functions
912 discussed here, @code{file-ownership-preserved-p} does @emph{not}
913 replace @var{filename} with its target. However, it does recursively
914 follow symbolic links at all levels of parent directories.
917 @defun file-newer-than-file-p filename1 filename2
919 @cindex file modification time
920 This function returns @code{t} if the file @var{filename1} is
921 newer than file @var{filename2}. If @var{filename1} does not
922 exist, it returns @code{nil}. If @var{filename1} does exist, but
923 @var{filename2} does not, it returns @code{t}.
925 In the following example, assume that the file @file{aug-19} was written
926 on the 19th, @file{aug-20} was written on the 20th, and the file
927 @file{no-file} doesn't exist at all.
931 (file-newer-than-file-p "aug-19" "aug-20")
935 (file-newer-than-file-p "aug-20" "aug-19")
939 (file-newer-than-file-p "aug-19" "no-file")
943 (file-newer-than-file-p "no-file" "aug-19")
948 You can use @code{file-attributes} to get a file's last modification
949 time as a list of two numbers. @xref{File Attributes}.
953 @comment node-name, next, previous, up
954 @subsection Distinguishing Kinds of Files
956 This section describes how to distinguish various kinds of files, such
957 as directories, symbolic links, and ordinary files.
959 @defun file-symlink-p filename
960 @cindex file symbolic links
961 If the file @var{filename} is a symbolic link, the
962 @code{file-symlink-p} function returns the (non-recursive) link target
963 as a string. (Determining the file name that the link points to from
964 the target is nontrivial.) First, this function recursively follows
965 symbolic links at all levels of parent directories.
967 If the file @var{filename} is not a symbolic link (or there is no such file),
968 @code{file-symlink-p} returns @code{nil}.
972 (file-symlink-p "foo")
976 (file-symlink-p "sym-link")
980 (file-symlink-p "sym-link2")
984 (file-symlink-p "/bin")
989 @c !!! file-symlink-p: should show output of ls -l for comparison
992 The next two functions recursively follow symbolic links at
993 all levels for @var{filename}.
995 @defun file-directory-p filename
996 This function returns @code{t} if @var{filename} is the name of an
997 existing directory, @code{nil} otherwise.
1001 (file-directory-p "~rms")
1005 (file-directory-p "~rms/lewis/files.texi")
1009 (file-directory-p "~rms/lewis/no-such-file")
1013 (file-directory-p "$HOME")
1018 (substitute-in-file-name "$HOME"))
1024 @defun file-regular-p filename
1025 This function returns @code{t} if the file @var{filename} exists and is
1026 a regular file (not a directory, named pipe, terminal, or
1031 @subsection Truenames
1032 @cindex truename (of file)
1034 @c Emacs 19 features
1035 The @dfn{truename} of a file is the name that you get by following
1036 symbolic links at all levels until none remain, then simplifying away
1037 @samp{.}@: and @samp{..}@: appearing as name components. This results
1038 in a sort of canonical name for the file. A file does not always have a
1039 unique truename; the number of distinct truenames a file has is equal to
1040 the number of hard links to the file. However, truenames are useful
1041 because they eliminate symbolic links as a cause of name variation.
1043 @defun file-truename filename
1044 The function @code{file-truename} returns the truename of the file
1045 @var{filename}. The argument must be an absolute file name.
1047 This function does not expand environment variables. Only
1048 @code{substitute-in-file-name} does that. @xref{Definition of
1049 substitute-in-file-name}.
1051 If you may need to follow symbolic links preceding @samp{..}@:
1052 appearing as a name component, you should make sure to call
1053 @code{file-truename} without prior direct or indirect calls to
1054 @code{expand-file-name}, as otherwise the file name component
1055 immediately preceding @samp{..} will be ``simplified away'' before
1056 @code{file-truename} is called. To eliminate the need for a call to
1057 @code{expand-file-name}, @code{file-truename} handles @samp{~} in the
1058 same way that @code{expand-file-name} does. @xref{File Name
1059 Expansion,, Functions that Expand Filenames}.
1062 @defun file-chase-links filename &optional limit
1063 This function follows symbolic links, starting with @var{filename},
1064 until it finds a file name which is not the name of a symbolic link.
1065 Then it returns that file name. This function does @emph{not} follow
1066 symbolic links at the level of parent directories.
1068 If you specify a number for @var{limit}, then after chasing through
1069 that many links, the function just returns what it has even if that is
1070 still a symbolic link.
1073 To illustrate the difference between @code{file-chase-links} and
1074 @code{file-truename}, suppose that @file{/usr/foo} is a symbolic link to
1075 the directory @file{/home/foo}, and @file{/home/foo/hello} is an
1076 ordinary file (or at least, not a symbolic link) or nonexistent. Then
1080 (file-chase-links "/usr/foo/hello")
1081 ;; @r{This does not follow the links in the parent directories.}
1082 @result{} "/usr/foo/hello"
1083 (file-truename "/usr/foo/hello")
1084 ;; @r{Assuming that @file{/home} is not a symbolic link.}
1085 @result{} "/home/foo/hello"
1088 @xref{Buffer File Name}, for related information.
1090 @node File Attributes
1091 @comment node-name, next, previous, up
1092 @subsection Other Information about Files
1094 This section describes the functions for getting detailed information
1095 about a file, other than its contents. This information includes the
1096 mode bits that control access permission, the owner and group numbers,
1097 the number of names, the inode number, the size, and the times of access
1100 @defun file-modes filename
1102 @cindex file attributes
1103 This function returns the mode bits of @var{filename}, as an integer.
1104 The mode bits are also called the file permissions, and they specify
1105 access control in the usual Unix fashion. If the low-order bit is 1,
1106 then the file is executable by all users, if the second-lowest-order bit
1107 is 1, then the file is writable by all users, etc.
1109 The highest value returnable is 4095 (7777 octal), meaning that
1110 everyone has read, write, and execute permission, that the @acronym{SUID} bit
1111 is set for both others and group, and that the sticky bit is set.
1113 If @var{filename} does not exist, @code{file-modes} returns @code{nil}.
1115 This function recursively follows symbolic links at all levels.
1119 (file-modes "~/junk/diffs")
1120 @result{} 492 ; @r{Decimal integer.}
1124 @result{} "754" ; @r{Convert to octal.}
1128 (set-file-modes "~/junk/diffs" 438)
1134 @result{} "666" ; @r{Convert to octal.}
1139 -rw-rw-rw- 1 lewis 0 3063 Oct 30 16:00 diffs
1144 If the @var{filename} argument to the next two functions is a symbolic
1145 link, then these function do @emph{not} replace it with its target.
1146 However, they both recursively follow symbolic links at all levels of
1149 @defun file-nlinks filename
1150 This functions returns the number of names (i.e., hard links) that
1151 file @var{filename} has. If the file does not exist, then this function
1152 returns @code{nil}. Note that symbolic links have no effect on this
1153 function, because they are not considered to be names of the files they
1159 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo
1160 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo1
1168 (file-nlinks "doesnt-exist")
1174 @defun file-attributes filename &optional id-format
1175 @anchor{Definition of file-attributes}
1176 This function returns a list of attributes of file @var{filename}. If
1177 the specified file cannot be opened, it returns @code{nil}.
1178 The optional parameter @var{id-format} specifies the preferred format
1179 of attributes @acronym{UID} and @acronym{GID} (see below)---the
1180 valid values are @code{'string} and @code{'integer}. The latter is
1181 the default, but we plan to change that, so you should specify a
1182 non-@code{nil} value for @var{id-format} if you use the returned
1183 @acronym{UID} or @acronym{GID}.
1185 The elements of the list, in order, are:
1189 @code{t} for a directory, a string for a symbolic link (the name
1190 linked to), or @code{nil} for a text file.
1192 @c Wordy so as to prevent an overfull hbox. --rjc 15mar92
1194 The number of names the file has. Alternate names, also known as hard
1195 links, can be created by using the @code{add-name-to-file} function
1196 (@pxref{Changing Files}).
1199 The file's @acronym{UID}, normally as a string. However, if it does
1200 not correspond to a named user, the value is an integer or a floating
1204 The file's @acronym{GID}, likewise.
1207 The time of last access, as a list of two integers.
1208 The first integer has the high-order 16 bits of time,
1209 the second has the low 16 bits. (This is similar to the
1210 value of @code{current-time}; see @ref{Time of Day}.) Note that on
1211 some FAT-based filesystems, only the date of last access is recorded,
1212 so this time will always hold the midnight of the day of last access.
1214 @cindex modification time of file
1216 The time of last modification as a list of two integers (as above).
1217 This is the last time when the file's contents were modified.
1220 The time of last status change as a list of two integers (as above).
1221 This is the time of the last change to the file's access mode bits,
1222 its owner and group, and other information recorded in the filesystem
1223 for the file, beyond the file's contents.
1226 The size of the file in bytes. If the size is too large to fit in a
1227 Lisp integer, this is a floating point number.
1230 The file's modes, as a string of ten letters or dashes,
1234 @code{t} if the file's @acronym{GID} would change if file were
1235 deleted and recreated; @code{nil} otherwise.
1238 The file's inode number. If possible, this is an integer. If the
1239 inode number is too large to be represented as an integer in Emacs
1240 Lisp, but still fits into a 32-bit integer, then the value has the
1241 form @code{(@var{high} . @var{low})}, where @var{low} holds the low 16
1242 bits. If the inode is wider than 32 bits, the value is of the form
1243 @code{(@var{high} @var{middle} . @var{low})}, where @code{high} holds
1244 the high 24 bits, @var{middle} the next 24 bits, and @var{low} the low
1248 The filesystem number of the device that the file is on. Depending on
1249 the magnitude of the value, this can be either an integer or a cons
1250 cell, in the same manner as the inode number. This element and the
1251 file's inode number together give enough information to distinguish
1252 any two files on the system---no two files can have the same values
1253 for both of these numbers.
1256 For example, here are the file attributes for @file{files.texi}:
1260 (file-attributes "files.texi" 'string)
1261 @result{} (nil 1 "lh" "users"
1266 nil (5888 2 . 43978)
1272 and here is how the result is interpreted:
1276 is neither a directory nor a symbolic link.
1279 has only one name (the name @file{files.texi} in the current default
1283 is owned by the user with name "lh".
1286 is in the group with name "users".
1289 was last accessed on Oct 5 2009, at 10:01:37.
1292 last had its contents modified on Oct 2 2009, at 13:49:12.
1295 last had its status changed on Feb 2 2008, at 12:19:00.
1298 is 122295 bytes long. (It may not contain 122295 characters, though,
1299 if some of the bytes belong to multibyte sequences, and also if the
1300 end-of-line format is CR-LF.)
1303 has a mode of read and write access for the owner, group, and world.
1306 would retain the same @acronym{GID} if it were recreated.
1308 @item (5888 2 . 43978)
1309 has an inode number of 6473924464520138.
1311 @item (15479 . 46724)
1312 is on the file-system device whose number is 1014478468.
1316 @cindex MS-DOS and file modes
1317 @cindex file modes and MS-DOS
1318 On MS-DOS, there is no such thing as an ``executable'' file mode bit.
1319 So Emacs considers a file executable if its name ends in one of the
1320 standard executable extensions, such as @file{.com}, @file{.bat},
1321 @file{.exe}, and some others. Files that begin with the Unix-standard
1322 @samp{#!} signature, such as shell and Perl scripts, are also considered
1323 as executable files. This is reflected in the values returned by
1324 @code{file-modes} and @code{file-attributes}. Directories are also
1325 reported with executable bit set, for compatibility with Unix.
1327 @node Locating Files
1328 @subsection How to Locate Files in Standard Places
1329 @cindex locate file in path
1330 @cindex find file in path
1332 This section explains how to search for a file in a list of
1333 directories (a @dfn{path}). One example is when you need to look for
1334 a program's executable file, e.g., to find out whether a given program
1335 is installed on the user's system. Another example is the search for
1336 Lisp libraries (@pxref{Library Search}). Such searches generally need
1337 to try various possible file name extensions, in addition to various
1338 possible directories. Emacs provides a function for such a
1339 generalized search for a file.
1341 @defun locate-file filename path &optional suffixes predicate
1342 This function searches for a file whose name is @var{filename} in a
1343 list of directories given by @var{path}, trying the suffixes in
1344 @var{suffixes}. If it finds such a file, it returns the full
1345 @dfn{absolute file name} of the file (@pxref{Relative File Names});
1346 otherwise it returns @code{nil}.
1348 The optional argument @var{suffixes} gives the list of file-name
1349 suffixes to append to @var{filename} when searching.
1350 @code{locate-file} tries each possible directory with each of these
1351 suffixes. If @var{suffixes} is @code{nil}, or @code{("")}, then there
1352 are no suffixes, and @var{filename} is used only as-is. Typical
1353 values of @var{suffixes} are @code{exec-suffixes} (@pxref{Subprocess
1354 Creation, exec-suffixes}), @code{load-suffixes},
1355 @code{load-file-rep-suffixes} and the return value of the function
1356 @code{get-load-suffixes} (@pxref{Load Suffixes}).
1358 Typical values for @var{path} are @code{exec-path} (@pxref{Subprocess
1359 Creation, exec-path}) when looking for executable programs or
1360 @code{load-path} (@pxref{Library Search, load-path}) when looking for
1361 Lisp files. If @var{filename} is absolute, @var{path} has no effect,
1362 but the suffixes in @var{suffixes} are still tried.
1364 The optional argument @var{predicate}, if non-@code{nil}, specifies
1365 the predicate function to use for testing whether a candidate file is
1366 suitable. The predicate function is passed the candidate file name as
1367 its single argument. If @var{predicate} is @code{nil} or unspecified,
1368 @code{locate-file} uses @code{file-readable-p} as the default
1369 predicate. Useful non-default predicates include
1370 @code{file-executable-p}, @code{file-directory-p}, and other
1371 predicates described in @ref{Kinds of Files}.
1373 For compatibility, @var{predicate} can also be one of the symbols
1374 @code{executable}, @code{readable}, @code{writable}, @code{exists}, or
1375 a list of one or more of these symbols.
1378 @defun executable-find program
1379 This function searches for the executable file of the named
1380 @var{program} and returns the full absolute name of the executable,
1381 including its file-name extensions, if any. It returns @code{nil} if
1382 the file is not found. The functions searches in all the directories
1383 in @code{exec-path} and tries all the file-name extensions in
1384 @code{exec-suffixes}.
1387 @node Changing Files
1388 @section Changing File Names and Attributes
1389 @c @cindex renaming files Duplicates rename-file
1390 @cindex copying files
1391 @cindex deleting files
1392 @cindex linking files
1393 @cindex setting modes of files
1395 The functions in this section rename, copy, delete, link, and set the
1398 In the functions that have an argument @var{newname}, if a file by the
1399 name of @var{newname} already exists, the actions taken depend on the
1400 value of the argument @var{ok-if-already-exists}:
1404 Signal a @code{file-already-exists} error if
1405 @var{ok-if-already-exists} is @code{nil}.
1408 Request confirmation if @var{ok-if-already-exists} is a number.
1411 Replace the old file without confirmation if @var{ok-if-already-exists}
1415 The next four commands all recursively follow symbolic links at all
1416 levels of parent directories for their first argument, but, if that
1417 argument is itself a symbolic link, then only @code{copy-file}
1418 replaces it with its (recursive) target.
1420 @deffn Command add-name-to-file oldname newname &optional ok-if-already-exists
1421 @cindex file with multiple names
1422 @cindex file hard link
1423 This function gives the file named @var{oldname} the additional name
1424 @var{newname}. This means that @var{newname} becomes a new ``hard
1425 link'' to @var{oldname}.
1427 In the first part of the following example, we list two files,
1428 @file{foo} and @file{foo3}.
1433 81908 -rw-rw-rw- 1 rms 29 Aug 18 20:32 foo
1434 84302 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1438 Now we create a hard link, by calling @code{add-name-to-file}, then list
1439 the files again. This shows two names for one file, @file{foo} and
1444 (add-name-to-file "foo" "foo2")
1450 81908 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo
1451 81908 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo2
1452 84302 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1456 Finally, we evaluate the following:
1459 (add-name-to-file "foo" "foo3" t)
1463 and list the files again. Now there are three names
1464 for one file: @file{foo}, @file{foo2}, and @file{foo3}. The old
1465 contents of @file{foo3} are lost.
1469 (add-name-to-file "foo1" "foo3")
1475 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo
1476 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo2
1477 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo3
1481 This function is meaningless on operating systems where multiple names
1482 for one file are not allowed. Some systems implement multiple names
1483 by copying the file instead.
1485 See also @code{file-nlinks} in @ref{File Attributes}.
1488 @deffn Command rename-file filename newname &optional ok-if-already-exists
1489 This command renames the file @var{filename} as @var{newname}.
1491 If @var{filename} has additional names aside from @var{filename}, it
1492 continues to have those names. In fact, adding the name @var{newname}
1493 with @code{add-name-to-file} and then deleting @var{filename} has the
1494 same effect as renaming, aside from momentary intermediate states.
1497 @deffn Command copy-file oldname newname &optional ok-if-exists time preserve-uid-gid
1498 This command copies the file @var{oldname} to @var{newname}. An
1499 error is signaled if @var{oldname} does not exist. If @var{newname}
1500 names a directory, it copies @var{oldname} into that directory,
1501 preserving its final name component.
1503 If @var{time} is non-@code{nil}, then this function gives the new file
1504 the same last-modified time that the old one has. (This works on only
1505 some operating systems.) If setting the time gets an error,
1506 @code{copy-file} signals a @code{file-date-error} error. In an
1507 interactive call, a prefix argument specifies a non-@code{nil} value
1510 This function copies the file modes, too.
1512 If argument @var{preserve-uid-gid} is @code{nil}, we let the operating
1513 system decide the user and group ownership of the new file (this is
1514 usually set to the user running Emacs). If @var{preserve-uid-gid} is
1515 non-@code{nil}, we attempt to copy the user and group ownership of the
1516 file. This works only on some operating systems, and only if you have
1517 the correct permissions to do so.
1520 @deffn Command make-symbolic-link filename newname &optional ok-if-exists
1522 @kindex file-already-exists
1523 This command makes a symbolic link to @var{filename}, named
1524 @var{newname}. This is like the shell command @samp{ln -s
1525 @var{filename} @var{newname}}.
1527 This function is not available on systems that don't support symbolic
1531 @deffn Command delete-file filename
1533 This command deletes the file @var{filename}, like the shell command
1534 @samp{rm @var{filename}}. If the file has multiple names, it continues
1535 to exist under the other names.
1537 A suitable kind of @code{file-error} error is signaled if the file does
1538 not exist, or is not deletable. (On Unix and GNU/Linux, a file is
1539 deletable if its directory is writable.)
1541 If @var{filename} is a symbolic link, @code{delete-file} does not
1542 replace it with its target, but it does follow symbolic links at all
1543 levels of parent directories.
1545 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1548 @deffn Command set-file-modes filename mode
1549 This function sets mode bits of @var{filename} to @var{mode} (which
1550 must be an integer when the function is called non-interactively).
1551 Only the low 12 bits of @var{mode} are used.
1553 Interactively, @var{mode} is read from the minibuffer using
1554 @code{read-file-modes}, which accepts mode bits either as a number or
1555 as a character string representing the mode bits symbolically. See
1556 the description of @code{read-file-modes} below for the supported
1557 forms of symbolic notation for mode bits.
1559 This function recursively follows symbolic links at all levels for
1564 @defun set-default-file-modes mode
1566 This function sets the default file protection for new files created by
1567 Emacs and its subprocesses. Every file created with Emacs initially has
1568 this protection, or a subset of it (@code{write-region} will not give a
1569 file execute permission even if the default file protection allows
1570 execute permission). On Unix and GNU/Linux, the default protection is
1571 the bitwise complement of the ``umask'' value.
1573 The argument @var{mode} must be an integer. On most systems, only the
1574 low 9 bits of @var{mode} are meaningful. You can use the Lisp construct
1575 for octal character codes to enter @var{mode}; for example,
1578 (set-default-file-modes ?\644)
1581 Saving a modified version of an existing file does not count as creating
1582 the file; it preserves the existing file's mode, whatever that is. So
1583 the default file protection has no effect.
1586 @defun default-file-modes
1587 This function returns the current default protection value.
1590 @defun read-file-modes &optional prompt base-file
1591 This function reads file mode bits from the minibuffer. The optional
1592 argument @var{prompt} specifies a non-default prompt. Second optional
1593 argument @var{base-file} is the name of a file on whose permissions to
1594 base the mode bits that this function returns, if what the user types
1595 specifies mode bits relative to permissions of an existing file.
1597 If user input represents an octal number, this function returns that
1598 number. If it is a complete symbolic specification of mode bits, as
1599 in @code{"u=rwx"}, the function converts it to the equivalent numeric
1600 value using @code{file-modes-symbolic-to-number} and returns the
1601 result. If the specification is relative, as in @code{"o+g"}, then
1602 the permissions on which the specification is based are taken from the
1603 mode bits of @var{base-file}. If @var{base-file} is omitted or
1604 @code{nil}, the function uses @code{0} as the base mode bits. The
1605 complete and relative specifications can be combined, as in
1606 @code{"u+r,g+rx,o+r,g-w"}. @xref{File Permissions,,, coreutils, The
1607 @sc{gnu} @code{Coreutils} Manual}, for detailed description of
1608 symbolic mode bits specifications.
1611 @defun file-modes-symbolic-to-number modes &optional base-modes
1612 This subroutine converts a symbolic specification of file mode bits in
1613 @var{modes} into the equivalent numeric value. If the symbolic
1614 specification is based on an existing file, that file's mode bits are
1615 taken from the optional argument @var{base-modes}; if that argument is
1616 omitted or @code{nil}, it defaults to zero, i.e.@: no access rights at
1620 @defun set-file-times filename &optional time
1621 This function sets the access and modification times of @var{filename}
1622 to @var{time}. The return value is @code{t} if the times are successfully
1623 set, otherwise it is @code{nil}. @var{time} defaults to the current
1624 time and must be in the format returned by @code{current-time}
1625 (@pxref{Time of Day}).
1632 Files are generally referred to by their names, in Emacs as elsewhere.
1633 File names in Emacs are represented as strings. The functions that
1634 operate on a file all expect a file name argument.
1636 In addition to operating on files themselves, Emacs Lisp programs
1637 often need to operate on file names; i.e., to take them apart and to use
1638 part of a name to construct related file names. This section describes
1639 how to manipulate file names.
1641 The functions in this section do not actually access files, so they
1642 can operate on file names that do not refer to an existing file or
1645 On MS-DOS and MS-Windows, these functions (like the function that
1646 actually operate on files) accept MS-DOS or MS-Windows file-name syntax,
1647 where backslashes separate the components, as well as Unix syntax; but
1648 they always return Unix syntax. This enables Lisp programs to specify
1649 file names in Unix syntax and work properly on all systems without
1653 * File Name Components:: The directory part of a file name, and the rest.
1654 * Relative File Names:: Some file names are relative to a current directory.
1655 * Directory Names:: A directory's name as a directory
1656 is different from its name as a file.
1657 * File Name Expansion:: Converting relative file names to absolute ones.
1658 * Unique File Names:: Generating names for temporary files.
1659 * File Name Completion:: Finding the completions for a given file name.
1660 * Standard File Names:: If your package uses a fixed file name,
1661 how to handle various operating systems simply.
1664 @node File Name Components
1665 @subsection File Name Components
1666 @cindex directory part (of file name)
1667 @cindex nondirectory part (of file name)
1668 @cindex version number (in file name)
1670 The operating system groups files into directories. To specify a
1671 file, you must specify the directory and the file's name within that
1672 directory. Therefore, Emacs considers a file name as having two main
1673 parts: the @dfn{directory name} part, and the @dfn{nondirectory} part
1674 (or @dfn{file name within the directory}). Either part may be empty.
1675 Concatenating these two parts reproduces the original file name.
1677 On most systems, the directory part is everything up to and including
1678 the last slash (backslash is also allowed in input on MS-DOS or
1679 MS-Windows); the nondirectory part is the rest.
1681 For some purposes, the nondirectory part is further subdivided into
1682 the name proper and the @dfn{version number}. On most systems, only
1683 backup files have version numbers in their names.
1685 @defun file-name-directory filename
1686 This function returns the directory part of @var{filename}, as a
1687 directory name (@pxref{Directory Names}), or @code{nil} if
1688 @var{filename} does not include a directory part.
1690 On GNU and Unix systems, a string returned by this function always
1691 ends in a slash. On MS-DOS it can also end in a colon.
1695 (file-name-directory "lewis/foo") ; @r{Unix example}
1699 (file-name-directory "foo") ; @r{Unix example}
1705 @defun file-name-nondirectory filename
1706 This function returns the nondirectory part of @var{filename}.
1710 (file-name-nondirectory "lewis/foo")
1714 (file-name-nondirectory "foo")
1718 (file-name-nondirectory "lewis/")
1724 @defun file-name-sans-versions filename &optional keep-backup-version
1725 This function returns @var{filename} with any file version numbers,
1726 backup version numbers, or trailing tildes discarded.
1728 If @var{keep-backup-version} is non-@code{nil}, then true file version
1729 numbers understood as such by the file system are discarded from the
1730 return value, but backup version numbers are kept.
1734 (file-name-sans-versions "~rms/foo.~1~")
1735 @result{} "~rms/foo"
1738 (file-name-sans-versions "~rms/foo~")
1739 @result{} "~rms/foo"
1742 (file-name-sans-versions "~rms/foo")
1743 @result{} "~rms/foo"
1748 @defun file-name-extension filename &optional period
1749 This function returns @var{filename}'s final ``extension,'' if any,
1750 after applying @code{file-name-sans-versions} to remove any
1751 version/backup part. The extension, in a file name, is the part that
1752 follows the last @samp{.} in the last name component (minus any
1753 version/backup part).
1755 This function returns @code{nil} for extensionless file names such as
1756 @file{foo}. It returns @code{""} for null extensions, as in
1757 @file{foo.}. If the last component of a file name begins with a
1758 @samp{.}, that @samp{.} doesn't count as the beginning of an
1759 extension. Thus, @file{.emacs}'s ``extension'' is @code{nil}, not
1762 If @var{period} is non-@code{nil}, then the returned value includes
1763 the period that delimits the extension, and if @var{filename} has no
1764 extension, the value is @code{""}.
1767 @defun file-name-sans-extension filename
1768 This function returns @var{filename} minus its extension, if any. The
1769 version/backup part, if present, is only removed if the file has an
1770 extension. For example,
1773 (file-name-sans-extension "foo.lose.c")
1774 @result{} "foo.lose"
1775 (file-name-sans-extension "big.hack/foo")
1776 @result{} "big.hack/foo"
1777 (file-name-sans-extension "/my/home/.emacs")
1778 @result{} "/my/home/.emacs"
1779 (file-name-sans-extension "/my/home/.emacs.el")
1780 @result{} "/my/home/.emacs"
1781 (file-name-sans-extension "~/foo.el.~3~")
1783 (file-name-sans-extension "~/foo.~3~")
1784 @result{} "~/foo.~3~"
1787 Note that the @samp{.~3~} in the two last examples is the backup part,
1792 Andrew Innes says that this
1794 @c @defvar directory-sep-char
1795 This variable holds the character that Emacs normally uses to separate
1796 file name components. The default value is @code{?/}, but on MS-Windows
1797 you can set it to @code{?\\}; then the functions that transform file names
1798 use backslashes in their output.
1800 File names using backslashes work as input to Lisp primitives even on
1801 MS-DOS and MS-Windows, even if @code{directory-sep-char} has its default
1806 @node Relative File Names
1807 @subsection Absolute and Relative File Names
1808 @cindex absolute file name
1809 @cindex relative file name
1811 All the directories in the file system form a tree starting at the
1812 root directory. A file name can specify all the directory names
1813 starting from the root of the tree; then it is called an @dfn{absolute}
1814 file name. Or it can specify the position of the file in the tree
1815 relative to a default directory; then it is called a @dfn{relative} file
1816 name. On Unix and GNU/Linux, an absolute file name starts with a slash
1817 or a tilde (@samp{~}), and a relative one does not. On MS-DOS and
1818 MS-Windows, an absolute file name starts with a slash or a backslash, or
1819 with a drive specification @samp{@var{x}:/}, where @var{x} is the
1822 @defun file-name-absolute-p filename
1823 This function returns @code{t} if file @var{filename} is an absolute
1824 file name, @code{nil} otherwise.
1828 (file-name-absolute-p "~rms/foo")
1832 (file-name-absolute-p "rms/foo")
1836 (file-name-absolute-p "/user/rms/foo")
1842 Given a possibly relative file name, you can convert it to an
1843 absolute name using @code{expand-file-name} (@pxref{File Name
1844 Expansion}). This function converts absolute file names to relative
1847 @defun file-relative-name filename &optional directory
1848 This function tries to return a relative name that is equivalent to
1849 @var{filename}, assuming the result will be interpreted relative to
1850 @var{directory} (an absolute directory name or directory file name).
1851 If @var{directory} is omitted or @code{nil}, it defaults to the
1852 current buffer's default directory.
1854 On some operating systems, an absolute file name begins with a device
1855 name. On such systems, @var{filename} has no relative equivalent based
1856 on @var{directory} if they start with two different device names. In
1857 this case, @code{file-relative-name} returns @var{filename} in absolute
1861 (file-relative-name "/foo/bar" "/foo/")
1863 (file-relative-name "/foo/bar" "/hack/")
1864 @result{} "../foo/bar"
1868 @node Directory Names
1869 @comment node-name, next, previous, up
1870 @subsection Directory Names
1871 @cindex directory name
1872 @cindex file name of directory
1874 A @dfn{directory name} is the name of a directory. A directory is
1875 actually a kind of file, so it has a file name, which is related to
1876 the directory name but not identical to it. (This is not quite the
1877 same as the usual Unix terminology.) These two different names for
1878 the same entity are related by a syntactic transformation. On GNU and
1879 Unix systems, this is simple: a directory name ends in a slash,
1880 whereas the directory's name as a file lacks that slash. On MS-DOS
1881 the relationship is more complicated.
1883 The difference between a directory name and its name as a file is
1884 subtle but crucial. When an Emacs variable or function argument is
1885 described as being a directory name, a file name of a directory is not
1886 acceptable. When @code{file-name-directory} returns a string, that is
1887 always a directory name.
1889 The following two functions convert between directory names and file
1890 names. They do nothing special with environment variable substitutions
1891 such as @samp{$HOME}, and the constructs @samp{~}, @samp{.} and @samp{..}.
1893 @defun file-name-as-directory filename
1894 This function returns a string representing @var{filename} in a form
1895 that the operating system will interpret as the name of a directory. On
1896 most systems, this means appending a slash to the string (if it does not
1897 already end in one).
1901 (file-name-as-directory "~rms/lewis")
1902 @result{} "~rms/lewis/"
1907 @defun directory-file-name dirname
1908 This function returns a string representing @var{dirname} in a form that
1909 the operating system will interpret as the name of a file. On most
1910 systems, this means removing the final slash (or backslash) from the
1915 (directory-file-name "~lewis/")
1921 Given a directory name, you can combine it with a relative file name
1922 using @code{concat}:
1925 (concat @var{dirname} @var{relfile})
1929 Be sure to verify that the file name is relative before doing that.
1930 If you use an absolute file name, the results could be syntactically
1931 invalid or refer to the wrong file.
1933 If you want to use a directory file name in making such a
1934 combination, you must first convert it to a directory name using
1935 @code{file-name-as-directory}:
1938 (concat (file-name-as-directory @var{dirfile}) @var{relfile})
1942 Don't try concatenating a slash by hand, as in
1946 (concat @var{dirfile} "/" @var{relfile})
1950 because this is not portable. Always use
1951 @code{file-name-as-directory}.
1953 To convert a directory name to its abbreviation, use this
1956 @defun abbreviate-file-name filename
1957 @anchor{Definition of abbreviate-file-name}
1958 This function returns an abbreviated form of @var{filename}. It
1959 applies the abbreviations specified in @code{directory-abbrev-alist}
1960 (@pxref{File Aliases,,File Aliases, emacs, The GNU Emacs Manual}),
1961 then substitutes @samp{~} for the user's home directory if the
1962 argument names a file in the home directory or one of its
1963 subdirectories. If the home directory is a root directory, it is not
1964 replaced with @samp{~}, because this does not make the result shorter
1967 You can use this function for directory names and for file names,
1968 because it recognizes abbreviations even as part of the name.
1971 @node File Name Expansion
1972 @subsection Functions that Expand Filenames
1973 @cindex expansion of file names
1975 @dfn{Expansion} of a file name means converting a relative file name
1976 to an absolute one. Since this is done relative to a default directory,
1977 you must specify the default directory name as well as the file name to
1978 be expanded. Expansion also simplifies file names by eliminating
1979 redundancies such as @file{./} and @file{@var{name}/../}.
1981 @defun expand-file-name filename &optional directory
1982 This function converts @var{filename} to an absolute file name. If
1983 @var{directory} is supplied, it is the default directory to start with
1984 if @var{filename} is relative. (The value of @var{directory} should
1985 itself be an absolute directory name or directory file name; it may
1986 start with @samp{~}.) Otherwise, the current buffer's value of
1987 @code{default-directory} is used. For example:
1991 (expand-file-name "foo")
1992 @result{} "/xcssun/users/rms/lewis/foo"
1995 (expand-file-name "../foo")
1996 @result{} "/xcssun/users/rms/foo"
1999 (expand-file-name "foo" "/usr/spool/")
2000 @result{} "/usr/spool/foo"
2003 (expand-file-name "$HOME/foo")
2004 @result{} "/xcssun/users/rms/lewis/$HOME/foo"
2008 If the part of the combined file name before the first slash is
2009 @samp{~}, it expands to the value of the @env{HOME} environment
2010 variable (usually your home directory). If the part before the first
2011 slash is @samp{~@var{user}} and if @var{user} is a valid login name,
2012 it expands to @var{user}'s home directory.
2014 Filenames containing @samp{.} or @samp{..} are simplified to their
2019 (expand-file-name "bar/../foo")
2020 @result{} "/xcssun/users/rms/lewis/foo"
2024 In some cases, a leading @samp{..} component can remain in the output:
2028 (expand-file-name "../home" "/")
2029 @result{} "/../home"
2034 This is for the sake of filesystems that have the concept of a
2035 ``superroot'' above the root directory @file{/}. On other filesystems,
2036 @file{/../} is interpreted exactly the same as @file{/}.
2038 Note that @code{expand-file-name} does @emph{not} expand environment
2039 variables; only @code{substitute-in-file-name} does that.
2041 Note also that @code{expand-file-name} does not follow symbolic links
2042 at any level. This results in a difference between the way
2043 @code{file-truename} and @code{expand-file-name} treat @samp{..}.
2044 Assuming that @samp{/tmp/bar} is a symbolic link to the directory
2045 @samp{/tmp/foo/bar} we get:
2049 (file-truename "/tmp/bar/../myfile")
2050 @result{} "/tmp/foo/myfile"
2053 (expand-file-name "/tmp/bar/../myfile")
2054 @result{} "/tmp/myfile"
2058 If you may need to follow symbolic links preceding @samp{..}, you
2059 should make sure to call @code{file-truename} without prior direct or
2060 indirect calls to @code{expand-file-name}. @xref{Truenames}.
2063 @defvar default-directory
2064 The value of this buffer-local variable is the default directory for the
2065 current buffer. It should be an absolute directory name; it may start
2066 with @samp{~}. This variable is buffer-local in every buffer.
2068 @code{expand-file-name} uses the default directory when its second
2069 argument is @code{nil}.
2071 The value is always a string ending with a slash.
2076 @result{} "/user/lewis/manual/"
2081 @defun substitute-in-file-name filename
2082 @anchor{Definition of substitute-in-file-name}
2083 This function replaces environment variable references in
2084 @var{filename} with the environment variable values. Following
2085 standard Unix shell syntax, @samp{$} is the prefix to substitute an
2086 environment variable value. If the input contains @samp{$$}, that is
2087 converted to @samp{$}; this gives the user a way to ``quote'' a
2090 The environment variable name is the series of alphanumeric characters
2091 (including underscores) that follow the @samp{$}. If the character following
2092 the @samp{$} is a @samp{@{}, then the variable name is everything up to the
2095 Calling @code{substitute-in-file-name} on output produced by
2096 @code{substitute-in-file-name} tends to give incorrect results. For
2097 instance, use of @samp{$$} to quote a single @samp{$} won't work
2098 properly, and @samp{$} in an environment variable's value could lead
2099 to repeated substitution. Therefore, programs that call this function
2100 and put the output where it will be passed to this function need to
2101 double all @samp{$} characters to prevent subsequent incorrect
2104 @c Wordy to avoid overfull hbox. --rjc 15mar92
2105 Here we assume that the environment variable @code{HOME}, which holds
2106 the user's home directory name, has value @samp{/xcssun/users/rms}.
2110 (substitute-in-file-name "$HOME/foo")
2111 @result{} "/xcssun/users/rms/foo"
2115 After substitution, if a @samp{~} or a @samp{/} appears immediately
2116 after another @samp{/}, the function discards everything before it (up
2117 through the immediately preceding @samp{/}).
2121 (substitute-in-file-name "bar/~/foo")
2125 (substitute-in-file-name "/usr/local/$HOME/foo")
2126 @result{} "/xcssun/users/rms/foo"
2127 ;; @r{@file{/usr/local/} has been discarded.}
2133 @node Unique File Names
2134 @subsection Generating Unique File Names
2136 Some programs need to write temporary files. Here is the usual way to
2137 construct a name for such a file:
2140 (make-temp-file @var{name-of-application})
2144 The job of @code{make-temp-file} is to prevent two different users or
2145 two different jobs from trying to use the exact same file name.
2147 @defun make-temp-file prefix &optional dir-flag suffix
2148 This function creates a temporary file and returns its name. Emacs
2149 creates the temporary file's name by adding to @var{prefix} some
2150 random characters that are different in each Emacs job. The result is
2151 guaranteed to be a newly created empty file. On MS-DOS, this function
2152 can truncate the @var{string} prefix to fit into the 8+3 file-name
2153 limits. If @var{prefix} is a relative file name, it is expanded
2154 against @code{temporary-file-directory}.
2158 (make-temp-file "foo")
2159 @result{} "/tmp/foo232J6v"
2163 When @code{make-temp-file} returns, the file has been created and is
2164 empty. At that point, you should write the intended contents into the
2167 If @var{dir-flag} is non-@code{nil}, @code{make-temp-file} creates an
2168 empty directory instead of an empty file. It returns the file name,
2169 not the directory name, of that directory. @xref{Directory Names}.
2171 If @var{suffix} is non-@code{nil}, @code{make-temp-file} adds it at
2172 the end of the file name.
2174 To prevent conflicts among different libraries running in the same
2175 Emacs, each Lisp program that uses @code{make-temp-file} should have its
2176 own @var{prefix}. The number added to the end of @var{prefix}
2177 distinguishes between the same application running in different Emacs
2178 jobs. Additional added characters permit a large number of distinct
2179 names even in one Emacs job.
2182 The default directory for temporary files is controlled by the
2183 variable @code{temporary-file-directory}. This variable gives the user
2184 a uniform way to specify the directory for all temporary files. Some
2185 programs use @code{small-temporary-file-directory} instead, if that is
2186 non-@code{nil}. To use it, you should expand the prefix against
2187 the proper directory before calling @code{make-temp-file}.
2189 In older Emacs versions where @code{make-temp-file} does not exist,
2190 you should use @code{make-temp-name} instead:
2194 (expand-file-name @var{name-of-application}
2195 temporary-file-directory))
2198 @defun make-temp-name string
2199 This function generates a string that can be used as a unique file
2200 name. The name starts with @var{string}, and has several random
2201 characters appended to it, which are different in each Emacs job. It
2202 is like @code{make-temp-file} except that it just constructs a name,
2203 and does not create a file. Another difference is that @var{string}
2204 should be an absolute file name. On MS-DOS, this function can
2205 truncate the @var{string} prefix to fit into the 8+3 file-name limits.
2208 @defopt temporary-file-directory
2209 @cindex @code{TMPDIR} environment variable
2210 @cindex @code{TMP} environment variable
2211 @cindex @code{TEMP} environment variable
2212 This variable specifies the directory name for creating temporary files.
2213 Its value should be a directory name (@pxref{Directory Names}), but it
2214 is good for Lisp programs to cope if the value is a directory's file
2215 name instead. Using the value as the second argument to
2216 @code{expand-file-name} is a good way to achieve that.
2218 The default value is determined in a reasonable way for your operating
2219 system; it is based on the @code{TMPDIR}, @code{TMP} and @code{TEMP}
2220 environment variables, with a fall-back to a system-dependent name if
2221 none of these variables is defined.
2223 Even if you do not use @code{make-temp-file} to create the temporary
2224 file, you should still use this variable to decide which directory to
2225 put the file in. However, if you expect the file to be small, you
2226 should use @code{small-temporary-file-directory} first if that is
2230 @defopt small-temporary-file-directory
2231 This variable specifies the directory name for
2232 creating certain temporary files, which are likely to be small.
2234 If you want to write a temporary file which is likely to be small, you
2235 should compute the directory like this:
2239 (expand-file-name @var{prefix}
2240 (or small-temporary-file-directory
2241 temporary-file-directory)))
2245 @node File Name Completion
2246 @subsection File Name Completion
2247 @cindex file name completion subroutines
2248 @cindex completion, file name
2250 This section describes low-level subroutines for completing a file
2251 name. For higher level functions, see @ref{Reading File Names}.
2253 @defun file-name-all-completions partial-filename directory
2254 This function returns a list of all possible completions for a file
2255 whose name starts with @var{partial-filename} in directory
2256 @var{directory}. The order of the completions is the order of the files
2257 in the directory, which is unpredictable and conveys no useful
2260 The argument @var{partial-filename} must be a file name containing no
2261 directory part and no slash (or backslash on some systems). The current
2262 buffer's default directory is prepended to @var{directory}, if
2263 @var{directory} is not absolute.
2265 In the following example, suppose that @file{~rms/lewis} is the current
2266 default directory, and has five files whose names begin with @samp{f}:
2267 @file{foo}, @file{file~}, @file{file.c}, @file{file.c.~1~}, and
2268 @file{file.c.~2~}.@refill
2272 (file-name-all-completions "f" "")
2273 @result{} ("foo" "file~" "file.c.~2~"
2274 "file.c.~1~" "file.c")
2278 (file-name-all-completions "fo" "")
2284 @defun file-name-completion filename directory &optional predicate
2285 This function completes the file name @var{filename} in directory
2286 @var{directory}. It returns the longest prefix common to all file names
2287 in directory @var{directory} that start with @var{filename}. If
2288 @var{predicate} is non-@code{nil} then it ignores possible completions
2289 that don't satisfy @var{predicate}, after calling that function
2290 with one argument, the expanded absolute file name.
2292 If only one match exists and @var{filename} matches it exactly, the
2293 function returns @code{t}. The function returns @code{nil} if directory
2294 @var{directory} contains no name starting with @var{filename}.
2296 In the following example, suppose that the current default directory
2297 has five files whose names begin with @samp{f}: @file{foo},
2298 @file{file~}, @file{file.c}, @file{file.c.~1~}, and
2299 @file{file.c.~2~}.@refill
2303 (file-name-completion "fi" "")
2308 (file-name-completion "file.c.~1" "")
2309 @result{} "file.c.~1~"
2313 (file-name-completion "file.c.~1~" "")
2318 (file-name-completion "file.c.~3" "")
2324 @defopt completion-ignored-extensions
2325 @code{file-name-completion} usually ignores file names that end in any
2326 string in this list. It does not ignore them when all the possible
2327 completions end in one of these suffixes. This variable has no effect
2328 on @code{file-name-all-completions}.@refill
2330 A typical value might look like this:
2334 completion-ignored-extensions
2335 @result{} (".o" ".elc" "~" ".dvi")
2339 If an element of @code{completion-ignored-extensions} ends in a slash
2340 @samp{/}, it signals a directory. The elements which do @emph{not} end
2341 in a slash will never match a directory; thus, the above value will not
2342 filter out a directory named @file{foo.elc}.
2345 @node Standard File Names
2346 @subsection Standard File Names
2348 Most of the file names used in Lisp programs are entered by the user.
2349 But occasionally a Lisp program needs to specify a standard file name
2350 for a particular use---typically, to hold customization information
2351 about each user. For example, abbrev definitions are stored (by
2352 default) in the file @file{~/.abbrev_defs}; the @code{completion}
2353 package stores completions in the file @file{~/.completions}. These are
2354 two of the many standard file names used by parts of Emacs for certain
2357 Various operating systems have their own conventions for valid file
2358 names and for which file names to use for user profile data. A Lisp
2359 program which reads a file using a standard file name ought to use, on
2360 each type of system, a file name suitable for that system. The function
2361 @code{convert-standard-filename} makes this easy to do.
2363 @defun convert-standard-filename filename
2364 This function alters the file name @var{filename} to fit the conventions
2365 of the operating system in use, and returns the result as a new string.
2368 The recommended way to specify a standard file name in a Lisp program
2369 is to choose a name which fits the conventions of GNU and Unix systems,
2370 usually with a nondirectory part that starts with a period, and pass it
2371 to @code{convert-standard-filename} instead of using it directly. Here
2372 is an example from the @code{completion} package:
2375 (defvar save-completions-file-name
2376 (convert-standard-filename "~/.completions")
2377 "*The file name to save completions to.")
2380 On GNU and Unix systems, and on some other systems as well,
2381 @code{convert-standard-filename} returns its argument unchanged. On
2382 some other systems, it alters the name to fit the system's conventions.
2384 For example, on MS-DOS the alterations made by this function include
2385 converting a leading @samp{.} to @samp{_}, converting a @samp{_} in the
2386 middle of the name to @samp{.} if there is no other @samp{.}, inserting
2387 a @samp{.} after eight characters if there is none, and truncating to
2388 three characters after the @samp{.}. (It makes other changes as well.)
2389 Thus, @file{.abbrev_defs} becomes @file{_abbrev.def}, and
2390 @file{.completions} becomes @file{_complet.ion}.
2392 @node Contents of Directories
2393 @section Contents of Directories
2394 @cindex directory-oriented functions
2395 @cindex file names in directory
2397 A directory is a kind of file that contains other files entered under
2398 various names. Directories are a feature of the file system.
2400 Emacs can list the names of the files in a directory as a Lisp list,
2401 or display the names in a buffer using the @code{ls} shell command. In
2402 the latter case, it can optionally display information about each file,
2403 depending on the options passed to the @code{ls} command.
2405 @defun directory-files directory &optional full-name match-regexp nosort
2406 This function returns a list of the names of the files in the directory
2407 @var{directory}. By default, the list is in alphabetical order.
2409 If @var{full-name} is non-@code{nil}, the function returns the files'
2410 absolute file names. Otherwise, it returns the names relative to
2411 the specified directory.
2413 If @var{match-regexp} is non-@code{nil}, this function returns only
2414 those file names that contain a match for that regular expression---the
2415 other file names are excluded from the list. On case-insensitive
2416 filesystems, the regular expression matching is case-insensitive.
2419 If @var{nosort} is non-@code{nil}, @code{directory-files} does not sort
2420 the list, so you get the file names in no particular order. Use this if
2421 you want the utmost possible speed and don't care what order the files
2422 are processed in. If the order of processing is visible to the user,
2423 then the user will probably be happier if you do sort the names.
2427 (directory-files "~lewis")
2428 @result{} ("#foo#" "#foo.el#" "." ".."
2429 "dired-mods.el" "files.texi"
2434 An error is signaled if @var{directory} is not the name of a directory
2438 @defun directory-files-and-attributes directory &optional full-name match-regexp nosort id-format
2439 This is similar to @code{directory-files} in deciding which files
2440 to report on and how to report their names. However, instead
2441 of returning a list of file names, it returns for each file a
2442 list @code{(@var{filename} . @var{attributes})}, where @var{attributes}
2443 is what @code{file-attributes} would return for that file.
2444 The optional argument @var{id-format} has the same meaning as the
2445 corresponding argument to @code{file-attributes} (@pxref{Definition
2446 of file-attributes}).
2449 @defun file-expand-wildcards pattern &optional full
2450 This function expands the wildcard pattern @var{pattern}, returning
2451 a list of file names that match it.
2453 If @var{pattern} is written as an absolute file name,
2454 the values are absolute also.
2456 If @var{pattern} is written as a relative file name, it is interpreted
2457 relative to the current default directory. The file names returned are
2458 normally also relative to the current default directory. However, if
2459 @var{full} is non-@code{nil}, they are absolute.
2462 @defun insert-directory file switches &optional wildcard full-directory-p
2463 This function inserts (in the current buffer) a directory listing for
2464 directory @var{file}, formatted with @code{ls} according to
2465 @var{switches}. It leaves point after the inserted text.
2466 @var{switches} may be a string of options, or a list of strings
2467 representing individual options.
2469 The argument @var{file} may be either a directory name or a file
2470 specification including wildcard characters. If @var{wildcard} is
2471 non-@code{nil}, that means treat @var{file} as a file specification with
2474 If @var{full-directory-p} is non-@code{nil}, that means the directory
2475 listing is expected to show the full contents of a directory. You
2476 should specify @code{t} when @var{file} is a directory and switches do
2477 not contain @samp{-d}. (The @samp{-d} option to @code{ls} says to
2478 describe a directory itself as a file, rather than showing its
2481 On most systems, this function works by running a directory listing
2482 program whose name is in the variable @code{insert-directory-program}.
2483 If @var{wildcard} is non-@code{nil}, it also runs the shell specified by
2484 @code{shell-file-name}, to expand the wildcards.
2486 MS-DOS and MS-Windows systems usually lack the standard Unix program
2487 @code{ls}, so this function emulates the standard Unix program @code{ls}
2490 As a technical detail, when @var{switches} contains the long
2491 @samp{--dired} option, @code{insert-directory} treats it specially,
2492 for the sake of dired. However, the normally equivalent short
2493 @samp{-D} option is just passed on to @code{insert-directory-program},
2494 as any other option.
2497 @defvar insert-directory-program
2498 This variable's value is the program to run to generate a directory listing
2499 for the function @code{insert-directory}. It is ignored on systems
2500 which generate the listing with Lisp code.
2503 @node Create/Delete Dirs
2504 @section Creating, Copying and Deleting Directories
2505 @cindex creating, copying and deleting directories
2506 @c Emacs 19 features
2508 Most Emacs Lisp file-manipulation functions get errors when used on
2509 files that are directories. For example, you cannot delete a directory
2510 with @code{delete-file}. These special functions exist to create and
2514 @deffn Command make-directory dirname &optional parents
2515 This command creates a directory named @var{dirname}. If
2516 @var{parents} is non-@code{nil}, as is always the case in an
2517 interactive call, that means to create the parent directories first,
2518 if they don't already exist.
2520 @code{mkdir} is an alias for this.
2523 @deffn Command copy-directory dirname newname &optional keep-time parents
2524 This command copies the directory named @var{dirname} to
2525 @var{newname}. If @var{newname} names an existing directory,
2526 @var{dirname} will be copied to a subdirectory there.
2528 It always sets the file modes of the copied files to match the
2529 corresponding original file.
2531 The third arg @var{keep-time} non-@code{nil} means to preserve the
2532 modification time of the copied files. A prefix arg makes
2533 @var{keep-time} non-@code{nil}.
2535 Noninteractively, the last argument @var{parents} says whether to
2536 create parent directories if they don't exist. Interactively,
2537 this happens by default.
2540 @deffn Command delete-directory dirname &optional recursive
2541 This command deletes the directory named @var{dirname}. The function
2542 @code{delete-file} does not work for files that are directories; you
2543 must use @code{delete-directory} for them. If @var{recursive} is
2544 @code{nil}, and the directory contains any files,
2545 @code{delete-directory} signals an error.
2547 @code{delete-directory} only follows symbolic links at the level of
2551 @node Magic File Names
2552 @section Making Certain File Names ``Magic''
2553 @cindex magic file names
2556 You can implement special handling for certain file names. This is
2557 called making those names @dfn{magic}. The principal use for this
2558 feature is in implementing remote file names (@pxref{Remote Files,,
2559 Remote Files, emacs, The GNU Emacs Manual}).
2561 To define a kind of magic file name, you must supply a regular
2562 expression to define the class of names (all those that match the
2563 regular expression), plus a handler that implements all the primitive
2564 Emacs file operations for file names that do match.
2566 @vindex file-name-handler-alist
2567 The variable @code{file-name-handler-alist} holds a list of handlers,
2568 together with regular expressions that determine when to apply each
2569 handler. Each element has this form:
2572 (@var{regexp} . @var{handler})
2576 All the Emacs primitives for file access and file name transformation
2577 check the given file name against @code{file-name-handler-alist}. If
2578 the file name matches @var{regexp}, the primitives handle that file by
2579 calling @var{handler}.
2581 The first argument given to @var{handler} is the name of the
2582 primitive, as a symbol; the remaining arguments are the arguments that
2583 were passed to that primitive. (The first of these arguments is most
2584 often the file name itself.) For example, if you do this:
2587 (file-exists-p @var{filename})
2591 and @var{filename} has handler @var{handler}, then @var{handler} is
2595 (funcall @var{handler} 'file-exists-p @var{filename})
2598 When a function takes two or more arguments that must be file names,
2599 it checks each of those names for a handler. For example, if you do
2603 (expand-file-name @var{filename} @var{dirname})
2607 then it checks for a handler for @var{filename} and then for a handler
2608 for @var{dirname}. In either case, the @var{handler} is called like
2612 (funcall @var{handler} 'expand-file-name @var{filename} @var{dirname})
2616 The @var{handler} then needs to figure out whether to handle
2617 @var{filename} or @var{dirname}.
2619 If the specified file name matches more than one handler, the one
2620 whose match starts last in the file name gets precedence. This rule
2621 is chosen so that handlers for jobs such as uncompression are handled
2622 first, before handlers for jobs such as remote file access.
2624 Here are the operations that a magic file name handler gets to handle:
2628 @code{access-file}, @code{add-name-to-file},
2629 @code{byte-compiler-base-file-name},@*
2630 @code{copy-directory}, @code{copy-file},
2631 @code{delete-directory}, @code{delete-file},
2632 @code{diff-latest-backup-file},
2633 @code{directory-file-name},
2634 @code{directory-files},
2635 @code{directory-files-and-attributes},
2636 @code{dired-compress-file}, @code{dired-uncache},@*
2637 @code{expand-file-name},
2638 @code{file-accessible-directory-p},
2639 @code{file-attributes},
2640 @code{file-directory-p},
2641 @code{file-executable-p}, @code{file-exists-p},
2642 @code{file-local-copy}, @code{file-remote-p},
2643 @code{file-modes}, @code{file-name-all-completions},
2644 @code{file-name-as-directory},
2645 @code{file-name-completion},
2646 @code{file-name-directory},
2647 @code{file-name-nondirectory},
2648 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2649 @code{file-ownership-preserved-p},
2650 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2651 @code{file-truename}, @code{file-writable-p},
2652 @code{find-backup-file-name},
2653 @c Not sure why it was here: @code{find-file-noselect},@*
2654 @code{get-file-buffer},
2655 @code{insert-directory},
2656 @code{insert-file-contents},@*
2658 @code{make-auto-save-file-name},
2659 @code{make-directory},
2660 @code{make-directory-internal},
2661 @code{make-symbolic-link},@*
2662 @code{process-file},
2663 @code{rename-file}, @code{set-file-modes}, @code{set-file-times},
2664 @code{set-visited-file-modtime}, @code{shell-command},
2665 @code{start-file-process},
2666 @code{substitute-in-file-name},@*
2667 @code{unhandled-file-name-directory},
2668 @code{vc-registered},
2669 @code{verify-visited-file-modtime},@*
2670 @code{write-region}.
2675 @code{access-file}, @code{add-name-to-file},
2676 @code{byte-com@discretionary{}{}{}piler-base-file-name},
2677 @code{copy-directory}, @code{copy-file},
2678 @code{delete-directory}, @code{delete-file},
2679 @code{diff-latest-backup-file},
2680 @code{directory-file-name},
2681 @code{directory-files},
2682 @code{directory-files-and-at@discretionary{}{}{}tributes},
2683 @code{dired-compress-file}, @code{dired-uncache},
2684 @code{expand-file-name},
2685 @code{file-accessible-direc@discretionary{}{}{}tory-p},
2686 @code{file-attributes},
2687 @code{file-direct@discretionary{}{}{}ory-p},
2688 @code{file-executable-p}, @code{file-exists-p},
2689 @code{file-local-copy}, @code{file-remote-p},
2690 @code{file-modes}, @code{file-name-all-completions},
2691 @code{file-name-as-directory},
2692 @code{file-name-completion},
2693 @code{file-name-directory},
2694 @code{file-name-nondirec@discretionary{}{}{}tory},
2695 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2696 @code{file-ownership-pre@discretionary{}{}{}served-p},
2697 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2698 @code{file-truename}, @code{file-writable-p},
2699 @code{find-backup-file-name},
2700 @c Not sure why it was here: @code{find-file-noselect},
2701 @code{get-file-buffer},
2702 @code{insert-directory},
2703 @code{insert-file-contents},
2704 @code{load}, @code{make-direc@discretionary{}{}{}tory},
2705 @code{make-direc@discretionary{}{}{}tory-internal},
2706 @code{make-symbolic-link},
2707 @code{process-file},
2708 @code{rename-file}, @code{set-file-modes},
2709 @code{set-visited-file-modtime}, @code{shell-command},
2710 @code{start-file-process},
2711 @code{substitute-in-file-name},
2712 @code{unhandled-file-name-directory},
2713 @code{vc-regis@discretionary{}{}{}tered},
2714 @code{verify-visited-file-modtime},
2715 @code{write-region}.
2719 Handlers for @code{insert-file-contents} typically need to clear the
2720 buffer's modified flag, with @code{(set-buffer-modified-p nil)}, if the
2721 @var{visit} argument is non-@code{nil}. This also has the effect of
2722 unlocking the buffer if it is locked.
2724 The handler function must handle all of the above operations, and
2725 possibly others to be added in the future. It need not implement all
2726 these operations itself---when it has nothing special to do for a
2727 certain operation, it can reinvoke the primitive, to handle the
2728 operation ``in the usual way.'' It should always reinvoke the primitive
2729 for an operation it does not recognize. Here's one way to do this:
2732 (defun my-file-handler (operation &rest args)
2733 ;; @r{First check for the specific operations}
2734 ;; @r{that we have special handling for.}
2735 (cond ((eq operation 'insert-file-contents) @dots{})
2736 ((eq operation 'write-region) @dots{})
2738 ;; @r{Handle any operation we don't know about.}
2739 (t (let ((inhibit-file-name-handlers
2740 (cons 'my-file-handler
2741 (and (eq inhibit-file-name-operation operation)
2742 inhibit-file-name-handlers)))
2743 (inhibit-file-name-operation operation))
2744 (apply operation args)))))
2747 When a handler function decides to call the ordinary Emacs primitive for
2748 the operation at hand, it needs to prevent the primitive from calling
2749 the same handler once again, thus leading to an infinite recursion. The
2750 example above shows how to do this, with the variables
2751 @code{inhibit-file-name-handlers} and
2752 @code{inhibit-file-name-operation}. Be careful to use them exactly as
2753 shown above; the details are crucial for proper behavior in the case of
2754 multiple handlers, and for operations that have two file names that may
2757 @kindex safe-magic (@r{property})
2758 Handlers that don't really do anything special for actual access to the
2759 file---such as the ones that implement completion of host names for
2760 remote file names---should have a non-@code{nil} @code{safe-magic}
2761 property. For instance, Emacs normally ``protects'' directory names
2762 it finds in @code{PATH} from becoming magic, if they look like magic
2763 file names, by prefixing them with @samp{/:}. But if the handler that
2764 would be used for them has a non-@code{nil} @code{safe-magic}
2765 property, the @samp{/:} is not added.
2767 @kindex operations (@r{property})
2768 A file name handler can have an @code{operations} property to
2769 declare which operations it handles in a nontrivial way. If this
2770 property has a non-@code{nil} value, it should be a list of
2771 operations; then only those operations will call the handler. This
2772 avoids inefficiency, but its main purpose is for autoloaded handler
2773 functions, so that they won't be loaded except when they have real
2776 Simply deferring all operations to the usual primitives does not
2777 work. For instance, if the file name handler applies to
2778 @code{file-exists-p}, then it must handle @code{load} itself, because
2779 the usual @code{load} code won't work properly in that case. However,
2780 if the handler uses the @code{operations} property to say it doesn't
2781 handle @code{file-exists-p}, then it need not handle @code{load}
2784 @defvar inhibit-file-name-handlers
2785 This variable holds a list of handlers whose use is presently inhibited
2786 for a certain operation.
2789 @defvar inhibit-file-name-operation
2790 The operation for which certain handlers are presently inhibited.
2793 @defun find-file-name-handler file operation
2794 This function returns the handler function for file name @var{file},
2795 or @code{nil} if there is none. The argument @var{operation} should
2796 be the operation to be performed on the file---the value you will pass
2797 to the handler as its first argument when you call it. If
2798 @var{operation} equals @code{inhibit-file-name-operation}, or if it is
2799 not found in the @code{operations} property of the handler, this
2800 function returns @code{nil}.
2803 @defun file-local-copy filename
2804 This function copies file @var{filename} to an ordinary non-magic file
2805 on the local machine, if it isn't on the local machine already. Magic
2806 file names should handle the @code{file-local-copy} operation if they
2807 refer to files on other machines. A magic file name that is used for
2808 other purposes than remote file access should not handle
2809 @code{file-local-copy}; then this function will treat the file as
2812 If @var{filename} is local, whether magic or not, this function does
2813 nothing and returns @code{nil}. Otherwise it returns the file name
2814 of the local copy file.
2817 @defun file-remote-p filename &optional identification connected
2818 This function tests whether @var{filename} is a remote file. If
2819 @var{filename} is local (not remote), the return value is @code{nil}.
2820 If @var{filename} is indeed remote, the return value is a string that
2821 identifies the remote system.
2823 This identifier string can include a host name and a user name, as
2824 well as characters designating the method used to access the remote
2825 system. For example, the remote identifier string for the filename
2826 @code{/sudo::/some/file} is @code{/sudo:root@@localhost:}.
2828 If @code{file-remote-p} returns the same identifier for two different
2829 filenames, that means they are stored on the same file system and can
2830 be accessed locally with respect to each other. This means, for
2831 example, that it is possible to start a remote process accessing both
2832 files at the same time. Implementors of file handlers need to ensure
2833 this principle is valid.
2835 @var{identification} specifies which part of the identifier shall be
2836 returned as string. @var{identification} can be the symbol
2837 @code{method}, @code{user} or @code{host}; any other value is handled
2838 like @code{nil} and means to return the complete identifier string.
2839 In the example above, the remote @code{user} identifier string would
2842 If @var{connected} is non-@code{nil}, this function returns @code{nil}
2843 even if @var{filename} is remote, if Emacs has no network connection
2844 to its host. This is useful when you want to avoid the delay of
2845 making connections when they don't exist.
2848 @defun unhandled-file-name-directory filename
2849 This function returns the name of a directory that is not magic. It
2850 uses the directory part of @var{filename} if that is not magic. For a
2851 magic file name, it invokes the file name handler, which therefore
2852 decides what value to return. If @var{filename} is not accessible
2853 from a local process, then the file name handler should indicate it by
2854 returning @code{nil}.
2856 This is useful for running a subprocess; every subprocess must have a
2857 non-magic directory to serve as its current directory, and this function
2858 is a good way to come up with one.
2861 @node Format Conversion
2862 @section File Format Conversion
2864 @cindex file format conversion
2865 @cindex encoding file formats
2866 @cindex decoding file formats
2867 @cindex text properties in files
2868 @cindex saving text properties
2869 Emacs performs several steps to convert the data in a buffer (text,
2870 text properties, and possibly other information) to and from a
2871 representation suitable for storing into a file. This section describes
2872 the fundamental functions that perform this @dfn{format conversion},
2873 namely @code{insert-file-contents} for reading a file into a buffer,
2874 and @code{write-region} for writing a buffer into a file.
2877 * Overview: Format Conversion Overview. @code{insert-file-contents} and @code{write-region}.
2878 * Round-Trip: Format Conversion Round-Trip. Using @code{format-alist}.
2879 * Piecemeal: Format Conversion Piecemeal. Specifying non-paired conversion.
2882 @node Format Conversion Overview
2883 @subsection Overview
2885 The function @code{insert-file-contents}:
2888 @item initially, inserts bytes from the file into the buffer;
2889 @item decodes bytes to characters as appropriate;
2890 @item processes formats as defined by entries in @code{format-alist}; and
2891 @item calls functions in @code{after-insert-file-functions}.
2895 The function @code{write-region}:
2898 @item initially, calls functions in @code{write-region-annotate-functions};
2899 @item processes formats as defined by entries in @code{format-alist};
2900 @item encodes characters to bytes as appropriate; and
2901 @item modifies the file with the bytes.
2904 This shows the symmetry of the lowest-level operations; reading and
2905 writing handle things in opposite order. The rest of this section
2906 describes the two facilities surrounding the three variables named
2907 above, as well as some related functions. @ref{Coding Systems}, for
2908 details on character encoding and decoding.
2910 @node Format Conversion Round-Trip
2911 @subsection Round-Trip Specification
2913 The most general of the two facilities is controlled by the variable
2914 @code{format-alist}, a list of @dfn{file format} specifications, which
2915 describe textual representations used in files for the data in an Emacs
2916 buffer. The descriptions for reading and writing are paired, which is
2917 why we call this ``round-trip'' specification
2918 (@pxref{Format Conversion Piecemeal}, for non-paired specification).
2920 @defvar format-alist
2921 This list contains one format definition for each defined file format.
2922 Each format definition is a list of this form:
2925 (@var{name} @var{doc-string} @var{regexp} @var{from-fn} @var{to-fn} @var{modify} @var{mode-fn} @var{preserve})
2929 @cindex format definition
2931 Here is what the elements in a format definition mean:
2935 The name of this format.
2938 A documentation string for the format.
2941 A regular expression which is used to recognize files represented in
2942 this format. If @code{nil}, the format is never applied automatically.
2945 A shell command or function to decode data in this format (to convert
2946 file data into the usual Emacs data representation).
2948 A shell command is represented as a string; Emacs runs the command as a
2949 filter to perform the conversion.
2951 If @var{from-fn} is a function, it is called with two arguments, @var{begin}
2952 and @var{end}, which specify the part of the buffer it should convert.
2953 It should convert the text by editing it in place. Since this can
2954 change the length of the text, @var{from-fn} should return the modified
2957 One responsibility of @var{from-fn} is to make sure that the beginning
2958 of the file no longer matches @var{regexp}. Otherwise it is likely to
2962 A shell command or function to encode data in this format---that is, to
2963 convert the usual Emacs data representation into this format.
2965 If @var{to-fn} is a string, it is a shell command; Emacs runs the
2966 command as a filter to perform the conversion.
2968 If @var{to-fn} is a function, it is called with three arguments:
2969 @var{begin} and @var{end}, which specify the part of the buffer it
2970 should convert, and @var{buffer}, which specifies which buffer. There
2971 are two ways it can do the conversion:
2975 By editing the buffer in place. In this case, @var{to-fn} should
2976 return the end-position of the range of text, as modified.
2979 By returning a list of annotations. This is a list of elements of the
2980 form @code{(@var{position} . @var{string})}, where @var{position} is an
2981 integer specifying the relative position in the text to be written, and
2982 @var{string} is the annotation to add there. The list must be sorted in
2983 order of position when @var{to-fn} returns it.
2985 When @code{write-region} actually writes the text from the buffer to the
2986 file, it intermixes the specified annotations at the corresponding
2987 positions. All this takes place without modifying the buffer.
2991 A flag, @code{t} if the encoding function modifies the buffer, and
2992 @code{nil} if it works by returning a list of annotations.
2995 A minor-mode function to call after visiting a file converted from this
2996 format. The function is called with one argument, the integer 1;
2997 that tells a minor-mode function to enable the mode.
3000 A flag, @code{t} if @code{format-write-file} should not remove this format
3001 from @code{buffer-file-format}.
3004 The function @code{insert-file-contents} automatically recognizes file
3005 formats when it reads the specified file. It checks the text of the
3006 beginning of the file against the regular expressions of the format
3007 definitions, and if it finds a match, it calls the decoding function for
3008 that format. Then it checks all the known formats over again.
3009 It keeps checking them until none of them is applicable.
3011 Visiting a file, with @code{find-file-noselect} or the commands that use
3012 it, performs conversion likewise (because it calls
3013 @code{insert-file-contents}); it also calls the mode function for each
3014 format that it decodes. It stores a list of the format names in the
3015 buffer-local variable @code{buffer-file-format}.
3017 @defvar buffer-file-format
3018 This variable states the format of the visited file. More precisely,
3019 this is a list of the file format names that were decoded in the course
3020 of visiting the current buffer's file. It is always buffer-local in all
3024 When @code{write-region} writes data into a file, it first calls the
3025 encoding functions for the formats listed in @code{buffer-file-format},
3026 in the order of appearance in the list.
3028 @deffn Command format-write-file file format &optional confirm
3029 This command writes the current buffer contents into the file @var{file}
3030 in a format based on @var{format}, which is a list of format names. It
3031 constructs the actual format starting from @var{format}, then appending
3032 any elements from the value of @code{buffer-file-format} with a non-nil
3033 @var{preserve} flag (see above), if they are not already present in
3034 @var{format}. It then updates @code{buffer-file-format} with this
3035 format, making it the default for future saves. Except for the
3036 @var{format} argument, this command is similar to @code{write-file}. In
3037 particular, @var{confirm} has the same meaning and interactive treatment
3038 as the corresponding argument to @code{write-file}. @xref{Definition of
3042 @deffn Command format-find-file file format
3043 This command finds the file @var{file}, converting it according to
3044 format @var{format}. It also makes @var{format} the default if the
3045 buffer is saved later.
3047 The argument @var{format} is a list of format names. If @var{format} is
3048 @code{nil}, no conversion takes place. Interactively, typing just
3049 @key{RET} for @var{format} specifies @code{nil}.
3052 @deffn Command format-insert-file file format &optional beg end
3053 This command inserts the contents of file @var{file}, converting it
3054 according to format @var{format}. If @var{beg} and @var{end} are
3055 non-@code{nil}, they specify which part of the file to read, as in
3056 @code{insert-file-contents} (@pxref{Reading from Files}).
3058 The return value is like what @code{insert-file-contents} returns: a
3059 list of the absolute file name and the length of the data inserted
3062 The argument @var{format} is a list of format names. If @var{format} is
3063 @code{nil}, no conversion takes place. Interactively, typing just
3064 @key{RET} for @var{format} specifies @code{nil}.
3067 @defvar buffer-auto-save-file-format
3068 This variable specifies the format to use for auto-saving. Its value is
3069 a list of format names, just like the value of
3070 @code{buffer-file-format}; however, it is used instead of
3071 @code{buffer-file-format} for writing auto-save files. If the value
3072 is @code{t}, the default, auto-saving uses the same format as a
3073 regular save in the same buffer. This variable is always buffer-local
3077 @node Format Conversion Piecemeal
3078 @subsection Piecemeal Specification
3080 In contrast to the round-trip specification described in the previous
3081 subsection (@pxref{Format Conversion Round-Trip}), you can use the variables
3082 @code{after-insert-file-functions} and @code{write-region-annotate-functions}
3083 to separately control the respective reading and writing conversions.
3085 Conversion starts with one representation and produces another
3086 representation. When there is only one conversion to do, there is no
3087 conflict about what to start with. However, when there are multiple
3088 conversions involved, conflict may arise when two conversions need to
3089 start with the same data.
3091 This situation is best understood in the context of converting text
3092 properties during @code{write-region}. For example, the character at
3093 position 42 in a buffer is @samp{X} with a text property @code{foo}. If
3094 the conversion for @code{foo} is done by inserting into the buffer, say,
3095 @samp{FOO:}, then that changes the character at position 42 from
3096 @samp{X} to @samp{F}. The next conversion will start with the wrong
3099 To avoid conflict, cooperative conversions do not modify the buffer,
3100 but instead specify @dfn{annotations}, a list of elements of the form
3101 @code{(@var{position} . @var{string})}, sorted in order of increasing
3104 If there is more than one conversion, @code{write-region} merges their
3105 annotations destructively into one sorted list. Later, when the text
3106 from the buffer is actually written to the file, it intermixes the
3107 specified annotations at the corresponding positions. All this takes
3108 place without modifying the buffer.
3110 @c ??? What about ``overriding'' conversions like those allowed
3111 @c ??? for `write-region-annotate-functions', below? --ttn
3113 In contrast, when reading, the annotations intermixed with the text
3114 are handled immediately. @code{insert-file-contents} sets point to
3115 the beginning of some text to be converted, then calls the conversion
3116 functions with the length of that text. These functions should always
3117 return with point at the beginning of the inserted text. This
3118 approach makes sense for reading because annotations removed by the
3119 first converter can't be mistakenly processed by a later converter.
3120 Each conversion function should scan for the annotations it
3121 recognizes, remove the annotation, modify the buffer text (to set a
3122 text property, for example), and return the updated length of the
3123 text, as it stands after those changes. The value returned by one
3124 function becomes the argument to the next function.
3126 @defvar write-region-annotate-functions
3127 A list of functions for @code{write-region} to call. Each function in
3128 the list is called with two arguments: the start and end of the region
3129 to be written. These functions should not alter the contents of the
3130 buffer. Instead, they should return annotations.
3132 As a special case, a function may return with a different buffer
3133 current. Emacs takes this to mean that the current buffer contains
3134 altered text to be output. It therefore changes the @var{start} and
3135 @var{end} arguments of the @code{write-region} call, giving them the
3136 values of @code{point-min} and @code{point-max} in the new buffer,
3137 respectively. It also discards all previous annotations, because they
3138 should have been dealt with by this function.
3141 @defvar write-region-post-annotation-function
3142 The value of this variable, if non-@code{nil}, should be a function.
3143 This function is called, with no arguments, after @code{write-region}
3146 If any function in @code{write-region-annotate-functions} returns with
3147 a different buffer current, Emacs calls
3148 @code{write-region-post-annotation-function} more than once. Emacs
3149 calls it with the last buffer that was current, and again with the
3150 buffer before that, and so on back to the original buffer.
3152 Thus, a function in @code{write-region-annotate-functions} can create
3153 a buffer, give this variable the local value of @code{kill-buffer} in
3154 that buffer, set up the buffer with altered text, and make the buffer
3155 current. The buffer will be killed after @code{write-region} is done.
3158 @defvar after-insert-file-functions
3159 Each function in this list is called by @code{insert-file-contents}
3160 with one argument, the number of characters inserted, and with point
3161 at the beginning of the inserted text. Each function should leave
3162 point unchanged, and return the new character count describing the
3163 inserted text as modified by the function.
3164 @c ??? The docstring mentions a handler from `file-name-handler-alist'
3165 @c "intercepting" `insert-file-contents'. Hmmm. --ttn
3168 We invite users to write Lisp programs to store and retrieve text
3169 properties in files, using these hooks, and thus to experiment with
3170 various data formats and find good ones. Eventually we hope users
3171 will produce good, general extensions we can install in Emacs.
3173 We suggest not trying to handle arbitrary Lisp objects as text property
3174 names or values---because a program that general is probably difficult
3175 to write, and slow. Instead, choose a set of possible data types that
3176 are reasonably flexible, and not too hard to encode.
3179 arch-tag: 141f74ce-6ae3-40dc-a6c4-ef83fc4ec35c