2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998-1999, 2001-2018 Free Software
5 @c See the file elisp.texi for copying conditions.
9 This chapter describes the Emacs Lisp functions and variables to
10 find, create, view, save, and otherwise work with files and
11 directories. A few other file-related functions are described in
12 @ref{Buffers}, and those related to backups and auto-saving are
13 described in @ref{Backups and Auto-Saving}.
15 Many of the file functions take one or more arguments that are file
16 names. A file name is a string. Most of these functions expand file
17 name arguments using the function @code{expand-file-name}, so that
18 @file{~} is handled correctly, as are relative file names (including
19 @file{../}). @xref{File Name Expansion}.
21 In addition, certain @dfn{magic} file names are handled specially.
22 For example, when a remote file name is specified, Emacs accesses the
23 file over the network via an appropriate protocol. @xref{Remote
24 Files,, Remote Files, emacs, The GNU Emacs Manual}. This handling is
25 done at a very low level, so you may assume that all the functions
26 described in this chapter accept magic file names as file name
27 arguments, except where noted. @xref{Magic File Names}, for details.
29 When file I/O functions signal Lisp errors, they usually use the
30 condition @code{file-error} (@pxref{Handling Errors}). The error
31 message is in most cases obtained from the operating system, according
32 to locale @code{system-messages-locale}, and decoded using coding system
33 @code{locale-coding-system} (@pxref{Locales}).
36 * Visiting Files:: Reading files into Emacs buffers for editing.
37 * Saving Buffers:: Writing changed buffers back into files.
38 * Reading from Files:: Reading files into buffers without visiting.
39 * Writing to Files:: Writing new files from parts of buffers.
40 * File Locks:: Locking and unlocking files, to prevent
41 simultaneous editing by two people.
42 * Information about Files:: Testing existence, accessibility, size of files.
43 * Changing Files:: Renaming files, changing permissions, etc.
44 * Files and Storage:: Surviving power and media failures
45 * File Names:: Decomposing and expanding file names.
46 * Contents of Directories:: Getting a list of the files in a directory.
47 * Create/Delete Dirs:: Creating and Deleting Directories.
48 * Magic File Names:: Special handling for certain file names.
49 * Format Conversion:: Conversion to and from various file formats.
53 @section Visiting Files
55 @cindex visiting files
57 Visiting a file means reading a file into a buffer. Once this is
58 done, we say that the buffer is @dfn{visiting} that file, and call the
59 file @dfn{the visited file} of the buffer.
61 A file and a buffer are two different things. A file is information
62 recorded permanently in the computer (unless you delete it). A
63 buffer, on the other hand, is information inside of Emacs that will
64 vanish at the end of the editing session (or when you kill the
65 buffer). When a buffer is visiting a file, it contains information
66 copied from the file. The copy in the buffer is what you modify with
67 editing commands. Changes to the buffer do not change the file; to
68 make the changes permanent, you must @dfn{save} the buffer, which
69 means copying the altered buffer contents back into the file.
71 Despite the distinction between files and buffers, people often
72 refer to a file when they mean a buffer and vice-versa. Indeed, we
73 say, ``I am editing a file'', rather than, ``I am editing a buffer
74 that I will soon save as a file of the same name''. Humans do not
75 usually need to make the distinction explicit. When dealing with a
76 computer program, however, it is good to keep the distinction in mind.
79 * Visiting Functions:: The usual interface functions for visiting.
80 * Subroutines of Visiting:: Lower-level subroutines that they use.
83 @node Visiting Functions
84 @subsection Functions for Visiting Files
85 @cindex visiting files, functions for
86 @cindex how to visit files
88 This section describes the functions normally used to visit files.
89 For historical reasons, these functions have names starting with
90 @samp{find-} rather than @samp{visit-}. @xref{Buffer File Name}, for
91 functions and variables that access the visited file name of a buffer or
92 that find an existing buffer by its visited file name.
94 In a Lisp program, if you want to look at the contents of a file but
95 not alter it, the fastest way is to use @code{insert-file-contents} in a
96 temporary buffer. Visiting the file is not necessary and takes longer.
97 @xref{Reading from Files}.
99 @deffn Command find-file filename &optional wildcards
100 This command selects a buffer visiting the file @var{filename},
101 using an existing buffer if there is one, and otherwise creating a
102 new buffer and reading the file into it. It also returns that buffer.
104 Aside from some technical details, the body of the @code{find-file}
105 function is basically equivalent to:
108 (switch-to-buffer (find-file-noselect filename nil nil wildcards))
112 (See @code{switch-to-buffer} in @ref{Switching Buffers}.)
114 If @var{wildcards} is non-@code{nil}, which is always true in an
115 interactive call, then @code{find-file} expands wildcard characters in
116 @var{filename} and visits all the matching files.
118 When @code{find-file} is called interactively, it prompts for
119 @var{filename} in the minibuffer.
122 @deffn Command find-file-literally filename
123 This command visits @var{filename}, like @code{find-file} does, but it
124 does not perform any format conversions (@pxref{Format Conversion}),
125 character code conversions (@pxref{Coding Systems}), or end-of-line
126 conversions (@pxref{Coding System Basics, End of line conversion}).
127 The buffer visiting the file is made unibyte, and its major mode is
128 Fundamental mode, regardless of the file name. File local variable
129 specifications in the file (@pxref{File Local Variables}) are
130 ignored, and automatic decompression and adding a newline at the end
131 of the file due to @code{require-final-newline} (@pxref{Saving
132 Buffers, require-final-newline}) are also disabled.
134 Note that if Emacs already has a buffer visiting the same file
135 non-literally, it will not visit the same file literally, but instead
136 just switch to the existing buffer. If you want to be sure of
137 accessing a file's contents literally, you should create a temporary
138 buffer and then read the file contents into it using
139 @code{insert-file-contents-literally} (@pxref{Reading from Files}).
142 @defun find-file-noselect filename &optional nowarn rawfile wildcards
143 This function is the guts of all the file-visiting functions. It
144 returns a buffer visiting the file @var{filename}. You may make the
145 buffer current or display it in a window if you wish, but this
146 function does not do so.
148 The function returns an existing buffer if there is one; otherwise it
149 creates a new buffer and reads the file into it. When
150 @code{find-file-noselect} uses an existing buffer, it first verifies
151 that the file has not changed since it was last visited or saved in
152 that buffer. If the file has changed, this function asks the user
153 whether to reread the changed file. If the user says @samp{yes}, any
154 edits previously made in the buffer are lost.
156 Reading the file involves decoding the file's contents (@pxref{Coding
157 Systems}), including end-of-line conversion, and format conversion
158 (@pxref{Format Conversion}). If @var{wildcards} is non-@code{nil},
159 then @code{find-file-noselect} expands wildcard characters in
160 @var{filename} and visits all the matching files.
162 This function displays warning or advisory messages in various peculiar
163 cases, unless the optional argument @var{nowarn} is non-@code{nil}. For
164 example, if it needs to create a buffer, and there is no file named
165 @var{filename}, it displays the message @samp{(New file)} in the echo
166 area, and leaves the buffer empty.
168 The @code{find-file-noselect} function normally calls
169 @code{after-find-file} after reading the file (@pxref{Subroutines of
170 Visiting}). That function sets the buffer major mode, parses local
171 variables, warns the user if there exists an auto-save file more recent
172 than the file just visited, and finishes by running the functions in
173 @code{find-file-hook}.
175 If the optional argument @var{rawfile} is non-@code{nil}, then
176 @code{after-find-file} is not called, and the
177 @code{find-file-not-found-functions} are not run in case of failure.
178 What's more, a non-@code{nil} @var{rawfile} value suppresses coding
179 system conversion and format conversion.
181 The @code{find-file-noselect} function usually returns the buffer that
182 is visiting the file @var{filename}. But, if wildcards are actually
183 used and expanded, it returns a list of buffers that are visiting the
188 (find-file-noselect "/etc/fstab")
189 @result{} #<buffer fstab>
194 @deffn Command find-file-other-window filename &optional wildcards
195 This command selects a buffer visiting the file @var{filename}, but
196 does so in a window other than the selected window. It may use
197 another existing window or split a window; see @ref{Switching
200 When this command is called interactively, it prompts for
204 @deffn Command find-file-read-only filename &optional wildcards
205 This command selects a buffer visiting the file @var{filename}, like
206 @code{find-file}, but it marks the buffer as read-only. @xref{Read Only
207 Buffers}, for related functions and variables.
209 When this command is called interactively, it prompts for
213 @defopt find-file-wildcards
214 If this variable is non-@code{nil}, then the various @code{find-file}
215 commands check for wildcard characters and visit all the files that
216 match them (when invoked interactively or when their @var{wildcards}
217 argument is non-@code{nil}). If this option is @code{nil}, then
218 the @code{find-file} commands ignore their @var{wildcards} argument
219 and never treat wildcard characters specially.
222 @defopt find-file-hook
223 The value of this variable is a list of functions to be called after a
224 file is visited. The file's local-variables specification (if any) will
225 have been processed before the hooks are run. The buffer visiting the
226 file is current when the hook functions are run.
228 This variable is a normal hook. @xref{Hooks}.
231 @defvar find-file-not-found-functions
232 The value of this variable is a list of functions to be called when
233 @code{find-file} or @code{find-file-noselect} is passed a nonexistent
234 file name. @code{find-file-noselect} calls these functions as soon as
235 it detects a nonexistent file. It calls them in the order of the list,
236 until one of them returns non-@code{nil}. @code{buffer-file-name} is
239 This is not a normal hook because the values of the functions are
240 used, and in many cases only some of the functions are called.
243 @defvar find-file-literally
244 This buffer-local variable, if set to a non-@code{nil} value, makes
245 @code{save-buffer} behave as if the buffer were visiting its file
246 literally, i.e., without conversions of any kind. The command
247 @code{find-file-literally} sets this variable's local value, but other
248 equivalent functions and commands can do that as well, e.g., to avoid
249 automatic addition of a newline at the end of the file. This variable
250 is permanent local, so it is unaffected by changes of major modes.
253 @node Subroutines of Visiting
254 @subsection Subroutines of Visiting
256 The @code{find-file-noselect} function uses two important subroutines
257 which are sometimes useful in user Lisp code: @code{create-file-buffer}
258 and @code{after-find-file}. This section explains how to use them.
260 @c FIXME This does not describe the default behavior, because
261 @c uniquify is enabled by default and advises this function.
262 @c This is confusing. uniquify should be folded into the function proper.
263 @defun create-file-buffer filename
264 This function creates a suitably named buffer for visiting
265 @var{filename}, and returns it. It uses @var{filename} (sans directory)
266 as the name if that name is free; otherwise, it appends a string such as
267 @samp{<2>} to get an unused name. See also @ref{Creating Buffers}.
268 Note that the @file{uniquify} library affects the result of this
269 function. @xref{Uniquify,,, emacs, The GNU Emacs Manual}.
271 @strong{Please note:} @code{create-file-buffer} does @emph{not}
272 associate the new buffer with a file and does not select the buffer.
273 It also does not use the default major mode.
277 (create-file-buffer "foo")
278 @result{} #<buffer foo>
281 (create-file-buffer "foo")
282 @result{} #<buffer foo<2>>
285 (create-file-buffer "foo")
286 @result{} #<buffer foo<3>>
290 This function is used by @code{find-file-noselect}.
291 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
294 @defun after-find-file &optional error warn noauto after-find-file-from-revert-buffer nomodes
295 This function sets the buffer major mode, and parses local variables
296 (@pxref{Auto Major Mode}). It is called by @code{find-file-noselect}
297 and by the default revert function (@pxref{Reverting}).
299 @cindex new file message
300 @cindex file open error
301 If reading the file got an error because the file does not exist, but
302 its directory does exist, the caller should pass a non-@code{nil} value
303 for @var{error}. In that case, @code{after-find-file} issues a warning:
304 @samp{(New file)}. For more serious errors, the caller should usually not
305 call @code{after-find-file}.
307 If @var{warn} is non-@code{nil}, then this function issues a warning
308 if an auto-save file exists and is more recent than the visited file.
310 If @var{noauto} is non-@code{nil}, that says not to enable or disable
311 Auto-Save mode. The mode remains enabled if it was enabled before.
313 If @var{after-find-file-from-revert-buffer} is non-@code{nil}, that
314 means this call was from @code{revert-buffer}. This has no direct
315 effect, but some mode functions and hook functions check the value
318 If @var{nomodes} is non-@code{nil}, that means don't alter the buffer's
319 major mode, don't process local variables specifications in the file,
320 and don't run @code{find-file-hook}. This feature is used by
321 @code{revert-buffer} in some cases.
323 The last thing @code{after-find-file} does is call all the functions
324 in the list @code{find-file-hook}.
328 @section Saving Buffers
329 @cindex saving buffers
331 When you edit a file in Emacs, you are actually working on a buffer
332 that is visiting that file---that is, the contents of the file are
333 copied into the buffer and the copy is what you edit. Changes to the
334 buffer do not change the file until you @dfn{save} the buffer, which
335 means copying the contents of the buffer into the file. Buffers which
336 are not visiting a file can still be ``saved'', in a sense, using
337 functions in the buffer-local @code{write-contents-functions} hook.
339 @deffn Command save-buffer &optional backup-option
340 This function saves the contents of the current buffer in its visited
341 file if the buffer has been modified since it was last visited or saved.
342 Otherwise it does nothing.
344 @code{save-buffer} is responsible for making backup files. Normally,
345 @var{backup-option} is @code{nil}, and @code{save-buffer} makes a backup
346 file only if this is the first save since visiting the file. Other
347 values for @var{backup-option} request the making of backup files in
352 With an argument of 4 or 64, reflecting 1 or 3 @kbd{C-u}'s, the
353 @code{save-buffer} function marks this version of the file to be
354 backed up when the buffer is next saved.
357 With an argument of 16 or 64, reflecting 2 or 3 @kbd{C-u}'s, the
358 @code{save-buffer} function unconditionally backs up the previous
359 version of the file before saving it.
362 With an argument of 0, unconditionally do @emph{not} make any backup file.
366 @deffn Command save-some-buffers &optional save-silently-p pred
367 @anchor{Definition of save-some-buffers}
368 This command saves some modified file-visiting buffers. Normally it
369 asks the user about each buffer. But if @var{save-silently-p} is
370 non-@code{nil}, it saves all the file-visiting buffers without
373 @vindex save-some-buffers-default-predicate
374 The optional @var{pred} argument provides a predicate that controls
375 which buffers to ask about (or to save silently if
376 @var{save-silently-p} is non-@code{nil}). If @var{pred} is
377 @code{nil}, that means to use the value of
378 @code{save-some-buffers-default-predicate} instead of @var{pred}. If
379 the result is @code{nil}, it means ask only about file-visiting
380 buffers. If it is @code{t}, that means also offer to save certain
381 other non-file buffers---those that have a non-@code{nil} buffer-local
382 value of @code{buffer-offer-save} (@pxref{Killing Buffers}). A user
383 who says @samp{yes} to saving a non-file buffer is asked to specify
384 the file name to use. The @code{save-buffers-kill-emacs} function
385 passes the value @code{t} for @var{pred}.
387 If the predicate is neither @code{t} nor @code{nil}, then it should be
388 a function of no arguments. It will be called in each buffer to decide
389 whether to offer to save that buffer. If it returns a non-@code{nil}
390 value in a certain buffer, that means do offer to save that buffer.
393 @deffn Command write-file filename &optional confirm
394 @anchor{Definition of write-file}
395 This function writes the current buffer into file @var{filename}, makes
396 the buffer visit that file, and marks it not modified. Then it renames
397 the buffer based on @var{filename}, appending a string like @samp{<2>}
398 if necessary to make a unique buffer name. It does most of this work by
399 calling @code{set-visited-file-name} (@pxref{Buffer File Name}) and
402 If @var{confirm} is non-@code{nil}, that means to ask for confirmation
403 before overwriting an existing file. Interactively, confirmation is
404 required, unless the user supplies a prefix argument.
406 If @var{filename} is a directory name (@pxref{Directory Names}),
407 @code{write-file} uses the name of the visited file, in directory
408 @var{filename}. If the buffer is not visiting a file, it uses the
412 Saving a buffer runs several hooks. It also performs format
413 conversion (@pxref{Format Conversion}). Note that these hooks,
414 described below, are only run by @code{save-buffer}, they are not run
415 by other primitives and functions that write buffer text to files, and
416 in particular auto-saving (@pxref{Auto-Saving}) doesn't run these
419 @defvar write-file-functions
420 The value of this variable is a list of functions to be called before
421 writing out a buffer to its visited file. If one of them returns
422 non-@code{nil}, the file is considered already written and the rest of
423 the functions are not called, nor is the usual code for writing the file
426 If a function in @code{write-file-functions} returns non-@code{nil}, it
427 is responsible for making a backup file (if that is appropriate).
428 To do so, execute the following code:
431 (or buffer-backed-up (backup-buffer))
434 You might wish to save the file modes value returned by
435 @code{backup-buffer} and use that (if non-@code{nil}) to set the mode
436 bits of the file that you write. This is what @code{save-buffer}
437 normally does. @xref{Making Backups,, Making Backup Files}.
439 The hook functions in @code{write-file-functions} are also responsible
440 for encoding the data (if desired): they must choose a suitable coding
441 system and end-of-line conversion (@pxref{Lisp and Coding Systems}),
442 perform the encoding (@pxref{Explicit Encoding}), and set
443 @code{last-coding-system-used} to the coding system that was used
444 (@pxref{Encoding and I/O}).
446 If you set this hook locally in a buffer, it is assumed to be
447 associated with the file or the way the contents of the buffer were
448 obtained. Thus the variable is marked as a permanent local, so that
449 changing the major mode does not alter a buffer-local value. On the
450 other hand, calling @code{set-visited-file-name} will reset it.
451 If this is not what you want, you might like to use
452 @code{write-contents-functions} instead.
454 Even though this is not a normal hook, you can use @code{add-hook} and
455 @code{remove-hook} to manipulate the list. @xref{Hooks}.
459 @defvar write-contents-functions
460 This works just like @code{write-file-functions}, but it is intended
461 for hooks that pertain to the buffer's contents, not to the particular
462 visited file or its location, and can be used to create arbitrary save
463 processes for buffers that aren't visiting files at all. Such hooks
464 are usually set up by major modes, as buffer-local bindings for this
465 variable. This variable automatically becomes buffer-local whenever
466 it is set; switching to a new major mode always resets this variable,
467 but calling @code{set-visited-file-name} does not.
469 If any of the functions in this hook returns non-@code{nil}, the file
470 is considered already written and the rest are not called and neither
471 are the functions in @code{write-file-functions}.
473 When using this hook to save buffers that are not visiting files (for
474 instance, special-mode buffers), keep in mind that, if the function
475 fails to save correctly and returns a @code{nil} value,
476 @code{save-buffer} will go on to prompt the user for a file to save
477 the buffer in. If this is undesirable, consider having the function
478 fail by raising an error.
481 @defopt before-save-hook
482 This normal hook runs before a buffer is saved in its visited file,
483 regardless of whether that is done normally or by one of the hooks
484 described above. For instance, the @file{copyright.el} program uses
485 this hook to make sure the file you are saving has the current year in
486 its copyright notice.
490 @defopt after-save-hook
491 This normal hook runs after a buffer has been saved in its visited file.
492 One use of this hook is in Fast Lock mode; it uses this hook to save the
493 highlighting information in a cache file.
496 @defopt file-precious-flag
497 If this variable is non-@code{nil}, then @code{save-buffer} protects
498 against I/O errors while saving by writing the new file to a temporary
499 name instead of the name it is supposed to have, and then renaming it to
500 the intended name after it is clear there are no errors. This procedure
501 prevents problems such as a lack of disk space from resulting in an
504 As a side effect, backups are necessarily made by copying. @xref{Rename
505 or Copy}. Yet, at the same time, saving a precious file always breaks
506 all hard links between the file you save and other file names.
508 Some modes give this variable a non-@code{nil} buffer-local value
509 in particular buffers.
512 @defopt require-final-newline
513 This variable determines whether files may be written out that do
514 @emph{not} end with a newline. If the value of the variable is
515 @code{t}, then @code{save-buffer} silently adds a newline at the end
516 of the buffer whenever it does not already end in one. If the value
517 is @code{visit}, Emacs adds a missing newline just after it visits the
518 file. If the value is @code{visit-save}, Emacs adds a missing newline
519 both on visiting and on saving. For any other non-@code{nil} value,
520 @code{save-buffer} asks the user whether to add a newline each time
523 If the value of the variable is @code{nil}, then @code{save-buffer}
524 doesn't add newlines at all. @code{nil} is the default value, but a few
525 major modes set it to @code{t} in particular buffers.
528 See also the function @code{set-visited-file-name} (@pxref{Buffer File
531 @node Reading from Files
532 @section Reading from Files
533 @cindex reading from files
535 To copy the contents of a file into a buffer, use the function
536 @code{insert-file-contents}. (Don't use the command
537 @code{insert-file} in a Lisp program, as that sets the mark.)
539 @defun insert-file-contents filename &optional visit beg end replace
540 This function inserts the contents of file @var{filename} into the
541 current buffer after point. It returns a list of the absolute file name
542 and the length of the data inserted. An error is signaled if
543 @var{filename} is not the name of a file that can be read.
545 This function checks the file contents against the defined file
546 formats, and converts the file contents if appropriate and also calls
547 the functions in the list @code{after-insert-file-functions}.
548 @xref{Format Conversion}. Normally, one of the functions in the
549 @code{after-insert-file-functions} list determines the coding system
550 (@pxref{Coding Systems}) used for decoding the file's contents,
551 including end-of-line conversion. However, if the file contains null
552 bytes, it is by default visited without any code conversions.
553 @xref{Lisp and Coding Systems, inhibit-null-byte-detection}.
555 If @var{visit} is non-@code{nil}, this function additionally marks the
556 buffer as unmodified and sets up various fields in the buffer so that it
557 is visiting the file @var{filename}: these include the buffer's visited
558 file name and its last save file modtime. This feature is used by
559 @code{find-file-noselect} and you probably should not use it yourself.
561 If @var{beg} and @var{end} are non-@code{nil}, they should be numbers
562 that are byte offsets specifying the portion of the file to insert.
563 In this case, @var{visit} must be @code{nil}. For example,
566 (insert-file-contents filename nil 0 500)
570 inserts the first 500 characters of a file.
572 If the argument @var{replace} is non-@code{nil}, it means to replace the
573 contents of the buffer (actually, just the accessible portion) with the
574 contents of the file. This is better than simply deleting the buffer
575 contents and inserting the whole file, because (1) it preserves some
576 marker positions and (2) it puts less data in the undo list.
578 It is possible to read a special file (such as a FIFO or an I/O device)
579 with @code{insert-file-contents}, as long as @var{replace} and
580 @var{visit} are @code{nil}.
583 @defun insert-file-contents-literally filename &optional visit beg end replace
584 This function works like @code{insert-file-contents} except that it
585 does not run @code{find-file-hook}, and does not do format decoding,
586 character code conversion, automatic uncompression, and so on.
589 If you want to pass a file name to another process so that another
590 program can read the file, use the function @code{file-local-copy}; see
591 @ref{Magic File Names}.
593 @node Writing to Files
594 @section Writing to Files
595 @cindex writing to files
597 You can write the contents of a buffer, or part of a buffer, directly
598 to a file on disk using the @code{append-to-file} and
599 @code{write-region} functions. Don't use these functions to write to
600 files that are being visited; that could cause confusion in the
601 mechanisms for visiting.
603 @deffn Command append-to-file start end filename
604 This function appends the contents of the region delimited by
605 @var{start} and @var{end} in the current buffer to the end of file
606 @var{filename}. If that file does not exist, it is created. This
607 function returns @code{nil}.
609 An error is signaled if @var{filename} specifies a nonwritable file,
610 or a nonexistent file in a directory where files cannot be created.
612 When called from Lisp, this function is completely equivalent to:
615 (write-region start end filename t)
619 @deffn Command write-region start end filename &optional append visit lockname mustbenew
620 This function writes the region delimited by @var{start} and @var{end}
621 in the current buffer into the file specified by @var{filename}.
623 If @var{start} is @code{nil}, then the command writes the entire buffer
624 contents (@emph{not} just the accessible portion) to the file and
628 If @var{start} is a string, then @code{write-region} writes or appends
629 that string, rather than text from the buffer. @var{end} is ignored in
632 If @var{append} is non-@code{nil}, then the specified text is appended
633 to the existing file contents (if any). If @var{append} is a
634 number, @code{write-region} seeks to that byte offset from the start
635 of the file and writes the data from there.
637 If @var{mustbenew} is non-@code{nil}, then @code{write-region} asks
638 for confirmation if @var{filename} names an existing file. If
639 @var{mustbenew} is the symbol @code{excl}, then @code{write-region}
640 does not ask for confirmation, but instead it signals an error
641 @code{file-already-exists} if the file already exists. Although
642 @code{write-region} normally follows a symbolic link and creates the
643 pointed-to file if the symbolic link is dangling, it does not follow
644 symbolic links if @var{mustbenew} is @code{excl}.
646 The test for an existing file, when @var{mustbenew} is @code{excl}, uses
647 a special system feature. At least for files on a local disk, there is
648 no chance that some other program could create a file of the same name
649 before Emacs does, without Emacs's noticing.
651 If @var{visit} is @code{t}, then Emacs establishes an association
652 between the buffer and the file: the buffer is then visiting that file.
653 It also sets the last file modification time for the current buffer to
654 @var{filename}'s modtime, and marks the buffer as not modified. This
655 feature is used by @code{save-buffer}, but you probably should not use
659 If @var{visit} is a string, it specifies the file name to visit. This
660 way, you can write the data to one file (@var{filename}) while recording
661 the buffer as visiting another file (@var{visit}). The argument
662 @var{visit} is used in the echo area message and also for file locking;
663 @var{visit} is stored in @code{buffer-file-name}. This feature is used
664 to implement @code{file-precious-flag}; don't use it yourself unless you
665 really know what you're doing.
667 The optional argument @var{lockname}, if non-@code{nil}, specifies the
668 file name to use for purposes of locking and unlocking, overriding
669 @var{filename} and @var{visit} for that purpose.
671 The function @code{write-region} converts the data which it writes to
672 the appropriate file formats specified by @code{buffer-file-format}
673 and also calls the functions in the list
674 @code{write-region-annotate-functions}.
675 @xref{Format Conversion}.
677 Normally, @code{write-region} displays the message @samp{Wrote
678 @var{filename}} in the echo area. This message is inhibited if
679 @var{visit} is neither @code{t} nor @code{nil} nor a string, or if
680 Emacs is operating in batch mode (@pxref{Batch Mode}). This
681 feature is useful for programs that use files for internal purposes,
682 files that the user does not need to know about.
685 @defvar write-region-inhibit-fsync
686 If this variable's value is @code{nil}, @code{write-region} uses the
687 @code{fsync} system call after writing a file. Although this slows
688 Emacs down, it lessens the risk of data loss after power failure. If
689 the value is @code{t}, Emacs does not use @code{fsync}. The default
690 value is @code{nil} when Emacs is interactive, and @code{t} when Emacs
691 runs in batch mode. @xref{Files and Storage}.
694 @defmac with-temp-file file body@dots{}
695 @anchor{Definition of with-temp-file}
696 The @code{with-temp-file} macro evaluates the @var{body} forms with a
697 temporary buffer as the current buffer; then, at the end, it writes the
698 buffer contents into file @var{file}. It kills the temporary buffer
699 when finished, restoring the buffer that was current before the
700 @code{with-temp-file} form. Then it returns the value of the last form
703 The current buffer is restored even in case of an abnormal exit via
704 @code{throw} or error (@pxref{Nonlocal Exits}).
706 See also @code{with-temp-buffer} in @ref{Definition of
707 with-temp-buffer,, The Current Buffer}.
715 When two users edit the same file at the same time, they are likely
716 to interfere with each other. Emacs tries to prevent this situation
717 from arising by recording a @dfn{file lock} when a file is being
719 Emacs can then detect the first attempt to modify a buffer visiting a
720 file that is locked by another Emacs job, and ask the user what to do.
721 The file lock is really a file, a symbolic link with a special name,
722 stored in the same directory as the file you are editing. (On file
723 systems that do not support symbolic links, a regular file is used.)
725 When you access files using NFS, there may be a small probability that
726 you and another user will both lock the same file simultaneously.
727 If this happens, it is possible for the two users to make changes
728 simultaneously, but Emacs will still warn the user who saves second.
729 Also, the detection of modification of a buffer visiting a file changed
730 on disk catches some cases of simultaneous editing; see
731 @ref{Modification Time}.
733 @defun file-locked-p filename
734 This function returns @code{nil} if the file @var{filename} is not
735 locked. It returns @code{t} if it is locked by this Emacs process, and
736 it returns the name of the user who has locked it if it is locked by
741 (file-locked-p "foo")
747 @defun lock-buffer &optional filename
748 This function locks the file @var{filename}, if the current buffer is
749 modified. The argument @var{filename} defaults to the current buffer's
750 visited file. Nothing is done if the current buffer is not visiting a
751 file, or is not modified, or if the option @code{create-lockfiles} is
756 This function unlocks the file being visited in the current buffer,
757 if the buffer is modified. If the buffer is not modified, then
758 the file should not be locked, so this function does nothing. It also
759 does nothing if the current buffer is not visiting a file, or is not locked.
762 @defopt create-lockfiles
763 If this variable is @code{nil}, Emacs does not lock files.
766 @defun ask-user-about-lock file other-user
767 This function is called when the user tries to modify @var{file}, but it
768 is locked by another user named @var{other-user}. The default
769 definition of this function asks the user to say what to do. The value
770 this function returns determines what Emacs does next:
774 A value of @code{t} says to grab the lock on the file. Then
775 this user may edit the file and @var{other-user} loses the lock.
778 A value of @code{nil} says to ignore the lock and let this
779 user edit the file anyway.
783 This function may instead signal a @code{file-locked} error, in which
784 case the change that the user was about to make does not take place.
786 The error message for this error looks like this:
789 @error{} File is locked: @var{file} @var{other-user}
793 where @code{file} is the name of the file and @var{other-user} is the
794 name of the user who has locked the file.
797 If you wish, you can replace the @code{ask-user-about-lock} function
798 with your own version that makes the decision in another way.
801 @node Information about Files
802 @section Information about Files
803 @cindex file, information about
805 This section describes the functions for retrieving various types of
806 information about files (or directories or symbolic links), such as
807 whether a file is readable or writable, and its size. These functions
808 all take arguments which are file names. Except where noted, these
809 arguments need to specify existing files, or an error is signaled.
811 @cindex file names, trailing whitespace
812 @cindex trailing blanks in file names
813 Be careful with file names that end in spaces. On some filesystems
814 (notably, MS-Windows), trailing whitespace characters in file names
815 are silently and automatically ignored.
818 * Testing Accessibility:: Is a given file readable? Writable?
819 * Kinds of Files:: Is it a directory? A symbolic link?
820 * Truenames:: Eliminating symbolic links from a file name.
821 * File Attributes:: File sizes, modification times, etc.
822 * Extended Attributes:: Extended file attributes for access control.
823 * Locating Files:: How to find a file in standard places.
826 @node Testing Accessibility
827 @subsection Testing Accessibility
828 @cindex accessibility of a file
829 @cindex file accessibility
831 These functions test for permission to access a file for reading,
832 writing, or execution. Unless explicitly stated otherwise, they
833 follow symbolic links. @xref{Kinds of Files}.
835 On some operating systems, more complex sets of access permissions
836 can be specified, via mechanisms such as Access Control Lists (ACLs).
837 @xref{Extended Attributes}, for how to query and set those
840 @defun file-exists-p filename
841 This function returns @code{t} if a file named @var{filename} appears
842 to exist. This does not mean you can necessarily read the file, only
843 that you can find out its attributes. (On GNU and other POSIX-like
844 systems, this is true if the file exists and you have execute
845 permission on the containing directories, regardless of the
846 permissions of the file itself.)
848 If the file does not exist, or if access control policies prevent you
849 from finding its attributes, this function returns @code{nil}.
851 Directories are files, so @code{file-exists-p} can return @code{t} when
852 given a directory. However, because @code{file-exists-p} follows
853 symbolic links, it returns @code{t} for a symbolic link
854 name only if the target file exists.
857 @defun file-readable-p filename
858 This function returns @code{t} if a file named @var{filename} exists
859 and you can read it. It returns @code{nil} otherwise.
862 @defun file-executable-p filename
863 This function returns @code{t} if a file named @var{filename} exists
864 and you can execute it. It returns @code{nil} otherwise. On GNU and
865 other POSIX-like systems, if the file is a directory, execute
866 permission means you can check the existence and attributes of files
867 inside the directory, and open those files if their modes permit.
870 @defun file-writable-p filename
871 This function returns @code{t} if the file @var{filename} can be written
872 or created by you, and @code{nil} otherwise. A file is writable if the
873 file exists and you can write it. It is creatable if it does not exist,
874 but the specified directory does exist and you can write in that
877 In the example below, @file{foo} is not writable because the parent
878 directory does not exist, even though the user could create such a
883 (file-writable-p "~/no-such-dir/foo")
889 @defun file-accessible-directory-p dirname
890 This function returns @code{t} if you have permission to open existing
891 files in the directory whose name as a file is @var{dirname};
892 otherwise (or if there is no such directory), it returns @code{nil}.
893 The value of @var{dirname} may be either a directory name (such as
894 @file{/foo/}) or the file name of a file which is a directory
895 (such as @file{/foo}, without the final slash).
897 For example, from the following we deduce that any attempt to read a
898 file in @file{/foo/} will give an error:
901 (file-accessible-directory-p "/foo")
906 @defun access-file filename string
907 This function opens file @var{filename} for reading, then closes it and
908 returns @code{nil}. However, if the open fails, it signals an error
909 using @var{string} as the error message text.
912 @defun file-ownership-preserved-p filename &optional group
913 This function returns @code{t} if deleting the file @var{filename} and
914 then creating it anew would keep the file's owner unchanged. It also
915 returns @code{t} for nonexistent files.
917 If the optional argument @var{group} is non-@code{nil}, this function
918 also checks that the file's group would be unchanged.
920 This function does not follow symbolic links.
923 @defun file-modes filename
925 @cindex file permissions
926 @cindex permissions, file
928 This function returns the @dfn{mode bits} of @var{filename}---an
929 integer summarizing its read, write, and execution permissions.
930 This function follows symbolic links. If the file does not exist, the
931 return value is @code{nil}.
933 @xref{File permissions,,, coreutils, The @sc{gnu} @code{Coreutils}
934 Manual}, for a description of mode bits. For example, if the
935 low-order bit is 1, the file is executable by all users; if the
936 second-lowest-order bit is 1, the file is writable by all users; etc.
937 The highest possible value is 4095 (7777 octal), meaning that everyone
938 has read, write, and execute permission, the @acronym{SUID} bit is set
939 for both others and group, and the sticky bit is set.
941 @xref{Changing Files}, for the @code{set-file-modes} function, which
942 can be used to set these permissions.
946 (file-modes "~/junk/diffs")
947 @result{} 492 ; @r{Decimal integer.}
951 @result{} "754" ; @r{Convert to octal.}
955 (set-file-modes "~/junk/diffs" #o666)
961 -rw-rw-rw- 1 lewis lewis 3063 Oct 30 16:00 diffs
965 @cindex MS-DOS and file modes
966 @cindex file modes and MS-DOS
967 @strong{MS-DOS note:} On MS-DOS, there is no such thing as an
968 executable file mode bit. So @code{file-modes} considers a file
969 executable if its name ends in one of the standard executable
970 extensions, such as @file{.com}, @file{.bat}, @file{.exe}, and some
971 others. Files that begin with the POSIX-standard @samp{#!} signature,
972 such as shell and Perl scripts, are also considered executable.
973 Directories are also reported as executable, for compatibility with
974 POSIX@. These conventions are also followed by @code{file-attributes}
975 (@pxref{File Attributes}).
979 @subsection Distinguishing Kinds of Files
980 @cindex file classification
981 @cindex classification of file types
982 @cindex symbolic links
984 This section describes how to distinguish various kinds of files, such
985 as directories, symbolic links, and ordinary files.
987 Symbolic links are ordinarily followed wherever they appear. For
988 example, to interpret the file name @file{a/b/c}, any of @file{a},
989 @file{a/b}, and @file{a/b/c} can be symbolic links that are followed,
990 possibly recursively if the link targets are themselves symbolic
991 links. However, a few functions do not follow symbolic links at the
992 end of a file name (@file{a/b/c} in this example). Such a function
993 is said to @dfn{not follow symbolic links}.
995 @defun file-symlink-p filename
996 @cindex symbolic links
997 If the file @var{filename} is a symbolic link, this function does not
998 follow it and instead returns its link target
999 as a string. (The link target string is not necessarily the full
1000 absolute file name of the target; determining the full file name that
1001 the link points to is nontrivial, see below.)
1003 If the file @var{filename} is not a symbolic link, or does not exist,
1004 @code{file-symlink-p} returns @code{nil}.
1006 Here are a few examples of using this function:
1010 (file-symlink-p "not-a-symlink")
1014 (file-symlink-p "sym-link")
1015 @result{} "not-a-symlink"
1018 (file-symlink-p "sym-link2")
1019 @result{} "sym-link"
1022 (file-symlink-p "/bin")
1023 @result{} "/pub/bin"
1027 Note that in the third example, the function returned @file{sym-link},
1028 but did not proceed to resolve it, although that file is itself a
1029 symbolic link. That is because this function does not follow symbolic
1030 links---the process of following the symbolic links does not apply to
1031 the last component of the file name.
1033 The string that this function returns is what is recorded in the
1034 symbolic link; it may or may not include any leading directories.
1035 This function does @emph{not} expand the link target to produce a
1036 fully-qualified file name, and in particular does not use the leading
1037 directories, if any, of the @var{filename} argument if the link target
1038 is not an absolute file name. Here's an example:
1042 (file-symlink-p "/foo/bar/baz")
1043 @result{} "some-file"
1048 Here, although @file{/foo/bar/baz} was given as a fully-qualified file
1049 name, the result is not, and in fact does not have any leading
1050 directories at all. And since @file{some-file} might itself be a
1051 symbolic link, you cannot simply prepend leading directories to it,
1052 nor even naively use @code{expand-file-name} (@pxref{File Name
1053 Expansion}) to produce its absolute file name.
1055 For this reason, this function is seldom useful if you need to
1056 determine more than just the fact that a file is or isn't a symbolic
1057 link. If you actually need the file name of the link target, use
1058 @code{file-chase-links} or @code{file-truename}, described in
1062 @defun file-directory-p filename
1063 This function returns @code{t} if @var{filename} is the name of an
1064 existing directory, @code{nil} otherwise.
1065 This function follows symbolic links.
1069 (file-directory-p "~rms")
1073 (file-directory-p "~rms/lewis/files.texi")
1077 (file-directory-p "~rms/lewis/no-such-file")
1081 (file-directory-p "$HOME")
1086 (substitute-in-file-name "$HOME"))
1092 @defun file-regular-p filename
1093 This function returns @code{t} if the file @var{filename} exists and is
1094 a regular file (not a directory, named pipe, terminal, or
1096 This function follows symbolic links.
1100 @subsection Truenames
1101 @cindex truename (of file)
1103 The @dfn{truename} of a file is the name that you get by following
1104 symbolic links at all levels until none remain, then simplifying away
1105 @samp{.}@: and @samp{..}@: appearing as name components. This results
1106 in a sort of canonical name for the file. A file does not always have a
1107 unique truename; the number of distinct truenames a file has is equal to
1108 the number of hard links to the file. However, truenames are useful
1109 because they eliminate symbolic links as a cause of name variation.
1111 @defun file-truename filename
1112 This function returns the truename of the file @var{filename}. If the
1113 argument is not an absolute file name, this function first expands it
1114 against @code{default-directory}.
1116 This function does not expand environment variables. Only
1117 @code{substitute-in-file-name} does that. @xref{Definition of
1118 substitute-in-file-name}.
1120 If you may need to follow symbolic links preceding @samp{..}@:
1121 appearing as a name component, call @code{file-truename} without prior
1122 direct or indirect calls to @code{expand-file-name}. Otherwise, the
1123 file name component immediately preceding @samp{..} will be
1124 simplified away before @code{file-truename} is called. To
1125 eliminate the need for a call to @code{expand-file-name},
1126 @code{file-truename} handles @samp{~} in the same way that
1127 @code{expand-file-name} does.
1129 If the target of a symbolic links has remote file name syntax,
1130 @code{file-truename} returns it quoted. @xref{File Name Expansion,,
1131 Functions that Expand Filenames}.
1134 @defun file-chase-links filename &optional limit
1135 This function follows symbolic links, starting with @var{filename},
1136 until it finds a file name which is not the name of a symbolic link.
1137 Then it returns that file name. This function does @emph{not} follow
1138 symbolic links at the level of parent directories.
1140 If you specify a number for @var{limit}, then after chasing through
1141 that many links, the function just returns what it has even if that is
1142 still a symbolic link.
1145 To illustrate the difference between @code{file-chase-links} and
1146 @code{file-truename}, suppose that @file{/usr/foo} is a symbolic link to
1147 the directory @file{/home/foo}, and @file{/home/foo/hello} is an
1148 ordinary file (or at least, not a symbolic link) or nonexistent. Then
1152 (file-chase-links "/usr/foo/hello")
1153 ;; @r{This does not follow the links in the parent directories.}
1154 @result{} "/usr/foo/hello"
1155 (file-truename "/usr/foo/hello")
1156 ;; @r{Assuming that @file{/home} is not a symbolic link.}
1157 @result{} "/home/foo/hello"
1160 @defun file-equal-p file1 file2
1161 This function returns @code{t} if the files @var{file1} and
1162 @var{file2} name the same file. This is similar to comparing their
1163 truenames, except that remote file names are also handled in an
1164 appropriate manner. If @var{file1} or @var{file2} does not exist, the
1165 return value is unspecified.
1168 @defun file-name-case-insensitive-p filename
1169 Sometimes file names or their parts need to be compared as strings, in
1170 which case it's important to know whether the underlying filesystem is
1171 case-insensitive. This function returns @code{t} if file
1172 @var{filename} is on a case-insensitive filesystem. It always returns
1173 @code{t} on MS-DOS and MS-Windows. On Cygwin and macOS,
1174 filesystems may or may not be case-insensitive, and the function tries
1175 to determine case-sensitivity by a runtime test. If the test is
1176 inconclusive, the function returns @code{t} on Cygwin and @code{nil}
1179 Currently this function always returns @code{nil} on platforms other
1180 than MS-DOS, MS-Windows, Cygwin, and macOS. It does not detect
1181 case-insensitivity of mounted filesystems, such as Samba shares or
1182 NFS-mounted Windows volumes. On remote hosts, it assumes @code{t} for
1183 the @samp{smb} method. For all other connection methods, runtime
1184 tests are performed.
1187 @defun file-in-directory-p file dir
1188 This function returns @code{t} if @var{file} is a file in directory
1189 @var{dir}, or in a subdirectory of @var{dir}. It also returns
1190 @code{t} if @var{file} and @var{dir} are the same directory. It
1191 compares the truenames of the two directories. If @var{dir} does not
1192 name an existing directory, the return value is @code{nil}.
1195 @defun vc-responsible-backend file
1196 This function determines the responsible VC backend of the given
1197 @var{file}. For example, if @file{emacs.c} is a file tracked by Git,
1198 @w{@code{(vc-responsible-backend "emacs.c")}} returns @samp{Git}.
1199 Note that if @var{file} is a symbolic link,
1200 @code{vc-responsible-backend} will not resolve it---the backend of the
1201 symbolic link file itself is reported. To get the backend VC of the
1202 file to which @var{file} refers, wrap @var{file} with a symbolic link
1203 resolving function such as @code{file-chase-links}:
1206 (vc-responsible-backend (file-chase-links "emacs.c"))
1210 @node File Attributes
1211 @subsection File Attributes
1212 @cindex file attributes
1214 This section describes the functions for getting detailed
1215 information about a file, including the owner and group numbers, the
1216 number of names, the inode number, the size, and the times of access
1219 @defun file-newer-than-file-p filename1 filename2
1221 @cindex file modification time
1222 This function returns @code{t} if the file @var{filename1} is
1223 newer than file @var{filename2}. If @var{filename1} does not
1224 exist, it returns @code{nil}. If @var{filename1} does exist, but
1225 @var{filename2} does not, it returns @code{t}.
1227 In the following example, assume that the file @file{aug-19} was written
1228 on the 19th, @file{aug-20} was written on the 20th, and the file
1229 @file{no-file} doesn't exist at all.
1233 (file-newer-than-file-p "aug-19" "aug-20")
1237 (file-newer-than-file-p "aug-20" "aug-19")
1241 (file-newer-than-file-p "aug-19" "no-file")
1245 (file-newer-than-file-p "no-file" "aug-19")
1251 @defun file-attributes filename &optional id-format
1252 @anchor{Definition of file-attributes}
1253 This function returns a list of attributes of file @var{filename}. If
1254 the specified file's attributes cannot be accessed, it returns @code{nil}.
1255 This function does not follow symbolic links.
1256 The optional parameter @var{id-format} specifies the preferred format
1257 of attributes @acronym{UID} and @acronym{GID} (see below)---the
1258 valid values are @code{'string} and @code{'integer}. The latter is
1259 the default, but we plan to change that, so you should specify a
1260 non-@code{nil} value for @var{id-format} if you use the returned
1261 @acronym{UID} or @acronym{GID}.
1263 On GNU platforms when operating on a local file, this function is
1264 atomic: if the filesystem is simultaneously being changed by some
1265 other process, this function returns the file's attributes either
1266 before or after the change. Otherwise this function is not atomic,
1267 and might return @code{nil} if it detects the race condition, or might
1268 return a hodgepodge of the previous and current file attributes.
1270 Accessor functions are provided to access the elements in this list.
1271 The accessors are mentioned along with the descriptions of the
1274 The elements of the list, in order, are:
1278 @code{t} for a directory, a string for a symbolic link (the name
1279 linked to), or @code{nil} for a text file
1280 (@code{file-attribute-type}).
1282 @c Wordy so as to prevent an overfull hbox. --rjc 15mar92
1284 The number of names the file has (@code{file-attribute-link-number}).
1285 Alternate names, also known as hard links, can be created by using the
1286 @code{add-name-to-file} function (@pxref{Changing Files}).
1289 The file's @acronym{UID}, normally as a string
1290 (@code{file-attribute-user-id}). However, if it does not correspond
1291 to a named user, the value is a number.
1294 The file's @acronym{GID}, likewise (@code{file-attribute-group-id}).
1297 The time of last access, as a list of four integers
1298 @code{(@var{sec-high} @var{sec-low} @var{microsec} @var{picosec})}
1299 (@code{file-attribute-access-time}). (This is similar to the value of
1300 @code{current-time}; see @ref{Time of Day}.) The value is truncated
1301 to that of the filesystem's timestamp resolution; for example, on some
1302 FAT-based filesystems, only the date of last access is recorded, so
1303 this time will always hold the midnight of the day of the last access.
1305 @cindex modification time of file
1307 The time of last modification as a list of four integers (as above)
1308 (@code{file-attribute-modification-time}). This is the last time when
1309 the file's contents were modified.
1312 The time of last status change as a list of four integers (as above)
1313 (@code{file-attribute-status-change-time}). This is the time of the
1314 last change to the file's access mode bits, its owner and group, and
1315 other information recorded in the filesystem for the file, beyond the
1319 The size of the file in bytes (@code{file-attribute-size}). This is
1320 floating point if the size is too large to fit in a Lisp integer.
1323 The file's modes, as a string of ten letters or dashes, as in
1324 @samp{ls -l} (@code{file-attribute-modes}).
1327 An unspecified value, present for backward compatibility.
1330 The file's inode number (@code{file-attribute-inode-number}). If
1331 possible, this is an integer. If the inode number is too large to be
1332 represented as an integer in Emacs Lisp but dividing it by
1333 @math{2^{16}} yields a representable integer, then the value has the
1334 form @code{(@var{high} . @var{low})}, where @var{low} holds the low 16
1335 bits. If the inode number is too wide for even that, the value is of
1336 the form @code{(@var{high} @var{middle} . @var{low})}, where
1337 @code{high} holds the high bits, @var{middle} the middle 24 bits, and
1338 @var{low} the low 16 bits.
1341 The filesystem number of the device that the file is on
1342 @code{file-attribute-device-number}). Depending on the magnitude of
1343 the value, this can be either an integer or a cons cell, in the same
1344 manner as the inode number. This element and the file's inode number
1345 together give enough information to distinguish any two files on the
1346 system---no two files can have the same values for both of these
1350 For example, here are the file attributes for @file{files.texi}:
1354 (file-attributes "files.texi" 'string)
1355 @result{} (nil 1 "lh" "users"
1356 (20614 64019 50040 152000)
1358 (20614 64555 902289 872000)
1366 and here is how the result is interpreted:
1370 is neither a directory nor a symbolic link.
1373 has only one name (the name @file{files.texi} in the current default
1377 is owned by the user with name @samp{lh}.
1380 is in the group with name @samp{users}.
1382 @item (20614 64019 50040 152000)
1383 was last accessed on October 23, 2012, at 20:12:03.050040152 UTC.
1385 @item (20000 23 0 0)
1386 was last modified on July 15, 2001, at 08:53:43 UTC.
1388 @item (20614 64555 902289 872000)
1389 last had its status changed on October 23, 2012, at 20:20:59.902289872 UTC.
1392 is 122295 bytes long. (It may not contain 122295 characters, though,
1393 if some of the bytes belong to multibyte sequences, and also if the
1394 end-of-line format is CR-LF.)
1397 has a mode of read and write access for the owner, group, and world.
1400 is merely a placeholder; it carries no information.
1402 @item (5888 2 . 43978)
1403 has an inode number of 6473924464520138.
1405 @item (15479 . 46724)
1406 is on the file-system device whose number is 1014478468.
1410 @defun file-nlinks filename
1411 This function returns the number of names (i.e., hard links) that
1412 file @var{filename} has. If the file does not exist, this function
1413 returns @code{nil}. Note that symbolic links have no effect on this
1414 function, because they are not considered to be names of the files
1415 they link to. This function does not follow symbolic links.
1420 -rw-rw-rw- 2 rms rms 4 Aug 19 01:27 foo
1421 -rw-rw-rw- 2 rms rms 4 Aug 19 01:27 foo1
1429 (file-nlinks "doesnt-exist")
1435 @node Extended Attributes
1436 @subsection Extended File Attributes
1437 @cindex extended file attributes
1439 On some operating systems, each file can be associated with arbitrary
1440 @dfn{extended file attributes}. At present, Emacs supports querying
1441 and setting two specific sets of extended file attributes: Access
1442 Control Lists (ACLs) and SELinux contexts. These extended file
1443 attributes are used, on some systems, to impose more sophisticated
1444 file access controls than the basic Unix-style permissions
1445 discussed in the previous sections.
1447 @cindex access control list
1449 @cindex SELinux context
1450 A detailed explanation of ACLs and SELinux is beyond the scope of
1451 this manual. For our purposes, each file can be associated with an
1452 @dfn{ACL}, which specifies its properties under an ACL-based file
1453 control system, and/or an @dfn{SELinux context}, which specifies its
1454 properties under the SELinux system.
1456 @defun file-acl filename
1457 This function returns the ACL for the file @var{filename}. The exact
1458 Lisp representation of the ACL is unspecified (and may change in
1459 future Emacs versions), but it is the same as what @code{set-file-acl}
1460 takes for its @var{acl} argument (@pxref{Changing Files}).
1462 The underlying ACL implementation is platform-specific; on GNU/Linux
1463 and BSD, Emacs uses the POSIX ACL interface, while on MS-Windows Emacs
1464 emulates the POSIX ACL interface with native file security APIs.
1466 If Emacs was not compiled with ACL support, or the file does not exist
1467 or is inaccessible, or Emacs was unable to determine the ACL entries
1468 for any other reason, then the return value is @code{nil}.
1471 @defun file-selinux-context filename
1472 This function returns the SELinux context of the file @var{filename},
1473 as a list of the form @code{(@var{user} @var{role} @var{type}
1474 @var{range})}. The list elements are the context's user, role, type,
1475 and range respectively, as Lisp strings; see the SELinux documentation
1476 for details about what these actually mean. The return value has the
1477 same form as what @code{set-file-selinux-context} takes for its
1478 @var{context} argument (@pxref{Changing Files}).
1480 If Emacs was not compiled with SELinux support, or the file does not
1481 exist or is inaccessible, or if the system does not support SELinux,
1482 then the return value is @code{(nil nil nil nil)}.
1485 @defun file-extended-attributes filename
1486 This function returns an alist of the Emacs-recognized extended
1487 attributes of file @var{filename}. Currently, it serves as a
1488 convenient way to retrieve both the ACL and SELinux context; you can
1489 then call the function @code{set-file-extended-attributes}, with the
1490 returned alist as its second argument, to apply the same file access
1491 attributes to another file (@pxref{Changing Files}).
1493 One of the elements is @code{(acl . @var{acl})}, where @var{acl} has
1494 the same form returned by @code{file-acl}.
1496 Another element is @code{(selinux-context . @var{context})}, where
1497 @var{context} is the SELinux context, in the same form returned by
1498 @code{file-selinux-context}.
1501 @node Locating Files
1502 @subsection Locating Files in Standard Places
1503 @cindex locate file in path
1504 @cindex find file in path
1506 This section explains how to search for a file in a list of
1507 directories (a @dfn{path}), or for an executable file in the standard
1508 list of executable file directories.
1510 To search for a user-specific configuration file, @xref{Standard
1511 File Names}, for the @code{locate-user-emacs-file} function.
1513 @defun locate-file filename path &optional suffixes predicate
1514 This function searches for a file whose name is @var{filename} in a
1515 list of directories given by @var{path}, trying the suffixes in
1516 @var{suffixes}. If it finds such a file, it returns the file's
1517 absolute file name (@pxref{Relative File Names}); otherwise it returns
1520 The optional argument @var{suffixes} gives the list of file-name
1521 suffixes to append to @var{filename} when searching.
1522 @code{locate-file} tries each possible directory with each of these
1523 suffixes. If @var{suffixes} is @code{nil}, or @code{("")}, then there
1524 are no suffixes, and @var{filename} is used only as-is. Typical
1525 values of @var{suffixes} are @code{exec-suffixes} (@pxref{Subprocess
1526 Creation}), @code{load-suffixes}, @code{load-file-rep-suffixes} and
1527 the return value of the function @code{get-load-suffixes} (@pxref{Load
1530 Typical values for @var{path} are @code{exec-path} (@pxref{Subprocess
1531 Creation}) when looking for executable programs, or @code{load-path}
1532 (@pxref{Library Search}) when looking for Lisp files. If
1533 @var{filename} is absolute, @var{path} has no effect, but the suffixes
1534 in @var{suffixes} are still tried.
1536 The optional argument @var{predicate}, if non-@code{nil}, specifies a
1537 predicate function for testing whether a candidate file is suitable.
1538 The predicate is passed the candidate file name as its single
1539 argument. If @var{predicate} is @code{nil} or omitted,
1540 @code{locate-file} uses @code{file-readable-p} as the predicate.
1541 @xref{Kinds of Files}, for other useful predicates, e.g.,
1542 @code{file-executable-p} and @code{file-directory-p}.
1544 This function will normally skip directories, so if you want it to
1545 find directories, make sure the @var{predicate} function returns
1546 @code{dir-ok} for them. For example:
1549 (locate-file "html" '("/var/www" "/srv") nil
1550 (lambda (f) (if (file-directory-p f) 'dir-ok)))
1554 For compatibility, @var{predicate} can also be one of the symbols
1555 @code{executable}, @code{readable}, @code{writable}, @code{exists}, or
1556 a list of one or more of these symbols.
1559 @defun executable-find program
1560 This function searches for the executable file of the named
1561 @var{program} and returns the absolute file name of the executable,
1562 including its file-name extensions, if any. It returns @code{nil} if
1563 the file is not found. The functions searches in all the directories
1564 in @code{exec-path}, and tries all the file-name extensions in
1565 @code{exec-suffixes} (@pxref{Subprocess Creation}).
1568 @node Changing Files
1569 @section Changing File Names and Attributes
1570 @c @cindex renaming files Duplicates rename-file
1571 @cindex copying files
1572 @cindex deleting files
1573 @cindex linking files
1574 @cindex setting modes of files
1576 The functions in this section rename, copy, delete, link, and set
1577 the modes (permissions) of files. Typically, they signal a
1578 @code{file-error} error if they fail to perform their function,
1579 reporting the system-dependent error message that describes the reason
1580 for the failure. If they fail because a file is missing, they signal
1581 a @code{file-missing} error instead.
1583 For performance, the operating system may cache or alias changes
1584 made by these functions instead of writing them immediately to
1585 secondary storage. @xref{Files and Storage}.
1587 In the functions that have an argument @var{newname}, if this
1588 argument is a directory name it is treated as if the nondirectory part
1589 of the source name were appended. Typically, a directory name is one
1590 that ends in @samp{/} (@pxref{Directory Names}). For example, if the
1591 old name is @file{a/b/c}, the @var{newname} @file{d/e/f/} is treated
1592 as if it were @file{d/e/f/c}. This special treatment does not apply
1593 if @var{newname} is not a directory name but names a file that is a
1594 directory; for example, the @var{newname} @file{d/e/f} is left as-is
1595 even if @file{d/e/f} happens to be a directory.
1597 In the functions that have an argument @var{newname}, if a file by the
1598 name of @var{newname} already exists, the actions taken depend on the
1599 value of the argument @var{ok-if-already-exists}:
1603 Signal a @code{file-already-exists} error if
1604 @var{ok-if-already-exists} is @code{nil}.
1607 Request confirmation if @var{ok-if-already-exists} is a number.
1610 Replace the old file without confirmation if @var{ok-if-already-exists}
1614 @deffn Command add-name-to-file oldname newname &optional ok-if-already-exists
1615 @cindex file with multiple names
1616 @cindex file hard link
1617 This function gives the file named @var{oldname} the additional name
1618 @var{newname}. This means that @var{newname} becomes a new hard
1619 link to @var{oldname}.
1621 If @var{newname} is a symbolic link, its directory entry is replaced,
1622 not the directory entry it points to. If @var{oldname} is a symbolic
1623 link, this function might or might not follow the link; it does not
1624 follow the link on GNU platforms. If @var{oldname} is a directory,
1625 this function typically fails, although for the superuser on a few
1626 old-fashioned non-GNU platforms it can succeed and create a filesystem
1627 that is not tree-structured.
1629 In the first part of the following example, we list two files,
1630 @file{foo} and @file{foo3}.
1635 81908 -rw-rw-rw- 1 rms rms 29 Aug 18 20:32 foo
1636 84302 -rw-rw-rw- 1 rms rms 24 Aug 18 20:31 foo3
1640 Now we create a hard link, by calling @code{add-name-to-file}, then list
1641 the files again. This shows two names for one file, @file{foo} and
1646 (add-name-to-file "foo" "foo2")
1652 81908 -rw-rw-rw- 2 rms rms 29 Aug 18 20:32 foo
1653 81908 -rw-rw-rw- 2 rms rms 29 Aug 18 20:32 foo2
1654 84302 -rw-rw-rw- 1 rms rms 24 Aug 18 20:31 foo3
1658 Finally, we evaluate the following:
1661 (add-name-to-file "foo" "foo3" t)
1665 and list the files again. Now there are three names
1666 for one file: @file{foo}, @file{foo2}, and @file{foo3}. The old
1667 contents of @file{foo3} are lost.
1671 (add-name-to-file "foo1" "foo3")
1677 81908 -rw-rw-rw- 3 rms rms 29 Aug 18 20:32 foo
1678 81908 -rw-rw-rw- 3 rms rms 29 Aug 18 20:32 foo2
1679 81908 -rw-rw-rw- 3 rms rms 29 Aug 18 20:32 foo3
1683 This function is meaningless on operating systems where multiple names
1684 for one file are not allowed. Some systems implement multiple names
1685 by copying the file instead.
1687 See also @code{file-nlinks} in @ref{File Attributes}.
1690 @deffn Command rename-file filename newname &optional ok-if-already-exists
1691 This command renames the file @var{filename} as @var{newname}.
1693 If @var{filename} has additional names aside from @var{filename}, it
1694 continues to have those names. In fact, adding the name @var{newname}
1695 with @code{add-name-to-file} and then deleting @var{filename} has the
1696 same effect as renaming, aside from momentary intermediate states and
1697 treatment of errors, directories and symbolic links.
1699 This command does not follow symbolic links. If @var{filename} is a
1700 symbolic link, this command renames the symbolic link, not the file it
1701 points to. If @var{newname} is a symbolic link, its directory entry
1702 is replaced, not the directory entry it points to.
1704 This command does nothing if @var{filename} and @var{newname} are the
1705 same directory entry, i.e., if they refer to the same parent directory
1706 and give the same name within that directory. Otherwise, if
1707 @var{filename} and @var{newname} name the same file, this command does
1708 nothing on POSIX-conforming systems, and removes @var{filename} on
1709 some non-POSIX systems.
1711 If @var{newname} exists, then it must be an empty directory if
1712 @var{oldname} is a directory and a non-directory otherwise.
1715 @deffn Command copy-file oldname newname &optional ok-if-already-exists time preserve-uid-gid preserve-extended-attributes
1716 This command copies the file @var{oldname} to @var{newname}. An
1717 error is signaled if @var{oldname} is not a regular file. If @var{newname}
1718 names a directory, it copies @var{oldname} into that directory,
1719 preserving its final name component.
1720 @c FIXME: See Bug#27986 for how the previous sentence might change.
1722 This function follows symbolic links, except that it does not follow a
1723 dangling symbolic link to create @var{newname}.
1725 If @var{time} is non-@code{nil}, then this function gives the new file
1726 the same last-modified time that the old one has. (This works on only
1727 some operating systems.) If setting the time gets an error,
1728 @code{copy-file} signals a @code{file-date-error} error. In an
1729 interactive call, a prefix argument specifies a non-@code{nil} value
1732 If argument @var{preserve-uid-gid} is @code{nil}, we let the operating
1733 system decide the user and group ownership of the new file (this is
1734 usually set to the user running Emacs). If @var{preserve-uid-gid} is
1735 non-@code{nil}, we attempt to copy the user and group ownership of the
1736 file. This works only on some operating systems, and only if you have
1737 the correct permissions to do so.
1739 If the optional argument @var{preserve-permissions} is non-@code{nil},
1740 this function copies the file modes (or ``permissions'') of
1741 @var{oldname} to @var{newname}, as well as the Access Control List and
1742 SELinux context (if any). @xref{Information about Files}.
1744 Otherwise, the file modes of @var{newname} are left unchanged if it is
1745 an existing file, and set to those of @var{oldname}, masked by the
1746 default file permissions (see @code{set-default-file-modes} below), if
1747 @var{newname} is to be newly created. The Access Control List or
1748 SELinux context are not copied over in either case.
1751 @deffn Command make-symbolic-link target newname &optional ok-if-already-exists
1753 @kindex file-already-exists
1754 This command makes a symbolic link to @var{target}, named
1755 @var{newname}. This is like the shell command @samp{ln -s
1756 @var{target} @var{newname}}. The @var{target} argument
1757 is treated only as a string; it need not name an existing file.
1758 If @var{ok-if-already-exists} is an integer, indicating interactive
1759 use, then leading @samp{~} is expanded and leading @samp{/:} is
1760 stripped in the @var{target} string.
1762 If @var{target} is a relative file name, the resulting symbolic link
1763 is interpreted relative to the directory containing the symbolic link.
1764 @xref{Relative File Names}.
1766 If both @var{target} and @var{newname} have remote file name syntax,
1767 and if both remote identifications are equal, the symbolic link points
1768 to the local file name part of @var{target}.
1770 This function is not available on systems that don't support symbolic
1775 @vindex delete-by-moving-to-trash
1776 @deffn Command delete-file filename &optional trash
1778 This command deletes the file @var{filename}. If the file has
1779 multiple names, it continues to exist under the other names. If
1780 @var{filename} is a symbolic link, @code{delete-file} deletes only the
1781 symbolic link and not its target.
1783 A suitable kind of @code{file-error} error is signaled if the file
1784 does not exist, or is not deletable. (On GNU and other POSIX-like
1785 systems, a file is deletable if its directory is writable.)
1787 If the optional argument @var{trash} is non-@code{nil} and the
1788 variable @code{delete-by-moving-to-trash} is non-@code{nil}, this
1789 command moves the file into the system Trash instead of deleting it.
1790 @xref{Misc File Ops,,Miscellaneous File Operations, emacs, The GNU
1791 Emacs Manual}. When called interactively, @var{trash} is @code{t} if
1792 no prefix argument is given, and @code{nil} otherwise.
1794 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1797 @cindex file permissions, setting
1798 @cindex permissions, file
1799 @cindex file modes, setting
1800 @deffn Command set-file-modes filename mode
1801 This function sets the @dfn{file mode} (or @dfn{permissions}) of
1802 @var{filename} to @var{mode}. This function follows symbolic links.
1804 If called non-interactively, @var{mode} must be an integer. Only the
1805 lowest 12 bits of the integer are used; on most systems, only the
1806 lowest 9 bits are meaningful. You can use the Lisp construct for
1807 octal numbers to enter @var{mode}. For example,
1810 (set-file-modes #o644)
1814 specifies that the file should be readable and writable for its owner,
1815 readable for group members, and readable for all other users.
1816 @xref{File permissions,,, coreutils, The @sc{gnu} @code{Coreutils}
1817 Manual}, for a description of mode bit specifications.
1819 Interactively, @var{mode} is read from the minibuffer using
1820 @code{read-file-modes} (see below), which lets the user type in either
1821 an integer or a string representing the permissions symbolically.
1823 @xref{File Attributes}, for the function @code{file-modes}, which
1824 returns the permissions of a file.
1827 @defun set-default-file-modes mode
1829 This function sets the default permissions for new files created by
1830 Emacs and its subprocesses. Every file created with Emacs initially
1831 has these permissions, or a subset of them (@code{write-region} will
1832 not grant execute permissions even if the default file permissions
1833 allow execution). On GNU and other POSIX-like systems, the default
1834 permissions are given by the bitwise complement of the @samp{umask}
1835 value, i.e.@: each bit that is set in the argument @var{mode} will be
1836 @emph{reset} in the default permissions with which Emacs creates
1839 The argument @var{mode} should be an integer which specifies the
1840 permissions, similar to @code{set-file-modes} above. Only the lowest
1841 9 bits are meaningful.
1843 The default file permissions have no effect when you save a modified
1844 version of an existing file; saving a file preserves its existing
1848 @defmac with-file-modes mode body@dots{}
1849 This macro evaluates the @var{body} forms with the default
1850 permissions for new files temporarily set to @var{modes} (whose value
1851 is as for @code{set-file-modes} above). When finished, it restores
1852 the original default file permissions, and returns the value of the
1853 last form in @var{body}.
1855 This is useful for creating private files, for example.
1858 @defun default-file-modes
1859 This function returns the default file permissions, as an integer.
1862 @defun read-file-modes &optional prompt base-file
1863 This function reads a set of file mode bits from the minibuffer. The
1864 first optional argument @var{prompt} specifies a non-default prompt.
1865 Second second optional argument @var{base-file} is the name of a file
1866 on whose permissions to base the mode bits that this function returns,
1867 if what the user types specifies mode bits relative to permissions of
1870 If user input represents an octal number, this function returns that
1871 number. If it is a complete symbolic specification of mode bits, as
1872 in @code{"u=rwx"}, the function converts it to the equivalent numeric
1873 value using @code{file-modes-symbolic-to-number} and returns the
1874 result. If the specification is relative, as in @code{"o+g"}, then
1875 the permissions on which the specification is based are taken from the
1876 mode bits of @var{base-file}. If @var{base-file} is omitted or
1877 @code{nil}, the function uses @code{0} as the base mode bits. The
1878 complete and relative specifications can be combined, as in
1879 @code{"u+r,g+rx,o+r,g-w"}. @xref{File permissions,,, coreutils, The
1880 @sc{gnu} @code{Coreutils} Manual}, for a description of file mode
1884 @defun file-modes-symbolic-to-number modes &optional base-modes
1885 This function converts a symbolic file mode specification in
1886 @var{modes} into the equivalent integer. If the symbolic
1887 specification is based on an existing file, that file's mode bits are
1888 taken from the optional argument @var{base-modes}; if that argument is
1889 omitted or @code{nil}, it defaults to 0, i.e., no access rights at
1893 @defun set-file-times filename &optional time
1894 This function sets the access and modification times of @var{filename}
1895 to @var{time}. The return value is @code{t} if the times are successfully
1896 set, otherwise it is @code{nil}. @var{time} defaults to the current
1897 time and must be a time value (@pxref{Time of Day}).
1900 @defun set-file-extended-attributes filename attribute-alist
1901 This function sets the Emacs-recognized extended file attributes for
1902 @code{filename}. The second argument @var{attribute-alist} should be
1903 an alist of the same form returned by @code{file-extended-attributes}.
1904 The return value is @code{t} if the attributes are successfully set,
1905 otherwise it is @code{nil}.
1906 @xref{Extended Attributes}.
1909 @defun set-file-selinux-context filename context
1910 This function sets the SELinux security context for @var{filename} to
1911 @var{context}. The @var{context} argument should be a list
1912 @code{(@var{user} @var{role} @var{type} @var{range})}, where each
1913 element is a string. @xref{Extended Attributes}.
1915 The function returns @code{t} if it succeeds in setting the SELinux
1916 context of @var{filename}. It returns @code{nil} if the context was
1917 not set (e.g., if SELinux is disabled, or if Emacs was compiled
1918 without SELinux support).
1921 @defun set-file-acl filename acl
1922 This function sets the Access Control List for @var{filename} to
1923 @var{acl}. The @var{acl} argument should have the same form returned
1924 by the function @code{file-acl}. @xref{Extended Attributes}.
1926 The function returns @code{t} if it successfully sets the ACL of
1927 @var{filename}, @code{nil} otherwise.
1930 @node Files and Storage
1931 @section Files and Secondary Storage
1932 @cindex secondary storage
1934 After Emacs changes a file, there are two reasons the changes might
1935 not survive later failures of power or media, both having to do with
1936 efficiency. First, the operating system might alias written data with
1937 data already stored elsewhere on secondary storage until one file or
1938 the other is later modified; this will lose both files if the only
1939 copy on secondary storage is lost due to media failure. Second, the
1940 operating system might not write data to secondary storage
1941 immediately, which will lose the data if power is lost.
1943 @findex write-region
1944 Although both sorts of failures can largely be avoided by a suitably
1945 configured file system, such systems are typically more expensive or
1946 less efficient. In more-typical systems, to survive media failure you
1947 can copy the file to a different device, and to survive a power
1948 failure you can use the @code{write-region} function with the
1949 @code{write-region-inhibit-fsync} variable set to @code{nil}.
1950 @xref{Writing to Files}.
1956 Files are generally referred to by their names, in Emacs as elsewhere.
1957 File names in Emacs are represented as strings. The functions that
1958 operate on a file all expect a file name argument.
1960 In addition to operating on files themselves, Emacs Lisp programs
1961 often need to operate on file names; i.e., to take them apart and to use
1962 part of a name to construct related file names. This section describes
1963 how to manipulate file names.
1965 The functions in this section do not actually access files, so they
1966 can operate on file names that do not refer to an existing file or
1969 @findex cygwin-convert-file-name-from-windows
1970 @findex cygwin-convert-file-name-to-windows
1971 @cindex MS-Windows file-name syntax
1972 @cindex converting file names from/to MS-Windows syntax
1973 On MS-DOS and MS-Windows, these functions (like the function that
1974 actually operate on files) accept MS-DOS or MS-Windows file-name syntax,
1975 where backslashes separate the components, as well as POSIX syntax; but
1976 they always return POSIX syntax. This enables Lisp programs to specify
1977 file names in POSIX syntax and work properly on all systems without
1978 change.@footnote{In MS-Windows versions of Emacs compiled for the Cygwin
1979 environment, you can use the functions
1980 @code{cygwin-convert-file-name-to-windows} and
1981 @code{cygwin-convert-file-name-from-windows} to convert between the
1982 two file-name syntaxes.}
1985 * File Name Components:: The directory part of a file name, and the rest.
1986 * Relative File Names:: Some file names are relative to a current directory.
1987 * Directory Names:: A directory's name as a directory
1988 is different from its name as a file.
1989 * File Name Expansion:: Converting relative file names to absolute ones.
1990 * Unique File Names:: Generating names for temporary files.
1991 * File Name Completion:: Finding the completions for a given file name.
1992 * Standard File Names:: If your package uses a fixed file name,
1993 how to handle various operating systems simply.
1996 @node File Name Components
1997 @subsection File Name Components
1998 @cindex directory part (of file name)
1999 @cindex nondirectory part (of file name)
2000 @cindex version number (in file name)
2002 The operating system groups files into directories. To specify a
2003 file, you must specify the directory and the file's name within that
2004 directory. Therefore, Emacs considers a file name as having two main
2005 parts: the @dfn{directory name} part, and the @dfn{nondirectory} part
2006 (or @dfn{file name within the directory}). Either part may be empty.
2007 Concatenating these two parts reproduces the original file name.
2009 On most systems, the directory part is everything up to and including
2010 the last slash (backslash is also allowed in input on MS-DOS or
2011 MS-Windows); the nondirectory part is the rest.
2013 For some purposes, the nondirectory part is further subdivided into
2014 the name proper and the @dfn{version number}. On most systems, only
2015 backup files have version numbers in their names.
2017 @defun file-name-directory filename
2018 This function returns the directory part of @var{filename}, as a
2019 directory name (@pxref{Directory Names}), or @code{nil} if
2020 @var{filename} does not include a directory part.
2022 On GNU and other POSIX-like systems, a string returned by this function always
2023 ends in a slash. On MS-DOS it can also end in a colon.
2027 (file-name-directory "lewis/foo") ; @r{GNU example}
2031 (file-name-directory "foo") ; @r{GNU example}
2037 @defun file-name-nondirectory filename
2038 This function returns the nondirectory part of @var{filename}.
2042 (file-name-nondirectory "lewis/foo")
2046 (file-name-nondirectory "foo")
2050 (file-name-nondirectory "lewis/")
2056 @defun file-name-sans-versions filename &optional keep-backup-version
2057 This function returns @var{filename} with any file version numbers,
2058 backup version numbers, or trailing tildes discarded.
2060 If @var{keep-backup-version} is non-@code{nil}, then true file version
2061 numbers understood as such by the file system are discarded from the
2062 return value, but backup version numbers are kept.
2066 (file-name-sans-versions "~rms/foo.~1~")
2067 @result{} "~rms/foo"
2070 (file-name-sans-versions "~rms/foo~")
2071 @result{} "~rms/foo"
2074 (file-name-sans-versions "~rms/foo")
2075 @result{} "~rms/foo"
2080 @defun file-name-extension filename &optional period
2081 This function returns @var{filename}'s final extension, if any,
2082 after applying @code{file-name-sans-versions} to remove any
2083 version/backup part. The extension, in a file name, is the part that
2084 follows the last @samp{.} in the last name component (minus any
2085 version/backup part).
2087 This function returns @code{nil} for extensionless file names such as
2088 @file{foo}. It returns @code{""} for null extensions, as in
2089 @file{foo.}. If the last component of a file name begins with a
2090 @samp{.}, that @samp{.} doesn't count as the beginning of an
2091 extension. Thus, @file{.emacs}'s extension is @code{nil}, not
2094 If @var{period} is non-@code{nil}, then the returned value includes
2095 the period that delimits the extension, and if @var{filename} has no
2096 extension, the value is @code{""}.
2099 @defun file-name-sans-extension filename
2100 This function returns @var{filename} minus its extension, if any. The
2101 version/backup part, if present, is only removed if the file has an
2102 extension. For example,
2105 (file-name-sans-extension "foo.lose.c")
2106 @result{} "foo.lose"
2107 (file-name-sans-extension "big.hack/foo")
2108 @result{} "big.hack/foo"
2109 (file-name-sans-extension "/my/home/.emacs")
2110 @result{} "/my/home/.emacs"
2111 (file-name-sans-extension "/my/home/.emacs.el")
2112 @result{} "/my/home/.emacs"
2113 (file-name-sans-extension "~/foo.el.~3~")
2115 (file-name-sans-extension "~/foo.~3~")
2116 @result{} "~/foo.~3~"
2119 Note that the @samp{.~3~} in the two last examples is the backup part,
2123 @defun file-name-base filename
2124 This function is the composition of @code{file-name-sans-extension}
2125 and @code{file-name-nondirectory}. For example,
2128 (file-name-base "/my/home/foo.c")
2133 @node Relative File Names
2134 @subsection Absolute and Relative File Names
2135 @cindex absolute file name
2136 @cindex relative file name
2138 All the directories in the file system form a tree starting at the
2139 root directory. A file name can specify all the directory names
2140 starting from the root of the tree; then it is called an
2141 @dfn{absolute} file name. Or it can specify the position of the file
2142 in the tree relative to a default directory; then it is called a
2143 @dfn{relative} file name. On GNU and other POSIX-like systems,
2144 after any leading @samp{~} has been expanded, an absolute file name
2145 starts with a @samp{/}
2146 (@pxref{abbreviate-file-name}), and a relative one does not. On
2147 MS-DOS and MS-Windows, an absolute file name starts with a slash or a
2148 backslash, or with a drive specification @samp{@var{x}:/}, where
2149 @var{x} is the @dfn{drive letter}.
2151 @defun file-name-absolute-p filename
2152 This function returns @code{t} if file @var{filename} is an absolute
2153 file name or begins with @samp{~}, @code{nil} otherwise.
2157 (file-name-absolute-p "~rms/foo")
2161 (file-name-absolute-p "rms/foo")
2165 (file-name-absolute-p "/user/rms/foo")
2171 Given a possibly relative file name, you can expand any
2172 leading @samp{~} and convert the result to an
2173 absolute name using @code{expand-file-name} (@pxref{File Name
2174 Expansion}). This function converts absolute file names to relative
2177 @defun file-relative-name filename &optional directory
2178 This function tries to return a relative name that is equivalent to
2179 @var{filename}, assuming the result will be interpreted relative to
2180 @var{directory} (an absolute directory name or directory file name).
2181 If @var{directory} is omitted or @code{nil}, it defaults to the
2182 current buffer's default directory.
2184 On some operating systems, an absolute file name begins with a device
2185 name. On such systems, @var{filename} has no relative equivalent based
2186 on @var{directory} if they start with two different device names. In
2187 this case, @code{file-relative-name} returns @var{filename} in absolute
2191 (file-relative-name "/foo/bar" "/foo/")
2193 (file-relative-name "/foo/bar" "/hack/")
2194 @result{} "../foo/bar"
2198 @node Directory Names
2199 @subsection Directory Names
2200 @cindex directory name
2201 @cindex directory file name
2202 @cindex file name of directory
2204 A @dfn{directory name} is a string that must name a directory if it
2205 names any file at all. A directory is actually a kind of file, and it
2206 has a file name (called the @dfn{directory file name}, which is
2207 related to the directory name but is typically not identical. (This
2208 is not quite the same as the usual POSIX terminology.) These two
2209 names for the same entity are related by a syntactic transformation.
2210 On GNU and other POSIX-like systems, this is simple: to obtain a
2211 directory name, append a @samp{/} to a directory file name that does
2212 not already end in @samp{/}. On MS-DOS the relationship is more
2215 The difference between a directory name and a directory file name is
2216 subtle but crucial. When an Emacs variable or function argument is
2217 described as being a directory name, a directory file name is not
2218 acceptable. When @code{file-name-directory} returns a string, that is
2219 always a directory name.
2221 The following two functions convert between directory names and
2222 directory file names. They do nothing special with environment
2223 variable substitutions such as @samp{$HOME}, and the constructs
2224 @samp{~}, @samp{.} and @samp{..}.
2226 @defun file-name-as-directory filename
2227 This function returns a string representing @var{filename} in a form
2228 that the operating system will interpret as the name of a directory (a
2229 directory name). On most systems, this means appending a slash to the
2230 string (if it does not already end in one).
2234 (file-name-as-directory "~rms/lewis")
2235 @result{} "~rms/lewis/"
2240 @defun directory-name-p filename
2241 This function returns non-@code{nil} if @var{filename} ends with a
2242 directory separator character. This is the forward slash @samp{/} on
2243 GNU and other POSIX-like systems; MS-Windows and MS-DOS recognize both
2244 the forward slash and the backslash @samp{\} as directory separators.
2247 @defun directory-file-name dirname
2248 This function returns a string representing @var{dirname} in a form
2249 that the operating system will interpret as the name of a file (a
2250 directory file name). On most systems, this means removing the final
2251 directory separators from the string, unless the string consists
2252 entirely of directory separators.
2256 (directory-file-name "~lewis/")
2262 Given a directory name, you can combine it with a relative file name
2263 using @code{concat}:
2266 (concat @var{dirname} @var{relfile})
2270 Be sure to verify that the file name is relative before doing that.
2271 If you use an absolute file name, the results could be syntactically
2272 invalid or refer to the wrong file.
2274 If you want to use a directory file name in making such a
2275 combination, you must first convert it to a directory name using
2276 @code{file-name-as-directory}:
2279 (concat (file-name-as-directory @var{dirfile}) @var{relfile})
2283 Don't try concatenating a slash by hand, as in
2287 (concat @var{dirfile} "/" @var{relfile})
2291 because this is not portable. Always use
2292 @code{file-name-as-directory}.
2294 To avoid the issues mentioned above, or if the @var{dirname} value
2295 might be @code{nil} (for example, from an element of @code{load-path}),
2299 (expand-file-name @var{relfile} @var{dirname})
2302 However, @code{expand-file-name} expands leading @samp{~} in
2303 @var{relfile}, which may not be what you want. @xref{File Name
2306 To convert a directory name to its abbreviation, use this
2309 @cindex file name abbreviations
2310 @cindex abbreviated file names
2311 @vindex directory-abbrev-alist
2312 @defun abbreviate-file-name filename
2313 @anchor{abbreviate-file-name}
2314 This function returns an abbreviated form of @var{filename}. It
2315 applies the abbreviations specified in @code{directory-abbrev-alist}
2316 (@pxref{File Aliases,,File Aliases, emacs, The GNU Emacs Manual}),
2317 then substitutes @samp{~} for the user's home directory if the
2318 argument names a file in the home directory or one of its
2319 subdirectories. If the home directory is a root directory, it is not
2320 replaced with @samp{~}, because this does not make the result shorter
2323 You can use this function for directory names and for file names,
2324 because it recognizes abbreviations even as part of the name.
2327 @node File Name Expansion
2328 @subsection Functions that Expand Filenames
2329 @cindex expansion of file names
2331 @dfn{Expanding} a file name means converting a relative file name to
2332 an absolute one. Since this is done relative to a default directory,
2333 you must specify the default directory as well as the file name
2334 to be expanded. It also involves expanding abbreviations like
2337 (@pxref{abbreviate-file-name}),
2339 and eliminating redundancies like @file{./} and @file{@var{name}/../}.
2341 @defun expand-file-name filename &optional directory
2342 This function converts @var{filename} to an absolute file name. If
2343 @var{directory} is supplied, it is the default directory to start with
2344 if @var{filename} is relative and does not start with @samp{~}.
2345 (The value of @var{directory} should
2346 itself be an absolute directory name or directory file name; it may
2347 start with @samp{~}.) Otherwise, the current buffer's value of
2348 @code{default-directory} is used. For example:
2352 (expand-file-name "foo")
2353 @result{} "/xcssun/users/rms/lewis/foo"
2356 (expand-file-name "../foo")
2357 @result{} "/xcssun/users/rms/foo"
2360 (expand-file-name "foo" "/usr/spool/")
2361 @result{} "/usr/spool/foo"
2365 If the part of @var{filename} before the first slash is
2366 @samp{~}, it expands to the value of the @env{HOME} environment
2367 variable (usually your home directory). If the part before the first
2368 slash is @samp{~@var{user}} and if @var{user} is a valid login name,
2369 it expands to @var{user}'s home directory.
2370 If you do not want this expansion for a relative @var{filename} that
2371 might begin with a literal @samp{~}, you can use @code{(concat
2372 (file-name-as-directory directory) filename)} instead of
2373 @code{(expand-file-name filename directory)}.
2375 Filenames containing @samp{.} or @samp{..} are simplified to their
2380 (expand-file-name "bar/../foo")
2381 @result{} "/xcssun/users/rms/lewis/foo"
2385 In some cases, a leading @samp{..} component can remain in the output:
2389 (expand-file-name "../home" "/")
2390 @result{} "/../home"
2395 This is for the sake of filesystems that have the concept of a
2396 superroot above the root directory @file{/}. On other filesystems,
2397 @file{/../} is interpreted exactly the same as @file{/}.
2399 Note that @code{expand-file-name} does @emph{not} expand environment
2400 variables; only @code{substitute-in-file-name} does that:
2404 (expand-file-name "$HOME/foo")
2405 @result{} "/xcssun/users/rms/lewis/$HOME/foo"
2409 Note also that @code{expand-file-name} does not follow symbolic links
2410 at any level. This results in a difference between the way
2411 @code{file-truename} and @code{expand-file-name} treat @samp{..}.
2412 Assuming that @samp{/tmp/bar} is a symbolic link to the directory
2413 @samp{/tmp/foo/bar} we get:
2417 (file-truename "/tmp/bar/../myfile")
2418 @result{} "/tmp/foo/myfile"
2421 (expand-file-name "/tmp/bar/../myfile")
2422 @result{} "/tmp/myfile"
2426 If you may need to follow symbolic links preceding @samp{..}, you
2427 should make sure to call @code{file-truename} without prior direct or
2428 indirect calls to @code{expand-file-name}. @xref{Truenames}.
2431 @defvar default-directory
2432 The value of this buffer-local variable is the default directory for the
2433 current buffer. It should be an absolute directory name; it may start
2434 with @samp{~}. This variable is buffer-local in every buffer.
2436 @code{expand-file-name} uses the default directory when its second
2437 argument is @code{nil}.
2439 The value is always a string ending with a slash.
2444 @result{} "/user/lewis/manual/"
2449 @defun substitute-in-file-name filename
2450 @anchor{Definition of substitute-in-file-name}
2451 This function replaces environment variable references in
2452 @var{filename} with the environment variable values. Following
2453 standard Unix shell syntax, @samp{$} is the prefix to substitute an
2454 environment variable value. If the input contains @samp{$$}, that is
2455 converted to @samp{$}; this gives the user a way to quote a
2458 The environment variable name is the series of alphanumeric characters
2459 (including underscores) that follow the @samp{$}. If the character following
2460 the @samp{$} is a @samp{@{}, then the variable name is everything up to the
2463 Calling @code{substitute-in-file-name} on output produced by
2464 @code{substitute-in-file-name} tends to give incorrect results. For
2465 instance, use of @samp{$$} to quote a single @samp{$} won't work
2466 properly, and @samp{$} in an environment variable's value could lead
2467 to repeated substitution. Therefore, programs that call this function
2468 and put the output where it will be passed to this function need to
2469 double all @samp{$} characters to prevent subsequent incorrect
2472 @c Wordy to avoid overfull hbox. --rjc 15mar92
2473 Here we assume that the environment variable @env{HOME}, which holds
2474 the user's home directory, has value @samp{/xcssun/users/rms}.
2478 (substitute-in-file-name "$HOME/foo")
2479 @result{} "/xcssun/users/rms/foo"
2483 After substitution, if a @samp{~} or a @samp{/} appears immediately
2484 after another @samp{/}, the function discards everything before it (up
2485 through the immediately preceding @samp{/}).
2489 (substitute-in-file-name "bar/~/foo")
2493 (substitute-in-file-name "/usr/local/$HOME/foo")
2494 @result{} "/xcssun/users/rms/foo"
2495 ;; @r{@file{/usr/local/} has been discarded.}
2501 Sometimes, it is not desired to expand file names. In such cases,
2502 the file name can be quoted to suppress the expansion, and to handle
2503 the file name literally. Quoting happens by prefixing the file name
2506 @defmac file-name-quote name
2507 This macro adds the quotation prefix @samp{/:} to the file @var{name}.
2508 For a local file @var{name}, it prefixes @var{name} with @samp{/:}.
2509 If @var{name} is a remote file name, the local part of @var{name} is
2510 quoted. If @var{name} is already a quoted file name, @var{name} is
2515 (substitute-in-file-name (file-name-quote "bar/~/foo"))
2516 @result{} "/:bar/~/foo"
2520 (substitute-in-file-name (file-name-quote "/ssh:host:bar/~/foo"))
2521 @result{} "/ssh:host:/:bar/~/foo"
2525 The macro cannot be used to suppress file name handlers from magic
2526 file names (@pxref{Magic File Names}).
2529 @defmac file-name-unquote name
2530 This macro removes the quotation prefix @samp{/:} from the file
2531 @var{name}, if any. If @var{name} is a remote file name, the local
2532 part of @var{name} is unquoted.
2535 @defmac file-name-quoted-p name
2536 This macro returns non-@code{nil}, when @var{name} is quoted with the
2537 prefix @samp{/:}. If @var{name} is a remote file name, the local part
2538 of @var{name} is checked.
2542 @node Unique File Names
2543 @subsection Generating Unique File Names
2544 @cindex unique file names
2545 @cindex temporary files
2547 Some programs need to write temporary files. Here is the usual way to
2548 construct a name for such a file:
2551 (make-temp-file @var{name-of-application})
2555 The job of @code{make-temp-file} is to prevent two different users or
2556 two different jobs from trying to use the exact same file name.
2558 @defun make-temp-file prefix &optional dir-flag suffix text
2559 This function creates a temporary file and returns its name. Emacs
2560 creates the temporary file's name by adding to @var{prefix} some
2561 random characters that are different in each Emacs job. The result is
2562 guaranteed to be a newly created file, containing @var{text} if that's
2563 given as a string and empty otherwise. On MS-DOS, this function
2564 can truncate the @var{string} prefix to fit into the 8+3 file-name
2565 limits. If @var{prefix} is a relative file name, it is expanded
2566 against @code{temporary-file-directory}.
2570 (make-temp-file "foo")
2571 @result{} "/tmp/foo232J6v"
2575 When @code{make-temp-file} returns, the file has been created and is
2576 empty. At that point, you should write the intended contents into the
2579 If @var{dir-flag} is non-@code{nil}, @code{make-temp-file} creates an
2580 empty directory instead of an empty file. It returns the file name,
2581 not the directory name, of that directory. @xref{Directory Names}.
2583 If @var{suffix} is non-@code{nil}, @code{make-temp-file} adds it at
2584 the end of the file name.
2586 If @var{text} is a string, @code{make-temp-file} inserts it in the file.
2588 To prevent conflicts among different libraries running in the same
2589 Emacs, each Lisp program that uses @code{make-temp-file} should have its
2590 own @var{prefix}. The number added to the end of @var{prefix}
2591 distinguishes between the same application running in different Emacs
2592 jobs. Additional added characters permit a large number of distinct
2593 names even in one Emacs job.
2596 The default directory for temporary files is controlled by the
2597 variable @code{temporary-file-directory}. This variable gives the user
2598 a uniform way to specify the directory for all temporary files. Some
2599 programs use @code{small-temporary-file-directory} instead, if that is
2600 non-@code{nil}. To use it, you should expand the prefix against
2601 the proper directory before calling @code{make-temp-file}.
2603 @defopt temporary-file-directory
2604 @cindex @env{TMPDIR} environment variable
2605 @cindex @env{TMP} environment variable
2606 @cindex @env{TEMP} environment variable
2607 This variable specifies the directory name for creating temporary files.
2608 Its value should be a directory name (@pxref{Directory Names}), but it
2609 is good for Lisp programs to cope if the value is a directory's file
2610 name instead. Using the value as the second argument to
2611 @code{expand-file-name} is a good way to achieve that.
2613 The default value is determined in a reasonable way for your operating
2614 system; it is based on the @env{TMPDIR}, @env{TMP} and @env{TEMP}
2615 environment variables, with a fall-back to a system-dependent name if
2616 none of these variables is defined.
2618 Even if you do not use @code{make-temp-file} to create the temporary
2619 file, you should still use this variable to decide which directory to
2620 put the file in. However, if you expect the file to be small, you
2621 should use @code{small-temporary-file-directory} first if that is
2625 @defopt small-temporary-file-directory
2626 This variable specifies the directory name for
2627 creating certain temporary files, which are likely to be small.
2629 If you want to write a temporary file which is likely to be small, you
2630 should compute the directory like this:
2634 (expand-file-name @var{prefix}
2635 (or small-temporary-file-directory
2636 temporary-file-directory)))
2640 @defun make-temp-name base-name
2641 This function generates a string that might be a unique file
2642 name. The name starts with @var{base-name}, and has several random
2643 characters appended to it, which are different in each Emacs job. It
2644 is like @code{make-temp-file} except that (i) it just constructs a
2645 name and does not create a file, (ii) @var{base-name} should be an
2646 absolute file name that is not magic, and (iii) if the returned file
2647 name is magic, it might name an existing file. @xref{Magic File
2650 @strong{Warning:} In most cases, you should not use this function; use
2651 @code{make-temp-file} instead! This function is susceptible to a race
2652 condition, between the @code{make-temp-name} call and the creation of
2653 the file, which in some cases may cause a security hole.
2656 Sometimes, it is necessary to create a temporary file on a remote host
2657 or a mounted directory. The following two functions support this.
2659 @defun make-nearby-temp-file prefix &optional dir-flag suffix
2660 This function is similar to @code{make-temp-file}, but it creates a
2661 temporary file as close as possible to @code{default-directory}. If
2662 @var{prefix} is a relative file name, and @code{default-directory} is
2663 a remote file name or located on a mounted file systems, the temporary
2664 file is created in the directory returned by the function
2665 @code{temporary-file-directory}. Otherwise, the function
2666 @code{make-temp-file} is used. @var{prefix}, @var{dir-flag} and
2667 @var{suffix} have the same meaning as in @code{make-temp-file}.
2671 (let ((default-directory "/ssh:remotehost:"))
2672 (make-nearby-temp-file "foo"))
2673 @result{} "/ssh:remotehost:/tmp/foo232J6v"
2678 @defun temporary-file-directory
2679 The directory for writing temporary files via
2680 @code{make-nearby-temp-file}. In case of a remote
2681 @code{default-directory}, this is a directory for temporary files on
2682 that remote host. If such a directory does not exist, or
2683 @code{default-directory} ought to be located on a mounted file system
2684 (see @code{mounted-file-systems}), the function returns
2685 @code{default-directory}. For a non-remote and non-mounted
2686 @code{default-directory}, the value of the variable
2687 @code{temporary-file-directory} is returned.
2690 In order to extract the local part of the path name from a temporary
2691 file, @code{file-local-name} could be used.
2693 @node File Name Completion
2694 @subsection File Name Completion
2695 @cindex file name completion subroutines
2696 @cindex completion, file name
2698 This section describes low-level subroutines for completing a file
2699 name. For higher level functions, see @ref{Reading File Names}.
2701 @defun file-name-all-completions partial-filename directory
2702 This function returns a list of all possible completions for a file
2703 whose name starts with @var{partial-filename} in directory
2704 @var{directory}. The order of the completions is the order of the files
2705 in the directory, which is unpredictable and conveys no useful
2708 The argument @var{partial-filename} must be a file name containing no
2709 directory part and no slash (or backslash on some systems). The current
2710 buffer's default directory is prepended to @var{directory}, if
2711 @var{directory} is not absolute.
2713 In the following example, suppose that @file{~rms/lewis} is the current
2714 default directory, and has five files whose names begin with @samp{f}:
2715 @file{foo}, @file{file~}, @file{file.c}, @file{file.c.~1~}, and
2720 (file-name-all-completions "f" "")
2721 @result{} ("foo" "file~" "file.c.~2~"
2722 "file.c.~1~" "file.c")
2726 (file-name-all-completions "fo" "")
2732 @defun file-name-completion filename directory &optional predicate
2733 This function completes the file name @var{filename} in directory
2734 @var{directory}. It returns the longest prefix common to all file names
2735 in directory @var{directory} that start with @var{filename}. If
2736 @var{predicate} is non-@code{nil} then it ignores possible completions
2737 that don't satisfy @var{predicate}, after calling that function
2738 with one argument, the expanded absolute file name.
2740 If only one match exists and @var{filename} matches it exactly, the
2741 function returns @code{t}. The function returns @code{nil} if directory
2742 @var{directory} contains no name starting with @var{filename}.
2744 In the following example, suppose that the current default directory
2745 has five files whose names begin with @samp{f}: @file{foo},
2746 @file{file~}, @file{file.c}, @file{file.c.~1~}, and
2751 (file-name-completion "fi" "")
2756 (file-name-completion "file.c.~1" "")
2757 @result{} "file.c.~1~"
2761 (file-name-completion "file.c.~1~" "")
2766 (file-name-completion "file.c.~3" "")
2772 @defopt completion-ignored-extensions
2773 @code{file-name-completion} usually ignores file names that end in any
2774 string in this list. It does not ignore them when all the possible
2775 completions end in one of these suffixes. This variable has no effect
2776 on @code{file-name-all-completions}.
2778 A typical value might look like this:
2782 completion-ignored-extensions
2783 @result{} (".o" ".elc" "~" ".dvi")
2787 If an element of @code{completion-ignored-extensions} ends in a slash
2788 @samp{/}, it signals a directory. The elements which do @emph{not} end
2789 in a slash will never match a directory; thus, the above value will not
2790 filter out a directory named @file{foo.elc}.
2793 @node Standard File Names
2794 @subsection Standard File Names
2796 Sometimes, an Emacs Lisp program needs to specify a standard file
2797 name for a particular use---typically, to hold configuration data
2798 specified by the current user. Usually, such files should be located
2799 in the directory specified by @code{user-emacs-directory}, which is
2800 @file{~/.emacs.d} by default (@pxref{Init File}). For example, abbrev
2801 definitions are stored by default in @file{~/.emacs.d/abbrev_defs}.
2802 The easiest way to specify such a file name is to use the function
2803 @code{locate-user-emacs-file}.
2805 @defun locate-user-emacs-file base-name &optional old-name
2806 This function returns an absolute file name for an Emacs-specific
2807 configuration or data file. The argument @file{base-name} should be a
2808 relative file name. The return value is the absolute name of a file
2809 in the directory specified by @code{user-emacs-directory}; if that
2810 directory does not exist, this function creates it.
2812 If the optional argument @var{old-name} is non-@code{nil}, it
2813 specifies a file in the user's home directory,
2814 @file{~/@var{old-name}}. If such a file exists, the return value is
2815 the absolute name of that file, instead of the file specified by
2816 @var{base-name}. This argument is intended to be used by Emacs
2817 packages to provide backward compatibility. For instance, prior to
2818 the introduction of @code{user-emacs-directory}, the abbrev file was
2819 located in @file{~/.abbrev_defs}. Here is the definition of
2820 @code{abbrev-file-name}:
2823 (defcustom abbrev-file-name
2824 (locate-user-emacs-file "abbrev_defs" ".abbrev_defs")
2825 "Default name of file from which to read abbrevs."
2831 A lower-level function for standardizing file names, which
2832 @code{locate-user-emacs-file} uses as a subroutine, is
2833 @code{convert-standard-filename}.
2835 @defun convert-standard-filename filename
2836 This function returns a file name based on @var{filename}, which fits
2837 the conventions of the current operating system.
2839 On GNU and other POSIX-like systems, this simply returns @var{filename}.
2840 On other operating systems, it may enforce system-specific file name
2841 conventions; for example, on MS-DOS this function performs a variety
2842 of changes to enforce MS-DOS file name limitations, including
2843 converting any leading @samp{.} to @samp{_} and truncating to three
2844 characters after the @samp{.}.
2846 The recommended way to use this function is to specify a name which
2847 fits the conventions of GNU and Unix systems, and pass it to
2848 @code{convert-standard-filename}.
2851 @node Contents of Directories
2852 @section Contents of Directories
2853 @cindex directory-oriented functions
2854 @cindex file names in directory
2856 A directory is a kind of file that contains other files entered under
2857 various names. Directories are a feature of the file system.
2859 Emacs can list the names of the files in a directory as a Lisp list,
2860 or display the names in a buffer using the @code{ls} shell command. In
2861 the latter case, it can optionally display information about each file,
2862 depending on the options passed to the @code{ls} command.
2864 @defun directory-files directory &optional full-name match-regexp nosort
2865 This function returns a list of the names of the files in the directory
2866 @var{directory}. By default, the list is in alphabetical order.
2868 If @var{full-name} is non-@code{nil}, the function returns the files'
2869 absolute file names. Otherwise, it returns the names relative to
2870 the specified directory.
2872 If @var{match-regexp} is non-@code{nil}, this function returns only
2873 those file names that contain a match for that regular expression---the
2874 other file names are excluded from the list. On case-insensitive
2875 filesystems, the regular expression matching is case-insensitive.
2878 If @var{nosort} is non-@code{nil}, @code{directory-files} does not sort
2879 the list, so you get the file names in no particular order. Use this if
2880 you want the utmost possible speed and don't care what order the files
2881 are processed in. If the order of processing is visible to the user,
2882 then the user will probably be happier if you do sort the names.
2886 (directory-files "~lewis")
2887 @result{} ("#foo#" "#foo.el#" "." ".."
2888 "dired-mods.el" "files.texi"
2893 An error is signaled if @var{directory} is not the name of a directory
2897 @defun directory-files-recursively directory regexp &optional include-directories
2898 Return all files under @var{directory} whose names match @var{regexp}.
2899 This function searches the specified @var{directory} and its
2900 sub-directories, recursively, for files whose basenames (i.e., without
2901 the leading directories) match the specified @var{regexp}, and returns
2902 a list of the absolute file names of the matching files
2903 (@pxref{Relative File Names, absolute file names}). The file names
2904 are returned in depth-first order, meaning that files in some
2905 sub-directory are returned before the files in its parent directory.
2906 In addition, matching files found in each subdirectory are sorted
2907 alphabetically by their basenames. By default, directories whose
2908 names match @var{regexp} are omitted from the list, but if the
2909 optional argument @var{include-directories} is non-@code{nil}, they
2913 @defun directory-files-and-attributes directory &optional full-name match-regexp nosort id-format
2914 This is similar to @code{directory-files} in deciding which files
2915 to report on and how to report their names. However, instead
2916 of returning a list of file names, it returns for each file a
2917 list @code{(@var{filename} . @var{attributes})}, where @var{attributes}
2918 is what @code{file-attributes} would return for that file.
2919 The optional argument @var{id-format} has the same meaning as the
2920 corresponding argument to @code{file-attributes} (@pxref{Definition
2921 of file-attributes}).
2924 @defun file-expand-wildcards pattern &optional full
2925 This function expands the wildcard pattern @var{pattern}, returning
2926 a list of file names that match it.
2928 If @var{pattern} is written as an absolute file name,
2929 the values are absolute also.
2931 If @var{pattern} is written as a relative file name, it is interpreted
2932 relative to the current default directory. The file names returned are
2933 normally also relative to the current default directory. However, if
2934 @var{full} is non-@code{nil}, they are absolute.
2937 @defun insert-directory file switches &optional wildcard full-directory-p
2938 This function inserts (in the current buffer) a directory listing for
2939 directory @var{file}, formatted with @code{ls} according to
2940 @var{switches}. It leaves point after the inserted text.
2941 @var{switches} may be a string of options, or a list of strings
2942 representing individual options.
2944 The argument @var{file} may be either a directory or a file
2945 specification including wildcard characters. If @var{wildcard} is
2946 non-@code{nil}, that means treat @var{file} as a file specification with
2949 If @var{full-directory-p} is non-@code{nil}, that means the directory
2950 listing is expected to show the full contents of a directory. You
2951 should specify @code{t} when @var{file} is a directory and switches do
2952 not contain @samp{-d}. (The @samp{-d} option to @code{ls} says to
2953 describe a directory itself as a file, rather than showing its
2956 On most systems, this function works by running a directory listing
2957 program whose name is in the variable @code{insert-directory-program}.
2958 If @var{wildcard} is non-@code{nil}, it also runs the shell specified by
2959 @code{shell-file-name}, to expand the wildcards.
2961 MS-DOS and MS-Windows systems usually lack the standard Unix program
2962 @code{ls}, so this function emulates the standard Unix program @code{ls}
2965 As a technical detail, when @var{switches} contains the long
2966 @samp{--dired} option, @code{insert-directory} treats it specially,
2967 for the sake of dired. However, the normally equivalent short
2968 @samp{-D} option is just passed on to @code{insert-directory-program},
2969 as any other option.
2972 @defvar insert-directory-program
2973 This variable's value is the program to run to generate a directory listing
2974 for the function @code{insert-directory}. It is ignored on systems
2975 which generate the listing with Lisp code.
2978 @node Create/Delete Dirs
2979 @section Creating, Copying and Deleting Directories
2980 @cindex creating, copying and deleting directories
2981 @c Emacs 19 features
2983 Most Emacs Lisp file-manipulation functions get errors when used on
2984 files that are directories. For example, you cannot delete a directory
2985 with @code{delete-file}. These special functions exist to create and
2989 @deffn Command make-directory dirname &optional parents
2990 This command creates a directory named @var{dirname}. If
2991 @var{parents} is non-@code{nil}, as is always the case in an
2992 interactive call, that means to create the parent directories first,
2993 if they don't already exist.
2995 @code{mkdir} is an alias for this.
2998 @deffn Command copy-directory dirname newname &optional keep-time parents copy-contents
2999 This command copies the directory named @var{dirname} to
3000 @var{newname}. If @var{newname} is a directory name,
3001 @var{dirname} will be copied to a subdirectory there.
3002 @xref{Directory Names}.
3004 It always sets the file modes of the copied files to match the
3005 corresponding original file.
3007 The third argument @var{keep-time} non-@code{nil} means to preserve the
3008 modification time of the copied files. A prefix arg makes
3009 @var{keep-time} non-@code{nil}.
3011 The fourth argument @var{parents} says whether to
3012 create parent directories if they don't exist. Interactively,
3013 this happens by default.
3015 The fifth argument @var{copy-contents}, if non-@code{nil}, means to
3016 copy the contents of @var{dirname} directly into @var{newname} if the
3017 latter is a directory name, instead of copying @var{dirname} into
3018 it as a subdirectory.
3022 @vindex delete-by-moving-to-trash
3023 @deffn Command delete-directory dirname &optional recursive trash
3024 This command deletes the directory named @var{dirname}. The function
3025 @code{delete-file} does not work for files that are directories; you
3026 must use @code{delete-directory} for them. If @var{recursive} is
3027 @code{nil}, and the directory contains any files,
3028 @code{delete-directory} signals an error.
3029 If recursive is non-@code{nil}, there is no error merely because the
3030 directory or its files are deleted by some other process before
3031 @code{delete-directory} gets to them.
3033 @code{delete-directory} only follows symbolic links at the level of
3036 If the optional argument @var{trash} is non-@code{nil} and the
3037 variable @code{delete-by-moving-to-trash} is non-@code{nil}, this
3038 command moves the file into the system Trash instead of deleting it.
3039 @xref{Misc File Ops,,Miscellaneous File Operations, emacs, The GNU
3040 Emacs Manual}. When called interactively, @var{trash} is @code{t} if
3041 no prefix argument is given, and @code{nil} otherwise.
3044 @node Magic File Names
3045 @section Making Certain File Names ``Magic''
3046 @cindex magic file names
3048 You can implement special handling for certain file names. This is
3049 called making those names @dfn{magic}. The principal use for this
3050 feature is in implementing access to remote files (@pxref{Remote Files,,
3051 Remote Files, emacs, The GNU Emacs Manual}).
3053 To define a kind of magic file name, you must supply a regular
3054 expression to define the class of names (all those that match the
3055 regular expression), plus a handler that implements all the primitive
3056 Emacs file operations for file names that match.
3058 @cindex file handler
3059 @vindex file-name-handler-alist
3060 The variable @code{file-name-handler-alist} holds a list of handlers,
3061 together with regular expressions that determine when to apply each
3062 handler. Each element has this form:
3065 (@var{regexp} . @var{handler})
3069 All the Emacs primitives for file access and file name transformation
3070 check the given file name against @code{file-name-handler-alist}. If
3071 the file name matches @var{regexp}, the primitives handle that file by
3072 calling @var{handler}.
3074 The first argument given to @var{handler} is the name of the
3075 primitive, as a symbol; the remaining arguments are the arguments that
3076 were passed to that primitive. (The first of these arguments is most
3077 often the file name itself.) For example, if you do this:
3080 (file-exists-p @var{filename})
3084 and @var{filename} has handler @var{handler}, then @var{handler} is
3088 (funcall @var{handler} 'file-exists-p @var{filename})
3091 When a function takes two or more arguments that must be file names,
3092 it checks each of those names for a handler. For example, if you do
3096 (expand-file-name @var{filename} @var{dirname})
3100 then it checks for a handler for @var{filename} and then for a handler
3101 for @var{dirname}. In either case, the @var{handler} is called like
3105 (funcall @var{handler} 'expand-file-name @var{filename} @var{dirname})
3109 The @var{handler} then needs to figure out whether to handle
3110 @var{filename} or @var{dirname}.
3112 If the specified file name matches more than one handler, the one
3113 whose match starts last in the file name gets precedence. This rule
3114 is chosen so that handlers for jobs such as uncompression are handled
3115 first, before handlers for jobs such as remote file access.
3117 Here are the operations that a magic file name handler gets to handle:
3121 @code{access-file}, @code{add-name-to-file},
3122 @code{byte-compiler-base-file-name},@*
3123 @code{copy-directory}, @code{copy-file},
3124 @code{delete-directory}, @code{delete-file},
3125 @code{diff-latest-backup-file},
3126 @code{directory-file-name},
3127 @code{directory-files},
3128 @code{directory-files-and-attributes},
3129 @code{dired-compress-file}, @code{dired-uncache},@*
3130 @code{expand-file-name},
3131 @code{file-accessible-directory-p},
3133 @code{file-attributes},
3134 @code{file-directory-p},
3135 @code{file-equal-p},
3136 @code{file-executable-p}, @code{file-exists-p},
3137 @code{file-in-directory-p},
3138 @code{file-local-copy},
3139 @code{file-modes}, @code{file-name-all-completions},
3140 @code{file-name-as-directory},
3141 @code{file-name-case-insensitive-p},
3142 @code{file-name-completion},
3143 @code{file-name-directory},
3144 @code{file-name-nondirectory},
3145 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
3146 @code{file-notify-add-watch}, @code{file-notify-rm-watch},
3147 @code{file-notify-valid-p},
3148 @code{file-ownership-preserved-p},
3149 @code{file-readable-p}, @code{file-regular-p},
3150 @code{file-remote-p}, @code{file-selinux-context},
3151 @code{file-symlink-p}, @code{file-system-info},
3152 @code{file-truename}, @code{file-writable-p},
3153 @code{find-backup-file-name},@*
3154 @code{get-file-buffer},
3155 @code{insert-directory},
3156 @code{insert-file-contents},@*
3158 @code{make-auto-save-file-name},
3159 @code{make-directory},
3160 @code{make-directory-internal},
3161 @code{make-nearby-temp-file},
3162 @code{make-symbolic-link},@*
3163 @code{process-file},
3164 @code{rename-file}, @code{set-file-acl}, @code{set-file-modes},
3165 @code{set-file-selinux-context}, @code{set-file-times},
3166 @code{set-visited-file-modtime}, @code{shell-command},
3167 @code{start-file-process},
3168 @code{substitute-in-file-name},@*
3169 @code{temporary-file-directory},
3170 @code{unhandled-file-name-directory},
3171 @code{vc-registered},
3172 @code{verify-visited-file-modtime},@*
3173 @code{write-region}.
3178 @code{access-file}, @code{add-name-to-file},
3179 @code{byte-com@discretionary{}{}{}piler-base-file-name},
3180 @code{copy-directory}, @code{copy-file},
3181 @code{delete-directory}, @code{delete-file},
3182 @code{diff-latest-backup-file},
3183 @code{directory-file-name},
3184 @code{directory-files},
3185 @code{directory-files-and-at@discretionary{}{}{}tributes},
3186 @code{dired-compress-file}, @code{dired-uncache},
3187 @code{expand-file-name},
3188 @code{file-accessible-direc@discretionary{}{}{}tory-p},
3190 @code{file-attributes},
3191 @code{file-direc@discretionary{}{}{}tory-p},
3192 @code{file-equal-p},
3193 @code{file-executable-p}, @code{file-exists-p},
3194 @code{file-in-directory-p},
3195 @code{file-local-copy},
3196 @code{file-modes}, @code{file-name-all-completions},
3197 @code{file-name-as-directory},
3198 @code{file-name-case-insensitive-p},
3199 @code{file-name-completion},
3200 @code{file-name-directory},
3201 @code{file-name-nondirec@discretionary{}{}{}tory},
3202 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
3203 @code{file-notify-add-watch}, @code{file-notify-rm-watch},
3204 @code{file-notify-valid-p},
3205 @code{file-ownership-pre@discretionary{}{}{}served-p},
3206 @code{file-readable-p}, @code{file-regular-p},
3207 @code{file-remote-p}, @code{file-selinux-context},
3208 @code{file-symlink-p}, @code{file-system-info},
3209 @code{file-truename}, @code{file-writable-p},
3210 @code{find-backup-file-name},
3211 @code{get-file-buffer},
3212 @code{insert-directory},
3213 @code{insert-file-contents},
3215 @code{make-auto-save-file-name},
3216 @code{make-direc@discretionary{}{}{}tory},
3217 @code{make-direc@discretionary{}{}{}tory-internal},
3218 @code{make-symbolic-link},
3219 @code{process-file},
3220 @code{rename-file}, @code{set-file-acl}, @code{set-file-modes},
3221 @code{set-file-selinux-context}, @code{set-file-times},
3222 @code{set-visited-file-modtime}, @code{shell-command},
3223 @code{start-file-process},
3224 @code{substitute-in-file-name},
3225 @code{unhandled-file-name-directory},
3226 @code{vc-regis@discretionary{}{}{}tered},
3227 @code{verify-visited-file-modtime},
3228 @code{write-region}.
3232 Handlers for @code{insert-file-contents} typically need to clear the
3233 buffer's modified flag, with @code{(set-buffer-modified-p nil)}, if the
3234 @var{visit} argument is non-@code{nil}. This also has the effect of
3235 unlocking the buffer if it is locked.
3237 The handler function must handle all of the above operations, and
3238 possibly others to be added in the future. It need not implement all
3239 these operations itself---when it has nothing special to do for a
3240 certain operation, it can reinvoke the primitive, to handle the
3241 operation in the usual way. It should always reinvoke the primitive
3242 for an operation it does not recognize. Here's one way to do this:
3245 (defun my-file-handler (operation &rest args)
3246 ;; @r{First check for the specific operations}
3247 ;; @r{that we have special handling for.}
3248 (cond ((eq operation 'insert-file-contents) @dots{})
3249 ((eq operation 'write-region) @dots{})
3251 ;; @r{Handle any operation we don't know about.}
3252 (t (let ((inhibit-file-name-handlers
3253 (cons 'my-file-handler
3254 (and (eq inhibit-file-name-operation operation)
3255 inhibit-file-name-handlers)))
3256 (inhibit-file-name-operation operation))
3257 (apply operation args)))))
3260 When a handler function decides to call the ordinary Emacs primitive for
3261 the operation at hand, it needs to prevent the primitive from calling
3262 the same handler once again, thus leading to an infinite recursion. The
3263 example above shows how to do this, with the variables
3264 @code{inhibit-file-name-handlers} and
3265 @code{inhibit-file-name-operation}. Be careful to use them exactly as
3266 shown above; the details are crucial for proper behavior in the case of
3267 multiple handlers, and for operations that have two file names that may
3270 @kindex safe-magic @r{(property)}
3271 Handlers that don't really do anything special for actual access to the
3272 file---such as the ones that implement completion of host names for
3273 remote file names---should have a non-@code{nil} @code{safe-magic}
3274 property. For instance, Emacs normally protects directory names
3275 it finds in @code{PATH} from becoming magic, if they look like magic
3276 file names, by prefixing them with @samp{/:}. But if the handler that
3277 would be used for them has a non-@code{nil} @code{safe-magic}
3278 property, the @samp{/:} is not added.
3280 @kindex operations @r{(property)}
3281 A file name handler can have an @code{operations} property to
3282 declare which operations it handles in a nontrivial way. If this
3283 property has a non-@code{nil} value, it should be a list of
3284 operations; then only those operations will call the handler. This
3285 avoids inefficiency, but its main purpose is for autoloaded handler
3286 functions, so that they won't be loaded except when they have real
3289 Simply deferring all operations to the usual primitives does not
3290 work. For instance, if the file name handler applies to
3291 @code{file-exists-p}, then it must handle @code{load} itself, because
3292 the usual @code{load} code won't work properly in that case. However,
3293 if the handler uses the @code{operations} property to say it doesn't
3294 handle @code{file-exists-p}, then it need not handle @code{load}
3297 @defvar inhibit-file-name-handlers
3298 This variable holds a list of handlers whose use is presently inhibited
3299 for a certain operation.
3302 @defvar inhibit-file-name-operation
3303 The operation for which certain handlers are presently inhibited.
3306 @defun find-file-name-handler file operation
3307 This function returns the handler function for file name @var{file},
3308 or @code{nil} if there is none. The argument @var{operation} should
3309 be the operation to be performed on the file---the value you will pass
3310 to the handler as its first argument when you call it. If
3311 @var{operation} equals @code{inhibit-file-name-operation}, or if it is
3312 not found in the @code{operations} property of the handler, this
3313 function returns @code{nil}.
3316 @defun file-local-copy filename
3317 This function copies file @var{filename} to an ordinary non-magic file
3318 on the local machine, if it isn't on the local machine already. Magic
3319 file names should handle the @code{file-local-copy} operation if they
3320 refer to files on other machines. A magic file name that is used for
3321 other purposes than remote file access should not handle
3322 @code{file-local-copy}; then this function will treat the file as
3325 If @var{filename} is local, whether magic or not, this function does
3326 nothing and returns @code{nil}. Otherwise it returns the file name
3327 of the local copy file.
3330 @defun file-remote-p filename &optional identification connected
3331 This function tests whether @var{filename} is a remote file. If
3332 @var{filename} is local (not remote), the return value is @code{nil}.
3333 If @var{filename} is indeed remote, the return value is a string that
3334 identifies the remote system.
3336 This identifier string can include a host name and a user name, as
3337 well as characters designating the method used to access the remote
3338 system. For example, the remote identifier string for the filename
3339 @code{/sudo::/some/file} is @code{/sudo:root@@localhost:}.
3341 If @code{file-remote-p} returns the same identifier for two different
3342 filenames, that means they are stored on the same file system and can
3343 be accessed locally with respect to each other. This means, for
3344 example, that it is possible to start a remote process accessing both
3345 files at the same time. Implementers of file handlers need to ensure
3346 this principle is valid.
3348 @var{identification} specifies which part of the identifier shall be
3349 returned as string. @var{identification} can be the symbol
3350 @code{method}, @code{user} or @code{host}; any other value is handled
3351 like @code{nil} and means to return the complete identifier string.
3352 In the example above, the remote @code{user} identifier string would
3355 If @var{connected} is non-@code{nil}, this function returns @code{nil}
3356 even if @var{filename} is remote, if Emacs has no network connection
3357 to its host. This is useful when you want to avoid the delay of
3358 making connections when they don't exist.
3361 @defun unhandled-file-name-directory filename
3362 This function returns the name of a directory that is not magic. For
3363 a non-magic @var{filename} it returns the corresponding directory name
3364 (@pxref{Directory Names}). For a magic @var{filename}, it invokes the
3365 file name handler, which therefore decides what value to return. If
3366 @var{filename} is not accessible from a local process, then the file
3367 name handler should indicate that by returning @code{nil}.
3369 This is useful for running a subprocess; every subprocess must have a
3370 non-magic directory to serve as its current directory, and this function
3371 is a good way to come up with one.
3374 @defun file-local-name filename
3375 This function returns the local part of file @var{filename}. For a
3376 remote @var{filename}, it returns a file name which could be used
3377 directly as argument of a remote process. If @var{filename} is local,
3378 this function returns the file name.
3381 @defopt remote-file-name-inhibit-cache
3382 The attributes of remote files can be cached for better performance. If
3383 they are changed outside of Emacs's control, the cached values become
3384 invalid, and must be reread.
3386 When this variable is set to @code{nil}, cached values are never
3387 expired. Use this setting with caution, only if you are sure nothing
3388 other than Emacs ever changes the remote files. If it is set to
3389 @code{t}, cached values are never used. This is the safest value, but
3390 could result in performance degradation.
3392 A compromise is to set it to a positive number. This means that
3393 cached values are used for that amount of seconds since they were
3394 cached. If a remote file is checked regularly, it might be a good
3395 idea to let-bind this variable to a value less than the time period
3396 between consecutive checks. For example:
3399 (defun display-time-file-nonempty-p (file)
3400 (let ((remote-file-name-inhibit-cache
3401 (- display-time-interval 5)))
3402 (and (file-exists-p file)
3403 (< 0 (nth 7 (file-attributes
3404 (file-chase-links file)))))))
3408 @node Format Conversion
3409 @section File Format Conversion
3411 @cindex file format conversion
3412 @cindex encoding file formats
3413 @cindex decoding file formats
3414 @cindex text properties in files
3415 @cindex saving text properties
3416 Emacs performs several steps to convert the data in a buffer (text,
3417 text properties, and possibly other information) to and from a
3418 representation suitable for storing into a file. This section describes
3419 the fundamental functions that perform this @dfn{format conversion},
3420 namely @code{insert-file-contents} for reading a file into a buffer,
3421 and @code{write-region} for writing a buffer into a file.
3424 * Overview: Format Conversion Overview. @code{insert-file-contents} and @code{write-region}.
3425 * Round-Trip: Format Conversion Round-Trip. Using @code{format-alist}.
3426 * Piecemeal: Format Conversion Piecemeal. Specifying non-paired conversion.
3429 @node Format Conversion Overview
3430 @subsection Overview
3432 The function @code{insert-file-contents}:
3435 @item initially, inserts bytes from the file into the buffer;
3436 @item decodes bytes to characters as appropriate;
3437 @item processes formats as defined by entries in @code{format-alist}; and
3438 @item calls functions in @code{after-insert-file-functions}.
3442 The function @code{write-region}:
3445 @item initially, calls functions in @code{write-region-annotate-functions};
3446 @item processes formats as defined by entries in @code{format-alist};
3447 @item encodes characters to bytes as appropriate; and
3448 @item modifies the file with the bytes.
3451 This shows the symmetry of the lowest-level operations; reading and
3452 writing handle things in opposite order. The rest of this section
3453 describes the two facilities surrounding the three variables named
3454 above, as well as some related functions. @ref{Coding Systems}, for
3455 details on character encoding and decoding.
3457 @node Format Conversion Round-Trip
3458 @subsection Round-Trip Specification
3460 The most general of the two facilities is controlled by the variable
3461 @code{format-alist}, a list of @dfn{file format} specifications, which
3462 describe textual representations used in files for the data in an Emacs
3463 buffer. The descriptions for reading and writing are paired, which is
3464 why we call this ``round-trip'' specification
3465 (@pxref{Format Conversion Piecemeal}, for non-paired specification).
3467 @defvar format-alist
3468 This list contains one format definition for each defined file format.
3469 Each format definition is a list of this form:
3472 (@var{name} @var{doc-string} @var{regexp} @var{from-fn} @var{to-fn} @var{modify} @var{mode-fn} @var{preserve})
3476 @cindex format definition
3478 Here is what the elements in a format definition mean:
3482 The name of this format.
3485 A documentation string for the format.
3488 A regular expression which is used to recognize files represented in
3489 this format. If @code{nil}, the format is never applied automatically.
3492 A shell command or function to decode data in this format (to convert
3493 file data into the usual Emacs data representation).
3495 A shell command is represented as a string; Emacs runs the command as a
3496 filter to perform the conversion.
3498 If @var{from-fn} is a function, it is called with two arguments, @var{begin}
3499 and @var{end}, which specify the part of the buffer it should convert.
3500 It should convert the text by editing it in place. Since this can
3501 change the length of the text, @var{from-fn} should return the modified
3504 One responsibility of @var{from-fn} is to make sure that the beginning
3505 of the file no longer matches @var{regexp}. Otherwise it is likely to
3506 get called again. Also, @var{from-fn} must not involve buffers or
3507 files other than the one being decoded, otherwise the internal buffer
3508 used for formatting might be overwritten.
3511 A shell command or function to encode data in this format---that is, to
3512 convert the usual Emacs data representation into this format.
3514 If @var{to-fn} is a string, it is a shell command; Emacs runs the
3515 command as a filter to perform the conversion.
3517 If @var{to-fn} is a function, it is called with three arguments:
3518 @var{begin} and @var{end}, which specify the part of the buffer it
3519 should convert, and @var{buffer}, which specifies which buffer. There
3520 are two ways it can do the conversion:
3524 By editing the buffer in place. In this case, @var{to-fn} should
3525 return the end-position of the range of text, as modified.
3528 By returning a list of annotations. This is a list of elements of the
3529 form @code{(@var{position} . @var{string})}, where @var{position} is an
3530 integer specifying the relative position in the text to be written, and
3531 @var{string} is the annotation to add there. The list must be sorted in
3532 order of position when @var{to-fn} returns it.
3534 When @code{write-region} actually writes the text from the buffer to the
3535 file, it intermixes the specified annotations at the corresponding
3536 positions. All this takes place without modifying the buffer.
3539 @var{to-fn} must not involve buffers or files other than the one being
3540 encoded, otherwise the internal buffer used for formatting might be
3544 A flag, @code{t} if the encoding function modifies the buffer, and
3545 @code{nil} if it works by returning a list of annotations.
3548 A minor-mode function to call after visiting a file converted from this
3549 format. The function is called with one argument, the integer 1;
3550 that tells a minor-mode function to enable the mode.
3553 A flag, @code{t} if @code{format-write-file} should not remove this format
3554 from @code{buffer-file-format}.
3557 The function @code{insert-file-contents} automatically recognizes file
3558 formats when it reads the specified file. It checks the text of the
3559 beginning of the file against the regular expressions of the format
3560 definitions, and if it finds a match, it calls the decoding function for
3561 that format. Then it checks all the known formats over again.
3562 It keeps checking them until none of them is applicable.
3564 Visiting a file, with @code{find-file-noselect} or the commands that use
3565 it, performs conversion likewise (because it calls
3566 @code{insert-file-contents}); it also calls the mode function for each
3567 format that it decodes. It stores a list of the format names in the
3568 buffer-local variable @code{buffer-file-format}.
3570 @defvar buffer-file-format
3571 This variable states the format of the visited file. More precisely,
3572 this is a list of the file format names that were decoded in the course
3573 of visiting the current buffer's file. It is always buffer-local in all
3577 When @code{write-region} writes data into a file, it first calls the
3578 encoding functions for the formats listed in @code{buffer-file-format},
3579 in the order of appearance in the list.
3581 @deffn Command format-write-file file format &optional confirm
3582 This command writes the current buffer contents into the file @var{file}
3583 in a format based on @var{format}, which is a list of format names. It
3584 constructs the actual format starting from @var{format}, then appending
3585 any elements from the value of @code{buffer-file-format} with a
3586 non-@code{nil} @var{preserve} flag (see above), if they are not already
3587 present in @var{format}. It then updates @code{buffer-file-format} with
3588 this format, making it the default for future saves. Except for the
3589 @var{format} argument, this command is similar to @code{write-file}. In
3590 particular, @var{confirm} has the same meaning and interactive treatment
3591 as the corresponding argument to @code{write-file}. @xref{Definition of
3595 @deffn Command format-find-file file format
3596 This command finds the file @var{file}, converting it according to
3597 format @var{format}. It also makes @var{format} the default if the
3598 buffer is saved later.
3600 The argument @var{format} is a list of format names. If @var{format} is
3601 @code{nil}, no conversion takes place. Interactively, typing just
3602 @key{RET} for @var{format} specifies @code{nil}.
3605 @deffn Command format-insert-file file format &optional beg end
3606 This command inserts the contents of file @var{file}, converting it
3607 according to format @var{format}. If @var{beg} and @var{end} are
3608 non-@code{nil}, they specify which part of the file to read, as in
3609 @code{insert-file-contents} (@pxref{Reading from Files}).
3611 The return value is like what @code{insert-file-contents} returns: a
3612 list of the absolute file name and the length of the data inserted
3615 The argument @var{format} is a list of format names. If @var{format} is
3616 @code{nil}, no conversion takes place. Interactively, typing just
3617 @key{RET} for @var{format} specifies @code{nil}.
3620 @defvar buffer-auto-save-file-format
3621 This variable specifies the format to use for auto-saving. Its value is
3622 a list of format names, just like the value of
3623 @code{buffer-file-format}; however, it is used instead of
3624 @code{buffer-file-format} for writing auto-save files. If the value
3625 is @code{t}, the default, auto-saving uses the same format as a
3626 regular save in the same buffer. This variable is always buffer-local
3630 @node Format Conversion Piecemeal
3631 @subsection Piecemeal Specification
3633 In contrast to the round-trip specification described in the previous
3634 subsection (@pxref{Format Conversion Round-Trip}), you can use the variables
3635 @code{after-insert-file-functions} and @code{write-region-annotate-functions}
3636 to separately control the respective reading and writing conversions.
3638 Conversion starts with one representation and produces another
3639 representation. When there is only one conversion to do, there is no
3640 conflict about what to start with. However, when there are multiple
3641 conversions involved, conflict may arise when two conversions need to
3642 start with the same data.
3644 This situation is best understood in the context of converting text
3645 properties during @code{write-region}. For example, the character at
3646 position 42 in a buffer is @samp{X} with a text property @code{foo}. If
3647 the conversion for @code{foo} is done by inserting into the buffer, say,
3648 @samp{FOO:}, then that changes the character at position 42 from
3649 @samp{X} to @samp{F}. The next conversion will start with the wrong
3652 To avoid conflict, cooperative conversions do not modify the buffer,
3653 but instead specify @dfn{annotations}, a list of elements of the form
3654 @code{(@var{position} . @var{string})}, sorted in order of increasing
3657 If there is more than one conversion, @code{write-region} merges their
3658 annotations destructively into one sorted list. Later, when the text
3659 from the buffer is actually written to the file, it intermixes the
3660 specified annotations at the corresponding positions. All this takes
3661 place without modifying the buffer.
3663 @c ??? What about "overriding" conversions like those allowed
3664 @c ??? for 'write-region-annotate-functions', below? --ttn
3666 In contrast, when reading, the annotations intermixed with the text
3667 are handled immediately. @code{insert-file-contents} sets point to
3668 the beginning of some text to be converted, then calls the conversion
3669 functions with the length of that text. These functions should always
3670 return with point at the beginning of the inserted text. This
3671 approach makes sense for reading because annotations removed by the
3672 first converter can't be mistakenly processed by a later converter.
3673 Each conversion function should scan for the annotations it
3674 recognizes, remove the annotation, modify the buffer text (to set a
3675 text property, for example), and return the updated length of the
3676 text, as it stands after those changes. The value returned by one
3677 function becomes the argument to the next function.
3679 @defvar write-region-annotate-functions
3680 A list of functions for @code{write-region} to call. Each function in
3681 the list is called with two arguments: the start and end of the region
3682 to be written. These functions should not alter the contents of the
3683 buffer. Instead, they should return annotations.
3685 As a special case, a function may return with a different buffer
3686 current. Emacs takes this to mean that the current buffer contains
3687 altered text to be output. It therefore changes the @var{start} and
3688 @var{end} arguments of the @code{write-region} call, giving them the
3689 values of @code{point-min} and @code{point-max} in the new buffer,
3690 respectively. It also discards all previous annotations, because they
3691 should have been dealt with by this function.
3694 @defvar write-region-post-annotation-function
3695 The value of this variable, if non-@code{nil}, should be a function.
3696 This function is called, with no arguments, after @code{write-region}
3699 If any function in @code{write-region-annotate-functions} returns with
3700 a different buffer current, Emacs calls
3701 @code{write-region-post-annotation-function} more than once. Emacs
3702 calls it with the last buffer that was current, and again with the
3703 buffer before that, and so on back to the original buffer.
3705 Thus, a function in @code{write-region-annotate-functions} can create
3706 a buffer, give this variable the local value of @code{kill-buffer} in
3707 that buffer, set up the buffer with altered text, and make the buffer
3708 current. The buffer will be killed after @code{write-region} is done.
3711 @defvar after-insert-file-functions
3712 Each function in this list is called by @code{insert-file-contents}
3713 with one argument, the number of characters inserted, and with point
3714 at the beginning of the inserted text. Each function should leave
3715 point unchanged, and return the new character count describing the
3716 inserted text as modified by the function.
3717 @c ??? The docstring mentions a handler from 'file-name-handler-alist'
3718 @c "intercepting" 'insert-file-contents'. Hmmm. --ttn
3721 We invite users to write Lisp programs to store and retrieve text
3722 properties in files, using these hooks, and thus to experiment with
3723 various data formats and find good ones. Eventually we hope users
3724 will produce good, general extensions we can install in Emacs.
3726 We suggest not trying to handle arbitrary Lisp objects as text property
3727 names or values---because a program that general is probably difficult
3728 to write, and slow. Instead, choose a set of possible data types that
3729 are reasonably flexible, and not too hard to encode.