2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
5 @setfilename ../info/files
6 @node Files, Backups and Auto-Saving, Documentation, Top
7 @comment node-name, next, previous, up
10 In Emacs, you can find, create, view, save, and otherwise work with
11 files and file directories. This chapter describes most of the
12 file-related functions of Emacs Lisp, but a few others are described in
13 @ref{Buffers}, and those related to backups and auto-saving are
14 described in @ref{Backups and Auto-Saving}.
16 Many of the file functions take one or more arguments that are file
17 names. A file name is actually a string. Most of these functions
18 expand file name arguments by calling @code{expand-file-name}, so that
19 @file{~} is handled correctly, as are relative file names (including
20 @samp{../}). These functions don't recognize environment variable
21 substitutions such as @samp{$HOME}. @xref{File Name Expansion}.
24 * Visiting Files:: Reading files into Emacs buffers for editing.
25 * Saving Buffers:: Writing changed buffers back into files.
26 * Reading from Files:: Reading files into buffers without visiting.
27 * Writing to Files:: Writing new files from parts of buffers.
28 * File Locks:: Locking and unlocking files, to prevent
29 simultaneous editing by two people.
30 * Information about Files:: Testing existence, accessibility, size of files.
31 * Changing Files:: Renaming files, changing protection, etc.
32 * File Names:: Decomposing and expanding file names.
33 * Contents of Directories:: Getting a list of the files in a directory.
34 * Create/Delete Dirs:: Creating and Deleting Directories.
35 * Magic File Names:: Defining "magic" special handling
36 for certain file names.
37 * Format Conversion:: Conversion to and from various file formats.
41 @section Visiting Files
43 @cindex visiting files
45 Visiting a file means reading a file into a buffer. Once this is
46 done, we say that the buffer is @dfn{visiting} that file, and call the
47 file ``the visited file'' of the buffer.
49 A file and a buffer are two different things. A file is information
50 recorded permanently in the computer (unless you delete it). A buffer,
51 on the other hand, is information inside of Emacs that will vanish at
52 the end of the editing session (or when you kill the buffer). Usually,
53 a buffer contains information that you have copied from a file; then we
54 say the buffer is visiting that file. The copy in the buffer is what
55 you modify with editing commands. Such changes to the buffer do not
56 change the file; therefore, to make the changes permanent, you must
57 @dfn{save} the buffer, which means copying the altered buffer contents
60 In spite of the distinction between files and buffers, people often
61 refer to a file when they mean a buffer and vice-versa. Indeed, we say,
62 ``I am editing a file,'' rather than, ``I am editing a buffer that I
63 will soon save as a file of the same name.'' Humans do not usually need
64 to make the distinction explicit. When dealing with a computer program,
65 however, it is good to keep the distinction in mind.
68 * Visiting Functions:: The usual interface functions for visiting.
69 * Subroutines of Visiting:: Lower-level subroutines that they use.
72 @node Visiting Functions
73 @subsection Functions for Visiting Files
75 This section describes the functions normally used to visit files.
76 For historical reasons, these functions have names starting with
77 @samp{find-} rather than @samp{visit-}. @xref{Buffer File Name}, for
78 functions and variables that access the visited file name of a buffer or
79 that find an existing buffer by its visited file name.
81 In a Lisp program, if you want to look at the contents of a file but
82 not alter it, the fastest way is to use @code{insert-file-contents} in a
83 temporary buffer. Visiting the file is not necessary and takes longer.
84 @xref{Reading from Files}.
86 @deffn Command find-file filename
87 This command selects a buffer visiting the file @var{filename},
88 using an existing buffer if there is one, and otherwise creating a
89 new buffer and reading the file into it. It also returns that buffer.
91 The body of the @code{find-file} function is very simple and looks
95 (switch-to-buffer (find-file-noselect filename))
99 (See @code{switch-to-buffer} in @ref{Displaying Buffers}.)
101 When @code{find-file} is called interactively, it prompts for
102 @var{filename} in the minibuffer.
105 @defun find-file-noselect filename &optional nowarn rawfile
106 This function is the guts of all the file-visiting functions. It finds
107 or creates a buffer visiting the file @var{filename}, and returns it.
108 It uses an existing buffer if there is one, and otherwise creates a new
109 buffer and reads the file into it. You may make the buffer current or
110 display it in a window if you wish, but this function does not do so.
112 When @code{find-file-noselect} uses an existing buffer, it first
113 verifies that the file has not changed since it was last visited or
114 saved in that buffer. If the file has changed, then this function asks
115 the user whether to reread the changed file. If the user says
116 @samp{yes}, any changes previously made in the buffer are lost.
118 This function displays warning or advisory messages in various peculiar
119 cases, unless the optional argument @var{nowarn} is non-@code{nil}. For
120 example, if it needs to create a buffer, and there is no file named
121 @var{filename}, it displays the message @samp{New file} in the echo
122 area, and leaves the buffer empty.
124 The @code{find-file-noselect} function normally calls
125 @code{after-find-file} after reading the file (@pxref{Subroutines of
126 Visiting}). That function sets the buffer major mode, parses local
127 variables, warns the user if there exists an auto-save file more recent
128 than the file just visited, and finishes by running the functions in
129 @code{find-file-hooks}.
131 If the optional argument @var{rawfile} is non-@code{nil}, then
132 @code{after-find-file} is not called, and the
133 @code{find-file-not-found-hooks} are not run in case of failure. What's
134 more, a non-@code{nil} @var{rawfile} value suppresses coding system
135 conversion (@pxref{Coding Systems}) and format conversion (@pxref{Format
138 The @code{find-file-noselect} function returns the buffer that is
139 visiting the file @var{filename}.
143 (find-file-noselect "/etc/fstab")
144 @result{} #<buffer fstab>
149 @deffn Command find-file-other-window filename
150 This command selects a buffer visiting the file @var{filename}, but
151 does so in a window other than the selected window. It may use another
152 existing window or split a window; see @ref{Displaying Buffers}.
154 When this command is called interactively, it prompts for
158 @deffn Command find-file-read-only filename
159 This command selects a buffer visiting the file @var{filename}, like
160 @code{find-file}, but it marks the buffer as read-only. @xref{Read Only
161 Buffers}, for related functions and variables.
163 When this command is called interactively, it prompts for
167 @deffn Command view-file filename
168 This command visits @var{filename} using View mode, returning to the
169 previous buffer when you exit View mode. View mode is a minor mode that
170 provides commands to skim rapidly through the file, but does not let you
171 modify the text. Entering View mode runs the normal hook
172 @code{view-mode-hook}. @xref{Hooks}.
174 When @code{view-file} is called interactively, it prompts for
178 @defvar find-file-hooks
179 The value of this variable is a list of functions to be called after a
180 file is visited. The file's local-variables specification (if any) will
181 have been processed before the hooks are run. The buffer visiting the
182 file is current when the hook functions are run.
184 This variable works just like a normal hook, but we think that renaming
185 it would not be advisable. @xref{Hooks}.
188 @defvar find-file-not-found-hooks
189 The value of this variable is a list of functions to be called when
190 @code{find-file} or @code{find-file-noselect} is passed a nonexistent
191 file name. @code{find-file-noselect} calls these functions as soon as
192 it detects a nonexistent file. It calls them in the order of the list,
193 until one of them returns non-@code{nil}. @code{buffer-file-name} is
196 This is not a normal hook because the values of the functions are
197 used, and in many cases only some of the functions are called.
200 @node Subroutines of Visiting
201 @comment node-name, next, previous, up
202 @subsection Subroutines of Visiting
204 The @code{find-file-noselect} function uses two important subroutines
205 which are sometimes useful in user Lisp code: @code{create-file-buffer}
206 and @code{after-find-file}. This section explains how to use them.
208 @defun create-file-buffer filename
209 This function creates a suitably named buffer for visiting
210 @var{filename}, and returns it. It uses @var{filename} (sans directory)
211 as the name if that name is free; otherwise, it appends a string such as
212 @samp{<2>} to get an unused name. See also @ref{Creating Buffers}.
214 @strong{Please note:} @code{create-file-buffer} does @emph{not}
215 associate the new buffer with a file and does not select the buffer.
216 It also does not use the default major mode.
220 (create-file-buffer "foo")
221 @result{} #<buffer foo>
224 (create-file-buffer "foo")
225 @result{} #<buffer foo<2>>
228 (create-file-buffer "foo")
229 @result{} #<buffer foo<3>>
233 This function is used by @code{find-file-noselect}.
234 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
237 @defun after-find-file &optional error warn
238 This function sets the buffer major mode, and parses local variables
239 (@pxref{Auto Major Mode}). It is called by @code{find-file-noselect}
240 and by the default revert function (@pxref{Reverting}).
242 @cindex new file message
243 @cindex file open error
244 If reading the file got an error because the file does not exist, but
245 its directory does exist, the caller should pass a non-@code{nil} value
246 for @var{error}. In that case, @code{after-find-file} issues a warning:
247 @samp{(New File)}. For more serious errors, the caller should usually not
248 call @code{after-find-file}.
250 If @var{warn} is non-@code{nil}, then this function issues a warning
251 if an auto-save file exists and is more recent than the visited file.
253 The last thing @code{after-find-file} does is call all the functions
254 in the list @code{find-file-hooks}.
258 @section Saving Buffers
260 When you edit a file in Emacs, you are actually working on a buffer
261 that is visiting that file---that is, the contents of the file are
262 copied into the buffer and the copy is what you edit. Changes to the
263 buffer do not change the file until you @dfn{save} the buffer, which
264 means copying the contents of the buffer into the file.
266 @deffn Command save-buffer &optional backup-option
267 This function saves the contents of the current buffer in its visited
268 file if the buffer has been modified since it was last visited or saved.
269 Otherwise it does nothing.
271 @code{save-buffer} is responsible for making backup files. Normally,
272 @var{backup-option} is @code{nil}, and @code{save-buffer} makes a backup
273 file only if this is the first save since visiting the file. Other
274 values for @var{backup-option} request the making of backup files in
279 With an argument of 4 or 64, reflecting 1 or 3 @kbd{C-u}'s, the
280 @code{save-buffer} function marks this version of the file to be
281 backed up when the buffer is next saved.
284 With an argument of 16 or 64, reflecting 2 or 3 @kbd{C-u}'s, the
285 @code{save-buffer} function unconditionally backs up the previous
286 version of the file before saving it.
290 @deffn Command save-some-buffers &optional save-silently-p exiting
291 This command saves some modified file-visiting buffers. Normally it
292 asks the user about each buffer. But if @var{save-silently-p} is
293 non-@code{nil}, it saves all the file-visiting buffers without querying
296 The optional @var{exiting} argument, if non-@code{nil}, requests this
297 function to offer also to save certain other buffers that are not
298 visiting files. These are buffers that have a non-@code{nil}
299 buffer-local value of @code{buffer-offer-save}. (A user who says yes to
300 saving one of these is asked to specify a file name to use.) The
301 @code{save-buffers-kill-emacs} function passes a non-@code{nil} value
305 @deffn Command write-file filename
306 This function writes the current buffer into file @var{filename}, makes
307 the buffer visit that file, and marks it not modified. Then it renames
308 the buffer based on @var{filename}, appending a string like @samp{<2>}
309 if necessary to make a unique buffer name. It does most of this work by
310 calling @code{set-visited-file-name} (@pxref{Buffer File Name}) and
314 Saving a buffer runs several hooks. It also performs format
315 conversion (@pxref{Format Conversion}), and may save text properties in
316 ``annotations'' (@pxref{Saving Properties}).
318 @defvar write-file-hooks
319 The value of this variable is a list of functions to be called before
320 writing out a buffer to its visited file. If one of them returns
321 non-@code{nil}, the file is considered already written and the rest of
322 the functions are not called, nor is the usual code for writing the file
325 If a function in @code{write-file-hooks} returns non-@code{nil}, it
326 is responsible for making a backup file (if that is appropriate).
327 To do so, execute the following code:
330 (or buffer-backed-up (backup-buffer))
333 You might wish to save the file modes value returned by
334 @code{backup-buffer} and use that to set the mode bits of the file that
335 you write. This is what @code{save-buffer} normally does.
337 The hook functions in @code{write-file-hooks} are also responsible for
338 encoding the data (if desired): they must choose a suitable coding
339 system (@pxref{Lisp and Coding Systems}), perform the encoding
340 (@pxref{Explicit Encoding}), and set @code{last-coding-system-used} to
341 the coding system that was used (@pxref{Encoding and I/O}).
343 Do not make this variable buffer-local. To set up buffer-specific hook
344 functions, use @code{write-contents-hooks} instead.
346 Even though this is not a normal hook, you can use @code{add-hook} and
347 @code{remove-hook} to manipulate the list. @xref{Hooks}.
351 @defvar local-write-file-hooks
352 This works just like @code{write-file-hooks}, but it is intended to be
353 made buffer-local in particular buffers, and used for hooks that pertain
354 to the file name or the way the buffer contents were obtained.
356 The variable is marked as a permanent local, so that changing the major
357 mode does not alter a buffer-local value. This is convenient for
358 packages that read ``file'' contents in special ways, and set up hooks
359 to save the data in a corresponding way.
363 @defvar write-contents-hooks
364 This works just like @code{write-file-hooks}, but it is intended for
365 hooks that pertain to the contents of the file, as opposed to hooks that
366 pertain to where the file came from. Such hooks are usually set up by
367 major modes, as buffer-local bindings for this variable.
369 This variable automatically becomes buffer-local whenever it is set;
370 switching to a new major mode always resets this variable. When you use
371 @code{add-hooks} to add an element to this hook, you should @emph{not}
372 specify a non-@code{nil} @var{local} argument, since this variable is
373 used @emph{only} buffer-locally.
377 @defvar after-save-hook
378 This normal hook runs after a buffer has been saved in its visited file.
379 One use of this hook is in Fast Lock mode; it uses this hook to save the
380 highlighting information in a cache file.
383 @defvar file-precious-flag
384 If this variable is non-@code{nil}, then @code{save-buffer} protects
385 against I/O errors while saving by writing the new file to a temporary
386 name instead of the name it is supposed to have, and then renaming it to
387 the intended name after it is clear there are no errors. This procedure
388 prevents problems such as a lack of disk space from resulting in an
391 As a side effect, backups are necessarily made by copying. @xref{Rename
392 or Copy}. Yet, at the same time, saving a precious file always breaks
393 all hard links between the file you save and other file names.
395 Some modes give this variable a non-@code{nil} buffer-local value
396 in particular buffers.
399 @defopt require-final-newline
400 This variable determines whether files may be written out that do
401 @emph{not} end with a newline. If the value of the variable is
402 @code{t}, then @code{save-buffer} silently adds a newline at the end of
403 the file whenever the buffer being saved does not already end in one.
404 If the value of the variable is non-@code{nil}, but not @code{t}, then
405 @code{save-buffer} asks the user whether to add a newline each time the
408 If the value of the variable is @code{nil}, then @code{save-buffer}
409 doesn't add newlines at all. @code{nil} is the default value, but a few
410 major modes set it to @code{t} in particular buffers.
413 See also the function @code{set-visited-file-name} (@pxref{Buffer File
416 @node Reading from Files
417 @comment node-name, next, previous, up
418 @section Reading from Files
420 You can copy a file from the disk and insert it into a buffer
421 using the @code{insert-file-contents} function. Don't use the user-level
422 command @code{insert-file} in a Lisp program, as that sets the mark.
424 @defun insert-file-contents filename &optional visit beg end replace
425 This function inserts the contents of file @var{filename} into the
426 current buffer after point. It returns a list of the absolute file name
427 and the length of the data inserted. An error is signaled if
428 @var{filename} is not the name of a file that can be read.
430 The function @code{insert-file-contents} checks the file contents
431 against the defined file formats, and converts the file contents if
432 appropriate. @xref{Format Conversion}. It also calls the functions in
433 the list @code{after-insert-file-functions}; see @ref{Saving
436 If @var{visit} is non-@code{nil}, this function additionally marks the
437 buffer as unmodified and sets up various fields in the buffer so that it
438 is visiting the file @var{filename}: these include the buffer's visited
439 file name and its last save file modtime. This feature is used by
440 @code{find-file-noselect} and you probably should not use it yourself.
442 If @var{beg} and @var{end} are non-@code{nil}, they should be integers
443 specifying the portion of the file to insert. In this case, @var{visit}
444 must be @code{nil}. For example,
447 (insert-file-contents filename nil 0 500)
451 inserts the first 500 characters of a file.
453 If the argument @var{replace} is non-@code{nil}, it means to replace the
454 contents of the buffer (actually, just the accessible portion) with the
455 contents of the file. This is better than simply deleting the buffer
456 contents and inserting the whole file, because (1) it preserves some
457 marker positions and (2) it puts less data in the undo list.
459 It is possible to read a special file (such as a FIFO or an I/O device)
460 with @code{insert-file-contents}, as long as @var{replace} and
461 @var{visit} are @code{nil}.
464 @defun insert-file-contents-literally filename &optional visit beg end replace
465 @tindex insert-file-contents-literally
466 This function works like @code{insert-file-contents} except that it does
467 not do format decoding (@pxref{Format Conversion}), does not do
468 character code conversion (@pxref{Coding Systems}), does not run
469 @code{find-file-hooks}, does not perform automatic uncompression, and so
473 If you want to pass a file name to another process so that another
474 program can read the file, use the function @code{file-local-copy}; see
475 @ref{Magic File Names}.
477 @node Writing to Files
478 @comment node-name, next, previous, up
479 @section Writing to Files
481 You can write the contents of a buffer, or part of a buffer, directly
482 to a file on disk using the @code{append-to-file} and
483 @code{write-region} functions. Don't use these functions to write to
484 files that are being visited; that could cause confusion in the
485 mechanisms for visiting.
487 @deffn Command append-to-file start end filename
488 This function appends the contents of the region delimited by
489 @var{start} and @var{end} in the current buffer to the end of file
490 @var{filename}. If that file does not exist, it is created. This
491 function returns @code{nil}.
493 An error is signaled if @var{filename} specifies a nonwritable file,
494 or a nonexistent file in a directory where files cannot be created.
497 @deffn Command write-region start end filename &optional append visit confirm
498 This function writes the region delimited by @var{start} and @var{end}
499 in the current buffer into the file specified by @var{filename}.
502 If @var{start} is a string, then @code{write-region} writes or appends
503 that string, rather than text from the buffer.
505 If @var{append} is non-@code{nil}, then the specified text is appended
506 to the existing file contents (if any).
508 If @var{confirm} is non-@code{nil}, then @code{write-region} asks
509 for confirmation if @var{filename} names an existing file.
511 If @var{visit} is @code{t}, then Emacs establishes an association
512 between the buffer and the file: the buffer is then visiting that file.
513 It also sets the last file modification time for the current buffer to
514 @var{filename}'s modtime, and marks the buffer as not modified. This
515 feature is used by @code{save-buffer}, but you probably should not use
519 If @var{visit} is a string, it specifies the file name to visit. This
520 way, you can write the data to one file (@var{filename}) while recording
521 the buffer as visiting another file (@var{visit}). The argument
522 @var{visit} is used in the echo area message and also for file locking;
523 @var{visit} is stored in @code{buffer-file-name}. This feature is used
524 to implement @code{file-precious-flag}; don't use it yourself unless you
525 really know what you're doing.
527 The function @code{write-region} converts the data which it writes to
528 the appropriate file formats specified by @code{buffer-file-format}.
529 @xref{Format Conversion}. It also calls the functions in the list
530 @code{write-region-annotate-functions}; see @ref{Saving Properties}.
532 Normally, @code{write-region} displays the message @samp{Wrote
533 @var{filename}} in the echo area. If @var{visit} is neither @code{t}
534 nor @code{nil} nor a string, then this message is inhibited. This
535 feature is useful for programs that use files for internal purposes,
536 files that the user does not need to know about.
539 @defmac with-temp-file file body...
540 @tindex with-temp-file
541 The @code{with-temp-file} macro evaluates the @var{body} forms with a
542 temporary buffer as the current buffer; then, at the end, it writes the
543 buffer contents into file @var{file}. It kills the temporary buffer
544 when finished, restoring the buffer that was current before the
545 @code{with-temp-file} form. Then it returns the value of the last form
548 The current buffer is restored even in case of an abnormal exit via
549 @code{throw} or error (@pxref{Nonlocal Exits}).
551 See also @code{with-temp-buffer} in @ref{Current Buffer}.
558 When two users edit the same file at the same time, they are likely to
559 interfere with each other. Emacs tries to prevent this situation from
560 arising by recording a @dfn{file lock} when a file is being modified.
561 Emacs can then detect the first attempt to modify a buffer visiting a
562 file that is locked by another Emacs job, and ask the user what to do.
564 File locks are not completely reliable when multiple machines can
565 share file systems. When file locks do not work, it is possible for two
566 users to make changes simultaneously, but Emacs can still warn the user
567 who saves second. Also, the detection of modification of a buffer
568 visiting a file changed on disk catches some cases of simultaneous
569 editing; see @ref{Modification Time}.
571 @defun file-locked-p filename
572 This function returns @code{nil} if the file @var{filename} is not
573 locked. It returns @code{t} if it is locked by this Emacs process, and
574 it returns the name of the user who has locked it if it is locked by
579 (file-locked-p "foo")
585 @defun lock-buffer &optional filename
586 This function locks the file @var{filename}, if the current buffer is
587 modified. The argument @var{filename} defaults to the current buffer's
588 visited file. Nothing is done if the current buffer is not visiting a
589 file, or is not modified.
593 This function unlocks the file being visited in the current buffer,
594 if the buffer is modified. If the buffer is not modified, then
595 the file should not be locked, so this function does nothing. It also
596 does nothing if the current buffer is not visiting a file.
599 @defun ask-user-about-lock file other-user
600 This function is called when the user tries to modify @var{file}, but it
601 is locked by another user named @var{other-user}. The default
602 definition of this function asks the user to say what to do. The value
603 this function returns determines what Emacs does next:
607 A value of @code{t} says to grab the lock on the file. Then
608 this user may edit the file and @var{other-user} loses the lock.
611 A value of @code{nil} says to ignore the lock and let this
612 user edit the file anyway.
616 This function may instead signal a @code{file-locked} error, in which
617 case the change that the user was about to make does not take place.
619 The error message for this error looks like this:
622 @error{} File is locked: @var{file} @var{other-user}
626 where @code{file} is the name of the file and @var{other-user} is the
627 name of the user who has locked the file.
630 If you wish, you can replace the @code{ask-user-about-lock} function
631 with your own version that makes the decision in another way. The code
632 for its usual definition is in @file{userlock.el}.
635 @node Information about Files
636 @section Information about Files
638 The functions described in this section all operate on strings that
639 designate file names. All the functions have names that begin with the
640 word @samp{file}. These functions all return information about actual
641 files or directories, so their arguments must all exist as actual files
642 or directories unless otherwise noted.
645 * Testing Accessibility:: Is a given file readable? Writable?
646 * Kinds of Files:: Is it a directory? A symbolic link?
647 * Truenames:: Eliminating symbolic links from a file name.
648 * File Attributes:: How large is it? Any other names? Etc.
651 @node Testing Accessibility
652 @comment node-name, next, previous, up
653 @subsection Testing Accessibility
654 @cindex accessibility of a file
655 @cindex file accessibility
657 These functions test for permission to access a file in specific ways.
659 @defun file-exists-p filename
660 This function returns @code{t} if a file named @var{filename} appears
661 to exist. This does not mean you can necessarily read the file, only
662 that you can find out its attributes. (On Unix, this is true if the
663 file exists and you have execute permission on the containing
664 directories, regardless of the protection of the file itself.)
666 If the file does not exist, or if fascist access control policies
667 prevent you from finding the attributes of the file, this function
671 @defun file-readable-p filename
672 This function returns @code{t} if a file named @var{filename} exists
673 and you can read it. It returns @code{nil} otherwise.
677 (file-readable-p "files.texi")
681 (file-exists-p "/usr/spool/mqueue")
685 (file-readable-p "/usr/spool/mqueue")
692 @defun file-executable-p filename
693 This function returns @code{t} if a file named @var{filename} exists and
694 you can execute it. It returns @code{nil} otherwise. If the file is a
695 directory, execute permission means you can check the existence and
696 attributes of files inside the directory, and open those files if their
700 @defun file-writable-p filename
701 This function returns @code{t} if the file @var{filename} can be written
702 or created by you, and @code{nil} otherwise. A file is writable if the
703 file exists and you can write it. It is creatable if it does not exist,
704 but the specified directory does exist and you can write in that
707 In the third example below, @file{foo} is not writable because the
708 parent directory does not exist, even though the user could create such
713 (file-writable-p "~/foo")
717 (file-writable-p "/foo")
721 (file-writable-p "~/no-such-dir/foo")
728 @defun file-accessible-directory-p dirname
729 This function returns @code{t} if you have permission to open existing
730 files in the directory whose name as a file is @var{dirname}; otherwise
731 (or if there is no such directory), it returns @code{nil}. The value
732 of @var{dirname} may be either a directory name or the file name of a
733 file which is a directory.
735 Example: after the following,
738 (file-accessible-directory-p "/foo")
743 we can deduce that any attempt to read a file in @file{/foo/} will
747 @defun access-file filename string
749 This function opens file @var{filename} for reading, then closes it and
750 returns @code{nil}. However, if the open fails, it signals an error
751 using @var{string} as the error message text.
754 @defun file-ownership-preserved-p filename
755 This function returns @code{t} if deleting the file @var{filename} and
756 then creating it anew would keep the file's owner unchanged.
759 @defun file-newer-than-file-p filename1 filename2
761 @cindex file modification time
762 This function returns @code{t} if the file @var{filename1} is
763 newer than file @var{filename2}. If @var{filename1} does not
764 exist, it returns @code{nil}. If @var{filename2} does not exist,
767 In the following example, assume that the file @file{aug-19} was written
768 on the 19th, @file{aug-20} was written on the 20th, and the file
769 @file{no-file} doesn't exist at all.
773 (file-newer-than-file-p "aug-19" "aug-20")
777 (file-newer-than-file-p "aug-20" "aug-19")
781 (file-newer-than-file-p "aug-19" "no-file")
785 (file-newer-than-file-p "no-file" "aug-19")
790 You can use @code{file-attributes} to get a file's last modification
791 time as a list of two numbers. @xref{File Attributes}.
795 @comment node-name, next, previous, up
796 @subsection Distinguishing Kinds of Files
798 This section describes how to distinguish various kinds of files, such
799 as directories, symbolic links, and ordinary files.
801 @defun file-symlink-p filename
802 @cindex file symbolic links
803 If the file @var{filename} is a symbolic link, the @code{file-symlink-p}
804 function returns the file name to which it is linked. This may be the
805 name of a text file, a directory, or even another symbolic link, or it
806 may be a nonexistent file name.
808 If the file @var{filename} is not a symbolic link (or there is no such file),
809 @code{file-symlink-p} returns @code{nil}.
813 (file-symlink-p "foo")
817 (file-symlink-p "sym-link")
821 (file-symlink-p "sym-link2")
825 (file-symlink-p "/bin")
830 @c !!! file-symlink-p: should show output of ls -l for comparison
833 @defun file-directory-p filename
834 This function returns @code{t} if @var{filename} is the name of an
835 existing directory, @code{nil} otherwise.
839 (file-directory-p "~rms")
843 (file-directory-p "~rms/lewis/files.texi")
847 (file-directory-p "~rms/lewis/no-such-file")
851 (file-directory-p "$HOME")
856 (substitute-in-file-name "$HOME"))
862 @defun file-regular-p filename
863 This function returns @code{t} if the file @var{filename} exists and is
864 a regular file (not a directory, symbolic link, named pipe, terminal, or
869 @subsection Truenames
870 @cindex truename (of file)
873 The @dfn{truename} of a file is the name that you get by following
874 symbolic links until none remain, then simplifying away @samp{.}@: and
875 @samp{..}@: appearing as components. Strictly speaking, a file need not
876 have a unique truename; the number of distinct truenames a file has is
877 equal to the number of hard links to the file. However, truenames are
878 useful because they eliminate symbolic links as a cause of name
881 @defun file-truename filename
882 The function @code{file-truename} returns the true name of the file
883 @var{filename}. This is the name that you get by following symbolic
884 links until none remain. The argument must be an absolute file name.
887 @xref{Buffer File Name}, for related information.
889 @node File Attributes
890 @comment node-name, next, previous, up
891 @subsection Other Information about Files
893 This section describes the functions for getting detailed information
894 about a file, other than its contents. This information includes the
895 mode bits that control access permission, the owner and group numbers,
896 the number of names, the inode number, the size, and the times of access
899 @defun file-modes filename
901 @cindex file attributes
902 This function returns the mode bits of @var{filename}, as an integer.
903 The mode bits are also called the file permissions, and they specify
904 access control in the usual Unix fashion. If the low-order bit is 1,
905 then the file is executable by all users, if the second-lowest-order bit
906 is 1, then the file is writable by all users, etc.
908 The highest value returnable is 4095 (7777 octal), meaning that
909 everyone has read, write, and execute permission, that the @sc{suid} bit
910 is set for both others and group, and that the sticky bit is set.
914 (file-modes "~/junk/diffs")
915 @result{} 492 ; @r{Decimal integer.}
919 @result{} "754" ; @r{Convert to octal.}
923 (set-file-modes "~/junk/diffs" 438)
929 @result{} "666" ; @r{Convert to octal.}
934 -rw-rw-rw- 1 lewis 0 3063 Oct 30 16:00 diffs
939 @defun file-nlinks filename
940 This functions returns the number of names (i.e., hard links) that
941 file @var{filename} has. If the file does not exist, then this function
942 returns @code{nil}. Note that symbolic links have no effect on this
943 function, because they are not considered to be names of the files they
949 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo
950 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo1
958 (file-nlinks "doesnt-exist")
964 @defun file-attributes filename
965 This function returns a list of attributes of file @var{filename}. If
966 the specified file cannot be opened, it returns @code{nil}.
968 The elements of the list, in order, are:
972 @code{t} for a directory, a string for a symbolic link (the name
973 linked to), or @code{nil} for a text file.
975 @c Wordy so as to prevent an overfull hbox. --rjc 15mar92
977 The number of names the file has. Alternate names, also known as hard
978 links, can be created by using the @code{add-name-to-file} function
979 (@pxref{Changing Files}).
988 The time of last access, as a list of two integers.
989 The first integer has the high-order 16 bits of time,
990 the second has the low 16 bits. (This is similar to the
991 value of @code{current-time}; see @ref{Time of Day}.)
994 The time of last modification as a list of two integers (as above).
997 The time of last status change as a list of two integers (as above).
1000 The size of the file in bytes.
1003 The file's modes, as a string of ten letters or dashes,
1007 @code{t} if the file's @sc{gid} would change if file were
1008 deleted and recreated; @code{nil} otherwise.
1011 The file's inode number. If possible, this is an integer. If the inode
1012 number is too large to be represented as an integer in Emacs Lisp, then
1013 the value has the form @code{(@var{high} . @var{low})}, where @var{low}
1014 holds the low 16 bits.
1017 The file system number of the file system that the file is in. This
1018 element and the file's inode number together give enough information to
1019 distinguish any two files on the system---no two files can have the same
1020 values for both of these numbers.
1023 For example, here are the file attributes for @file{files.texi}:
1027 (file-attributes "files.texi")
1028 @result{} (nil 1 2235 75
1038 and here is how the result is interpreted:
1042 is neither a directory nor a symbolic link.
1045 has only one name (the name @file{files.texi} in the current default
1049 is owned by the user with @sc{uid} 2235.
1052 is in the group with @sc{gid} 75.
1055 was last accessed on Aug 19 00:09.
1058 was last modified on Aug 19 00:09.
1061 last had its inode changed on Aug 19 00:09.
1064 is 14906 characters long.
1067 has a mode of read and write access for the owner, group, and world.
1070 would retain the same @sc{gid} if it were recreated.
1073 has an inode number of 129500.
1075 is on file system number -32252.
1079 @node Changing Files
1080 @section Changing File Names and Attributes
1081 @cindex renaming files
1082 @cindex copying files
1083 @cindex deleting files
1084 @cindex linking files
1085 @cindex setting modes of files
1087 The functions in this section rename, copy, delete, link, and set the
1090 In the functions that have an argument @var{newname}, if a file by the
1091 name of @var{newname} already exists, the actions taken depend on the
1092 value of the argument @var{ok-if-already-exists}:
1096 Signal a @code{file-already-exists} error if
1097 @var{ok-if-already-exists} is @code{nil}.
1100 Request confirmation if @var{ok-if-already-exists} is a number.
1103 Replace the old file without confirmation if @var{ok-if-already-exists}
1107 @defun add-name-to-file oldname newname &optional ok-if-already-exists
1108 @cindex file with multiple names
1109 @cindex file hard link
1110 This function gives the file named @var{oldname} the additional name
1111 @var{newname}. This means that @var{newname} becomes a new ``hard
1112 link'' to @var{oldname}.
1114 In the first part of the following example, we list two files,
1115 @file{foo} and @file{foo3}.
1120 81908 -rw-rw-rw- 1 rms 29 Aug 18 20:32 foo
1121 84302 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1125 Now we create a hard link, by calling @code{add-name-to-file}, then list
1126 the files again. This shows two names for one file, @file{foo} and
1131 (add-name-to-file "foo" "foo2")
1137 81908 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo
1138 81908 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo2
1139 84302 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1143 Finally, we evaluate the following:
1146 (add-name-to-file "foo" "foo3" t)
1150 and list the files again. Now there are three names
1151 for one file: @file{foo}, @file{foo2}, and @file{foo3}. The old
1152 contents of @file{foo3} are lost.
1156 (add-name-to-file "foo1" "foo3")
1162 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo
1163 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo2
1164 81908 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo3
1168 This function is meaningless on operating systems where multiple names
1169 for one file are not allowed.
1171 See also @code{file-nlinks} in @ref{File Attributes}.
1174 @deffn Command rename-file filename newname &optional ok-if-already-exists
1175 This command renames the file @var{filename} as @var{newname}.
1177 If @var{filename} has additional names aside from @var{filename}, it
1178 continues to have those names. In fact, adding the name @var{newname}
1179 with @code{add-name-to-file} and then deleting @var{filename} has the
1180 same effect as renaming, aside from momentary intermediate states.
1182 In an interactive call, this function prompts for @var{filename} and
1183 @var{newname} in the minibuffer; also, it requests confirmation if
1184 @var{newname} already exists.
1187 @deffn Command copy-file oldname newname &optional ok-if-exists time
1188 This command copies the file @var{oldname} to @var{newname}. An
1189 error is signaled if @var{oldname} does not exist.
1191 If @var{time} is non-@code{nil}, then this function gives the new file
1192 the same last-modified time that the old one has. (This works on only
1193 some operating systems.) If setting the time gets an error,
1194 @code{copy-file} signals a @code{file-date-error} error.
1196 In an interactive call, this function prompts for @var{filename} and
1197 @var{newname} in the minibuffer; also, it requests confirmation if
1198 @var{newname} already exists.
1201 @deffn Command delete-file filename
1203 This command deletes the file @var{filename}, like the shell command
1204 @samp{rm @var{filename}}. If the file has multiple names, it continues
1205 to exist under the other names.
1207 A suitable kind of @code{file-error} error is signaled if the file
1208 does not exist, or is not deletable. (On Unix, a file is deletable if
1209 its directory is writable.)
1211 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1214 @deffn Command make-symbolic-link filename newname &optional ok-if-exists
1216 @kindex file-already-exists
1217 This command makes a symbolic link to @var{filename}, named
1218 @var{newname}. This is like the shell command @samp{ln -s
1219 @var{filename} @var{newname}}.
1221 In an interactive call, this function prompts for @var{filename} and
1222 @var{newname} in the minibuffer; also, it requests confirmation if
1223 @var{newname} already exists.
1226 @defun define-logical-name varname string
1227 This function defines the logical name @var{name} to have the value
1228 @var{string}. It is available only on VMS.
1231 @defun set-file-modes filename mode
1232 This function sets mode bits of @var{filename} to @var{mode} (which must
1233 be an integer). Only the low 12 bits of @var{mode} are used.
1237 @defun set-default-file-modes mode
1238 This function sets the default file protection for new files created by
1239 Emacs and its subprocesses. Every file created with Emacs initially has
1240 this protection. On Unix, the default protection is the bitwise
1241 complement of the ``umask'' value.
1243 The argument @var{mode} must be an integer. On most systems, only the
1244 low 9 bits of @var{mode} are meaningful.
1246 Saving a modified version of an existing file does not count as creating
1247 the file; it does not change the file's mode, and does not use the
1248 default file protection.
1251 @defun default-file-modes
1252 This function returns the current default protection value.
1255 @cindex MS-DOS and file modes
1256 @cindex file modes and MS-DOS
1257 On MS-DOS, there is no such thing as an ``executable'' file mode bit.
1258 So Emacs considers a file executable if its name ends in @samp{.com},
1259 @samp{.bat} or @samp{.exe}. This is reflected in the values returned
1260 by @code{file-modes} and @code{file-attributes}.
1266 Files are generally referred to by their names, in Emacs as elsewhere.
1267 File names in Emacs are represented as strings. The functions that
1268 operate on a file all expect a file name argument.
1270 In addition to operating on files themselves, Emacs Lisp programs
1271 often need to operate on file names; i.e., to take them apart and to use
1272 part of a name to construct related file names. This section describes
1273 how to manipulate file names.
1275 The functions in this section do not actually access files, so they
1276 can operate on file names that do not refer to an existing file or
1279 On VMS, all these functions understand both VMS file-name syntax and
1280 Unix syntax. This is so that all the standard Lisp libraries can
1281 specify file names in Unix syntax and work properly on VMS without
1282 change. On MS-DOS and MS-Windows, these functions understand MS-DOS or
1283 MS-Windows file-name syntax as well as Unix syntax.
1286 * File Name Components:: The directory part of a file name, and the rest.
1287 * Directory Names:: A directory's name as a directory
1288 is different from its name as a file.
1289 * Relative File Names:: Some file names are relative to a current directory.
1290 * File Name Expansion:: Converting relative file names to absolute ones.
1291 * Unique File Names:: Generating names for temporary files.
1292 * File Name Completion:: Finding the completions for a given file name.
1293 * Standard File Names:: If your package uses a fixed file name,
1294 how to handle various operating systems simply.
1297 @node File Name Components
1298 @subsection File Name Components
1299 @cindex directory part (of file name)
1300 @cindex nondirectory part (of file name)
1301 @cindex version number (in file name)
1303 The operating system groups files into directories. To specify a
1304 file, you must specify the directory and the file's name within that
1305 directory. Therefore, Emacs considers a file name as having two main
1306 parts: the @dfn{directory name} part, and the @dfn{nondirectory} part
1307 (or @dfn{file name within the directory}). Either part may be empty.
1308 Concatenating these two parts reproduces the original file name.
1310 On Unix, the directory part is everything up to and including the last
1311 slash; the nondirectory part is the rest. The rules in VMS syntax are
1314 For some purposes, the nondirectory part is further subdivided into
1315 the name proper and the @dfn{version number}. On Unix, only backup
1316 files have version numbers in their names. On VMS, every file has a
1317 version number, but most of the time the file name actually used in
1318 Emacs omits the version number, so that version numbers in Emacs are
1319 found mostly in directory lists.
1321 @defun file-name-directory filename
1322 This function returns the directory part of @var{filename} (or
1323 @code{nil} if @var{filename} does not include a directory part). On
1324 Unix, the function returns a string ending in a slash. On VMS, it
1325 returns a string ending in one of the three characters @samp{:},
1326 @samp{]}, or @samp{>}.
1330 (file-name-directory "lewis/foo") ; @r{Unix example}
1334 (file-name-directory "foo") ; @r{Unix example}
1338 (file-name-directory "[X]FOO.TMP") ; @r{VMS example}
1344 @defun file-name-nondirectory filename
1345 This function returns the nondirectory part of @var{filename}.
1349 (file-name-nondirectory "lewis/foo")
1353 (file-name-nondirectory "foo")
1357 ;; @r{The following example is accurate only on VMS.}
1358 (file-name-nondirectory "[X]FOO.TMP")
1364 @defun file-name-sans-versions filename
1365 This function returns @var{filename} with any file version numbers,
1366 backup version numbers, or trailing tildes deleted.
1370 (file-name-sans-versions "~rms/foo.~1~")
1371 @result{} "~rms/foo"
1374 (file-name-sans-versions "~rms/foo~")
1375 @result{} "~rms/foo"
1378 (file-name-sans-versions "~rms/foo")
1379 @result{} "~rms/foo"
1382 ;; @r{The following example applies to VMS only.}
1383 (file-name-sans-versions "foo;23")
1389 @defun file-name-sans-extension filename
1390 This function returns @var{filename} minus its ``extension,'' if any.
1391 The extension, in a file name, is the part that starts with the last
1392 @samp{.} in the last name component. For example,
1395 (file-name-sans-extension "foo.lose.c")
1396 @result{} "foo.lose"
1397 (file-name-sans-extension "big.hack/foo")
1398 @result{} "big.hack/foo"
1402 @node Directory Names
1403 @comment node-name, next, previous, up
1404 @subsection Directory Names
1405 @cindex directory name
1406 @cindex file name of directory
1408 A @dfn{directory name} is the name of a directory. A directory is a
1409 kind of file, and it has a file name, which is related to the directory
1410 name but not identical to it. (This is not quite the same as the usual
1411 Unix terminology.) These two different names for the same entity are
1412 related by a syntactic transformation. On Unix, this is simple: a
1413 directory name ends in a slash, whereas the directory's name as a file
1414 lacks that slash. On VMS, the relationship is more complicated.
1416 The difference between a directory name and its name as a file is
1417 subtle but crucial. When an Emacs variable or function argument is
1418 described as being a directory name, a file name of a directory is not
1421 The following two functions convert between directory names and file
1422 names. They do nothing special with environment variable substitutions
1423 such as @samp{$HOME}, and the constructs @samp{~}, and @samp{..}.
1425 @defun file-name-as-directory filename
1426 This function returns a string representing @var{filename} in a form
1427 that the operating system will interpret as the name of a directory. In
1428 Unix, this means appending a slash to the string (if it does not already
1429 end in one). On VMS, the function converts a string of the form
1430 @file{[X]Y.DIR.1} to the form @file{[X.Y]}.
1434 (file-name-as-directory "~rms/lewis")
1435 @result{} "~rms/lewis/"
1440 @defun directory-file-name dirname
1441 This function returns a string representing @var{dirname} in a form that
1442 the operating system will interpret as the name of a file. On Unix,
1443 this means removing the final slash from the string. On VMS, the
1444 function converts a string of the form @file{[X.Y]} to
1449 (directory-file-name "~lewis/")
1455 @cindex directory name abbreviation
1456 Directory name abbreviations are useful for directories that are
1457 normally accessed through symbolic links. Sometimes the users recognize
1458 primarily the link's name as ``the name'' of the directory, and find it
1459 annoying to see the directory's ``real'' name. If you define the link
1460 name as an abbreviation for the ``real'' name, Emacs shows users the
1461 abbreviation instead.
1463 @defvar directory-abbrev-alist
1464 The variable @code{directory-abbrev-alist} contains an alist of
1465 abbreviations to use for file directories. Each element has the form
1466 @code{(@var{from} . @var{to})}, and says to replace @var{from} with
1467 @var{to} when it appears in a directory name. The @var{from} string is
1468 actually a regular expression; it should always start with @samp{^}.
1469 The function @code{abbreviate-file-name} performs these substitutions.
1471 You can set this variable in @file{site-init.el} to describe the
1472 abbreviations appropriate for your site.
1474 Here's an example, from a system on which file system @file{/home/fsf}
1475 and so on are normally accessed through symbolic links named @file{/fsf}
1479 (("^/home/fsf" . "/fsf")
1480 ("^/home/gp" . "/gp")
1481 ("^/home/gd" . "/gd"))
1485 To convert a directory name to its abbreviation, use this
1488 @defun abbreviate-file-name dirname
1489 This function applies abbreviations from @code{directory-abbrev-alist}
1490 to its argument, and substitutes @samp{~} for the user's home
1494 @node Relative File Names
1495 @subsection Absolute and Relative File Names
1496 @cindex absolute file name
1497 @cindex relative file name
1499 All the directories in the file system form a tree starting at the
1500 root directory. A file name can specify all the directory names
1501 starting from the root of the tree; then it is called an @dfn{absolute}
1502 file name. Or it can specify the position of the file in the tree
1503 relative to a default directory; then it is called a @dfn{relative}
1504 file name. On Unix, an absolute file name starts with a slash or a
1505 tilde (@samp{~}), and a relative one does not. The rules on VMS are
1508 @defun file-name-absolute-p filename
1509 This function returns @code{t} if file @var{filename} is an absolute
1510 file name, @code{nil} otherwise. On VMS, this function understands both
1511 Unix syntax and VMS syntax.
1515 (file-name-absolute-p "~rms/foo")
1519 (file-name-absolute-p "rms/foo")
1523 (file-name-absolute-p "/user/rms/foo")
1529 @node File Name Expansion
1530 @subsection Functions that Expand Filenames
1531 @cindex expansion of file names
1533 @dfn{Expansion} of a file name means converting a relative file name
1534 to an absolute one. Since this is done relative to a default directory,
1535 you must specify the default directory name as well as the file name to
1536 be expanded. Expansion also simplifies file names by eliminating
1537 redundancies such as @file{./} and @file{@var{name}/../}.
1539 @defun expand-file-name filename &optional directory
1540 This function converts @var{filename} to an absolute file name. If
1541 @var{directory} is supplied, it is the default directory to start with
1542 if @var{filename} is relative. (The value of @var{directory} should
1543 itself be an absolute directory name; it may start with @samp{~}.)
1544 Otherwise, the current buffer's value of @code{default-directory} is
1549 (expand-file-name "foo")
1550 @result{} "/xcssun/users/rms/lewis/foo"
1553 (expand-file-name "../foo")
1554 @result{} "/xcssun/users/rms/foo"
1557 (expand-file-name "foo" "/usr/spool/")
1558 @result{} "/usr/spool/foo"
1561 (expand-file-name "$HOME/foo")
1562 @result{} "/xcssun/users/rms/lewis/$HOME/foo"
1566 Filenames containing @samp{.} or @samp{..} are simplified to their
1571 (expand-file-name "bar/../foo")
1572 @result{} "/xcssun/users/rms/lewis/foo"
1576 Note that @code{expand-file-name} does @emph{not} expand environment
1577 variables; only @code{substitute-in-file-name} does that.
1581 @defun file-relative-name filename directory
1582 This function does the inverse of expansion---it tries to return a
1583 relative name that is equivalent to @var{filename} when interpreted
1584 relative to @var{directory}.
1586 On some operating systems, an absolute file name begins with a device
1587 name. On such systems, @var{filename} has no relative equivalent based
1588 on @var{directory} if they start with two different device names. In
1589 this case, @code{file-relative-name} returns @var{filename} in absolute
1593 (file-relative-name "/foo/bar" "/foo/")
1595 (file-relative-name "/foo/bar" "/hack/")
1596 @result{} "/foo/bar"
1600 @defvar default-directory
1601 The value of this buffer-local variable is the default directory for the
1602 current buffer. It should be an absolute directory name; it may start
1603 with @samp{~}. This variable is buffer-local in every buffer.
1605 @code{expand-file-name} uses the default directory when its second
1606 argument is @code{nil}.
1608 On Unix systems, the value is always a string ending with a slash.
1613 @result{} "/user/lewis/manual/"
1618 @defun substitute-in-file-name filename
1619 This function replaces environment variables references in
1620 @var{filename} with the environment variable values. Following standard
1621 Unix shell syntax, @samp{$} is the prefix to substitute an environment
1624 The environment variable name is the series of alphanumeric characters
1625 (including underscores) that follow the @samp{$}. If the character following
1626 the @samp{$} is a @samp{@{}, then the variable name is everything up to the
1629 @c Wordy to avoid overfull hbox. --rjc 15mar92
1630 Here we assume that the environment variable @code{HOME}, which holds
1631 the user's home directory name, has value @samp{/xcssun/users/rms}.
1635 (substitute-in-file-name "$HOME/foo")
1636 @result{} "/xcssun/users/rms/foo"
1640 After substitution, if a @samp{~} or a @samp{/} appears following a
1641 @samp{/}, everything before the following @samp{/} is discarded:
1645 (substitute-in-file-name "bar/~/foo")
1649 (substitute-in-file-name "/usr/local/$HOME/foo")
1650 @result{} "/xcssun/users/rms/foo"
1651 ;; @r{@file{/usr/local/} has been discarded.}
1655 On VMS, @samp{$} substitution is not done, so this function does nothing
1656 on VMS except discard superfluous initial components as shown above.
1659 @node Unique File Names
1660 @subsection Generating Unique File Names
1662 Some programs need to write temporary files. Here is the usual way to
1663 construct a name for such a file:
1667 (expand-file-name @var{name-of-application}
1668 temporary-file-directory))
1672 The job of @code{make-temp-name} is to prevent two different users or
1673 two different jobs from trying to use the exact same file name. This
1674 example uses the variable @code{temporary-file-directory} to decide
1675 where to put the temporary file. All Emacs Lisp programs should
1676 use @code{temporary-file-directory} for this purpose, to give the user
1677 a uniform way to specify the directory for all temporary files.
1679 @defun make-temp-name string
1680 This function generates a string that can be used as a unique file name.
1681 The name starts with @var{string}, and contains a number that is
1682 different in each Emacs job.
1686 (make-temp-name "/tmp/foo")
1687 @result{} "/tmp/foo232J6v"
1691 To prevent conflicts among different libraries running in the same
1692 Emacs, each Lisp program that uses @code{make-temp-name} should have its
1693 own @var{string}. The number added to the end of @var{string}
1694 distinguishes between the same application running in different Emacs
1695 jobs. Additional added characters permit a large number of distinct
1696 names even in one Emacs job.
1699 @defvar temporary-file-directory
1700 @cindex @code{TMPDIR} environment variable.
1701 @cindex @code{TMP} environment variable.
1702 This variable specifies the directory name for creating temporary files.
1703 Its value should be a directory name (@pxref{Directory Names}), but it
1704 is good for Lisp programs to cope if the value is a directory's file
1705 name instead. Using the value as the second argument to
1706 @code{expand-file-name} is a good way to achieve that.
1708 The default value is determined in a reasonable way for your operating
1709 system; on GNU and Unix systems it is based on the @code{TMP} and
1710 @code{TMPDIR} environment variables.
1712 Even if you do not use @code{make-temp-name} to choose the temporary
1713 file's name, you should still use this variable to decide which
1714 directory to put the file in.
1717 @node File Name Completion
1718 @subsection File Name Completion
1719 @cindex file name completion subroutines
1720 @cindex completion, file name
1722 This section describes low-level subroutines for completing a file
1723 name. For other completion functions, see @ref{Completion}.
1725 @defun file-name-all-completions partial-filename directory
1726 This function returns a list of all possible completions for a file
1727 whose name starts with @var{partial-filename} in directory
1728 @var{directory}. The order of the completions is the order of the files
1729 in the directory, which is unpredictable and conveys no useful
1732 The argument @var{partial-filename} must be a file name containing no
1733 directory part and no slash. The current buffer's default directory is
1734 prepended to @var{directory}, if @var{directory} is not absolute.
1736 In the following example, suppose that @file{~rms/lewis} is the current
1737 default directory, and has five files whose names begin with @samp{f}:
1738 @file{foo}, @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1739 @file{file.c.~2~}.@refill
1743 (file-name-all-completions "f" "")
1744 @result{} ("foo" "file~" "file.c.~2~"
1745 "file.c.~1~" "file.c")
1749 (file-name-all-completions "fo" "")
1755 @defun file-name-completion filename directory
1756 This function completes the file name @var{filename} in directory
1757 @var{directory}. It returns the longest prefix common to all file names
1758 in directory @var{directory} that start with @var{filename}.
1760 If only one match exists and @var{filename} matches it exactly, the
1761 function returns @code{t}. The function returns @code{nil} if directory
1762 @var{directory} contains no name starting with @var{filename}.
1764 In the following example, suppose that the current default directory
1765 has five files whose names begin with @samp{f}: @file{foo},
1766 @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1767 @file{file.c.~2~}.@refill
1771 (file-name-completion "fi" "")
1776 (file-name-completion "file.c.~1" "")
1777 @result{} "file.c.~1~"
1781 (file-name-completion "file.c.~1~" "")
1786 (file-name-completion "file.c.~3" "")
1792 @defopt completion-ignored-extensions
1793 @code{file-name-completion} usually ignores file names that end in any
1794 string in this list. It does not ignore them when all the possible
1795 completions end in one of these suffixes or when a buffer showing all
1796 possible completions is displayed.@refill
1798 A typical value might look like this:
1802 completion-ignored-extensions
1803 @result{} (".o" ".elc" "~" ".dvi")
1808 @node Standard File Names
1809 @subsection Standard File Names
1811 Most of the file names used in Lisp programs are entered by the user.
1812 But occasionally a Lisp program needs to specify a standard file name
1813 for a particular use---typically, to hold customization information
1814 about each user. For example, abbrev definitions are stored (by
1815 default) in the file @file{~/.abbrev_defs}; the @code{completion}
1816 package stores completions in the file @file{~/.completions}. These are
1817 two of the many standard file names used by parts of Emacs for certain
1820 Various operating systems have their own conventions for valid file
1821 names and for which file names to use for user profile data. A Lisp
1822 program which reads a file using a standard file name ought to use, on
1823 each type of system, a file name suitable for that system. The function
1824 @code{convert-standard-filename} makes this easy to do.
1826 @defun convert-standard-filename filename
1827 This function alters the file name @var{filename} to fit the conventions
1828 of the operating system in use, and returns the result as a new string.
1831 The recommended way to specify a standard file name in a Lisp program
1832 is to choose a name which fits the conventions of GNU and Unix systems,
1833 usually with a nondirectory part that starts with a period, and pass it
1834 to @code{convert-standard-filename} instead of using it directly. Here
1835 is an example from the @code{completion} package:
1838 (defvar save-completions-file-name
1839 (convert-standard-filename "~/.completions")
1840 "*The file name to save completions to.")
1843 On GNU and Unix systems, and on some other systems as well,
1844 @code{convert-standard-filename} returns its argument unchanged. On
1845 some other systems, it alters the name to fit the system's conventions.
1847 For example, on MS-DOS the alterations made by this function include
1848 converting a leading @samp{.} to @samp{_}, converting a @samp{_} in the
1849 middle of the name to @samp{.} if there is no other @samp{.}, inserting
1850 a @samp{.} after eight characters if there is none, and truncating to
1851 three characters after the @samp{.}. (It makes other changes as well.)
1852 Thus, @file{.abbrev_defs} becomes @file{_abbrev.def}, and
1853 @file{.completions} becomes @file{_complet.ion}.
1855 @node Contents of Directories
1856 @section Contents of Directories
1857 @cindex directory-oriented functions
1858 @cindex file names in directory
1860 A directory is a kind of file that contains other files entered under
1861 various names. Directories are a feature of the file system.
1863 Emacs can list the names of the files in a directory as a Lisp list,
1864 or display the names in a buffer using the @code{ls} shell command. In
1865 the latter case, it can optionally display information about each file,
1866 depending on the options passed to the @code{ls} command.
1868 @defun directory-files directory &optional full-name match-regexp nosort
1869 This function returns a list of the names of the files in the directory
1870 @var{directory}. By default, the list is in alphabetical order.
1872 If @var{full-name} is non-@code{nil}, the function returns the files'
1873 absolute file names. Otherwise, it returns the names relative to
1874 the specified directory.
1876 If @var{match-regexp} is non-@code{nil}, this function returns only
1877 those file names that contain a match for that regular expression---the
1878 other file names are excluded from the list.
1881 If @var{nosort} is non-@code{nil}, @code{directory-files} does not sort
1882 the list, so you get the file names in no particular order. Use this if
1883 you want the utmost possible speed and don't care what order the files
1884 are processed in. If the order of processing is visible to the user,
1885 then the user will probably be happier if you do sort the names.
1889 (directory-files "~lewis")
1890 @result{} ("#foo#" "#foo.el#" "." ".."
1891 "dired-mods.el" "files.texi"
1896 An error is signaled if @var{directory} is not the name of a directory
1900 @defun file-name-all-versions file dirname
1901 This function returns a list of all versions of the file named
1902 @var{file} in directory @var{dirname}.
1905 @defun insert-directory file switches &optional wildcard full-directory-p
1906 This function inserts (in the current buffer) a directory listing for
1907 directory @var{file}, formatted with @code{ls} according to
1908 @var{switches}. It leaves point after the inserted text.
1910 The argument @var{file} may be either a directory name or a file
1911 specification including wildcard characters. If @var{wildcard} is
1912 non-@code{nil}, that means treat @var{file} as a file specification with
1915 If @var{full-directory-p} is non-@code{nil}, that means the directory
1916 listing is expected to show the full contents of a directory. You
1917 should specify @code{t} when @var{file} is a directory and switches do
1918 not contain @samp{-d}. (The @samp{-d} option to @code{ls} says to
1919 describe a directory itself as a file, rather than showing its
1922 This function works by running a directory listing program whose name is
1923 in the variable @code{insert-directory-program}. If @var{wildcard} is
1924 non-@code{nil}, it also runs the shell specified by
1925 @code{shell-file-name}, to expand the wildcards.
1928 @defvar insert-directory-program
1929 This variable's value is the program to run to generate a directory listing
1930 for the function @code{insert-directory}.
1933 @node Create/Delete Dirs
1934 @section Creating and Deleting Directories
1935 @c Emacs 19 features
1937 Most Emacs Lisp file-manipulation functions get errors when used on
1938 files that are directories. For example, you cannot delete a directory
1939 with @code{delete-file}. These special functions exist to create and
1942 @defun make-directory dirname
1943 This function creates a directory named @var{dirname}.
1946 @defun delete-directory dirname
1947 This function deletes the directory named @var{dirname}. The function
1948 @code{delete-file} does not work for files that are directories; you
1949 must use @code{delete-directory} for them. If the directory contains
1950 any files, @code{delete-directory} signals an error.
1953 @node Magic File Names
1954 @section Making Certain File Names ``Magic''
1955 @cindex magic file names
1958 You can implement special handling for certain file names. This is
1959 called making those names @dfn{magic}. The principal use for this
1960 feature is in implementing remote file names (@pxref{Remote Files,,
1961 Remote Files, emacs, The GNU Emacs Manual}).
1963 To define a kind of magic file name, you must supply a regular
1964 expression to define the class of names (all those that match the
1965 regular expression), plus a handler that implements all the primitive
1966 Emacs file operations for file names that do match.
1968 The variable @code{file-name-handler-alist} holds a list of handlers,
1969 together with regular expressions that determine when to apply each
1970 handler. Each element has this form:
1973 (@var{regexp} . @var{handler})
1977 All the Emacs primitives for file access and file name transformation
1978 check the given file name against @code{file-name-handler-alist}. If
1979 the file name matches @var{regexp}, the primitives handle that file by
1980 calling @var{handler}.
1982 The first argument given to @var{handler} is the name of the primitive;
1983 the remaining arguments are the arguments that were passed to that
1984 operation. (The first of these arguments is typically the file name
1985 itself.) For example, if you do this:
1988 (file-exists-p @var{filename})
1992 and @var{filename} has handler @var{handler}, then @var{handler} is
1996 (funcall @var{handler} 'file-exists-p @var{filename})
1999 Here are the operations that a magic file name handler gets to handle:
2003 @code{add-name-to-file}, @code{copy-file}, @code{delete-directory},
2005 @code{diff-latest-backup-file},
2006 @code{directory-file-name},
2007 @code{directory-files},
2008 @code{dired-call-process},
2009 @code{dired-compress-file}, @code{dired-uncache},
2010 @code{expand-file-name},
2011 @code{file-accessible-directory-p},@*
2012 @code{file-attributes},
2013 @code{file-directory-p},
2014 @code{file-executable-p}, @code{file-exists-p},@*
2015 @code{file-local-copy},
2016 @code{file-modes}, @code{file-name-all-completions},@*
2017 @code{file-name-as-directory},
2018 @code{file-name-completion},
2019 @code{file-name-directory},
2020 @code{file-name-nondirectory},
2021 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2022 @code{file-ownership-preserved-p},
2023 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2024 @code{file-truename}, @code{file-writable-p},
2025 @code{find-backup-file-name},
2026 @code{get-file-buffer},@*
2027 @code{insert-directory},
2028 @code{insert-file-contents},
2029 @code{load}, @code{make-directory},
2030 @code{make-symbolic-link}, @code{rename-file}, @code{set-file-modes},
2031 @code{set-visited-file-modtime}, @code{shell-command},@*
2032 @code{unhandled-file-name-directory},
2033 @code{vc-registered},
2034 @code{verify-visited-file-modtime},@*
2035 @code{write-region}.
2039 @code{add-name-to-file}, @code{copy-file}, @code{delete-directory},
2041 @code{diff-latest-backup-file},
2042 @code{directory-file-name},
2043 @code{directory-files},
2044 @code{dired-call-process},
2045 @code{dired-compress-file}, @code{dired-uncache},
2046 @code{expand-file-name},
2047 @code{file-accessible-direc@discretionary{}{}{}tory-p},
2048 @code{file-attributes},
2049 @code{file-direct@discretionary{}{}{}ory-p},
2050 @code{file-executable-p}, @code{file-exists-p},
2051 @code{file-local-copy},
2052 @code{file-modes}, @code{file-name-all-completions},
2053 @code{file-name-as-directory},
2054 @code{file-name-completion},
2055 @code{file-name-directory},
2056 @code{file-name-nondirec@discretionary{}{}{}tory},
2057 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2058 @code{file-ownership-pre@discretionary{}{}{}served-p},
2059 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2060 @code{file-truename}, @code{file-writable-p},
2061 @code{find-backup-file-name},
2062 @code{get-file-buffer},
2063 @code{insert-directory},
2064 @code{insert-file-contents},
2065 @code{load}, @code{make-direc@discretionary{}{}{}tory},
2066 @code{make-symbolic-link}, @code{rename-file}, @code{set-file-modes},
2067 @code{set-visited-file-modtime}, @code{shell-command},
2068 @code{unhandled-file-name-directory},
2069 @code{vc-regis@discretionary{}{}{}tered},
2070 @code{verify-visited-file-modtime},
2071 @code{write-region}.
2074 Handlers for @code{insert-file-contents} typically need to clear the
2075 buffer's modified flag, with @code{(set-buffer-modified-p nil)}, if the
2076 @var{visit} argument is non-@code{nil}. This also has the effect of
2077 unlocking the buffer if it is locked.
2079 The handler function must handle all of the above operations, and
2080 possibly others to be added in the future. It need not implement all
2081 these operations itself---when it has nothing special to do for a
2082 certain operation, it can reinvoke the primitive, to handle the
2083 operation ``in the usual way''. It should always reinvoke the primitive
2084 for an operation it does not recognize. Here's one way to do this:
2087 (defun my-file-handler (operation &rest args)
2088 ;; @r{First check for the specific operations}
2089 ;; @r{that we have special handling for.}
2090 (cond ((eq operation 'insert-file-contents) @dots{})
2091 ((eq operation 'write-region) @dots{})
2093 ;; @r{Handle any operation we don't know about.}
2094 (t (let ((inhibit-file-name-handlers
2095 (cons 'my-file-handler
2096 (and (eq inhibit-file-name-operation operation)
2097 inhibit-file-name-handlers)))
2098 (inhibit-file-name-operation operation))
2099 (apply operation args)))))
2102 When a handler function decides to call the ordinary Emacs primitive for
2103 the operation at hand, it needs to prevent the primitive from calling
2104 the same handler once again, thus leading to an infinite recursion. The
2105 example above shows how to do this, with the variables
2106 @code{inhibit-file-name-handlers} and
2107 @code{inhibit-file-name-operation}. Be careful to use them exactly as
2108 shown above; the details are crucial for proper behavior in the case of
2109 multiple handlers, and for operations that have two file names that may
2112 @defvar inhibit-file-name-handlers
2113 This variable holds a list of handlers whose use is presently inhibited
2114 for a certain operation.
2117 @defvar inhibit-file-name-operation
2118 The operation for which certain handlers are presently inhibited.
2121 @defun find-file-name-handler file operation
2122 This function returns the handler function for file name @var{file}, or
2123 @code{nil} if there is none. The argument @var{operation} should be the
2124 operation to be performed on the file---the value you will pass to the
2125 handler as its first argument when you call it. The operation is needed
2126 for comparison with @code{inhibit-file-name-operation}.
2129 @defun file-local-copy filename
2130 This function copies file @var{filename} to an ordinary non-magic file,
2131 if it isn't one already.
2133 If @var{filename} specifies a magic file name, which programs
2134 outside Emacs cannot directly read or write, this copies the contents to
2135 an ordinary file and returns that file's name.
2137 If @var{filename} is an ordinary file name, not magic, then this function
2138 does nothing and returns @code{nil}.
2141 @defun unhandled-file-name-directory filename
2142 This function returns the name of a directory that is not magic. It
2143 uses the directory part of @var{filename} if that is not magic. For a
2144 magic file name, it invokes the file name handler, which therefore
2145 decides what value to return.
2147 This is useful for running a subprocess; every subprocess must have a
2148 non-magic directory to serve as its current directory, and this function
2149 is a good way to come up with one.
2152 @node Format Conversion
2153 @section File Format Conversion
2155 @cindex file format conversion
2156 @cindex encoding file formats
2157 @cindex decoding file formats
2158 The variable @code{format-alist} defines a list of @dfn{file formats},
2159 which describe textual representations used in files for the data (text,
2160 text-properties, and possibly other information) in an Emacs buffer.
2161 Emacs performs format conversion if appropriate when reading and writing
2164 @defvar format-alist
2165 This list contains one format definition for each defined file format.
2168 @cindex format definition
2169 Each format definition is a list of this form:
2172 (@var{name} @var{doc-string} @var{regexp} @var{from-fn} @var{to-fn} @var{modify} @var{mode-fn})
2175 Here is what the elements in a format definition mean:
2179 The name of this format.
2182 A documentation string for the format.
2185 A regular expression which is used to recognize files represented in
2189 A shell command or function to decode data in this format (to convert
2190 file data into the usual Emacs data representation).
2192 A shell command is represented as a string; Emacs runs the command as a
2193 filter to perform the conversion.
2195 If @var{from-fn} is a function, it is called with two arguments, @var{begin}
2196 and @var{end}, which specify the part of the buffer it should convert.
2197 It should convert the text by editing it in place. Since this can
2198 change the length of the text, @var{from-fn} should return the modified
2201 One responsibility of @var{from-fn} is to make sure that the beginning
2202 of the file no longer matches @var{regexp}. Otherwise it is likely to
2206 A shell command or function to encode data in this format---that is, to
2207 convert the usual Emacs data representation into this format.
2209 If @var{to-fn} is a string, it is a shell command; Emacs runs the
2210 command as a filter to perform the conversion.
2212 If @var{to-fn} is a function, it is called with two arguments, @var{begin}
2213 and @var{end}, which specify the part of the buffer it should convert.
2214 There are two ways it can do the conversion:
2218 By editing the buffer in place. In this case, @var{to-fn} should
2219 return the end-position of the range of text, as modified.
2222 By returning a list of annotations. This is a list of elements of the
2223 form @code{(@var{position} . @var{string})}, where @var{position} is an
2224 integer specifying the relative position in the text to be written, and
2225 @var{string} is the annotation to add there. The list must be sorted in
2226 order of position when @var{to-fn} returns it.
2228 When @code{write-region} actually writes the text from the buffer to the
2229 file, it intermixes the specified annotations at the corresponding
2230 positions. All this takes place without modifying the buffer.
2234 A flag, @code{t} if the encoding function modifies the buffer, and
2235 @code{nil} if it works by returning a list of annotations.
2238 A mode function to call after visiting a file converted from this
2242 The function @code{insert-file-contents} automatically recognizes file
2243 formats when it reads the specified file. It checks the text of the
2244 beginning of the file against the regular expressions of the format
2245 definitions, and if it finds a match, it calls the decoding function for
2246 that format. Then it checks all the known formats over again.
2247 It keeps checking them until none of them is applicable.
2249 Visiting a file, with @code{find-file-noselect} or the commands that use
2250 it, performs conversion likewise (because it calls
2251 @code{insert-file-contents}); it also calls the mode function for each
2252 format that it decodes. It stores a list of the format names in the
2253 buffer-local variable @code{buffer-file-format}.
2255 @defvar buffer-file-format
2256 This variable states the format of the visited file. More precisely,
2257 this is a list of the file format names that were decoded in the course
2258 of visiting the current buffer's file. It is always buffer-local in all
2262 When @code{write-region} writes data into a file, it first calls the
2263 encoding functions for the formats listed in @code{buffer-file-format},
2264 in the order of appearance in the list.
2266 @deffn Command format-write-file file format
2267 This command writes the current buffer contents into the file @var{file}
2268 in format @var{format}, and makes that format the default for future
2269 saves of the buffer. The argument @var{format} is a list of format
2273 @deffn Command format-find-file file format
2274 This command finds the file @var{file}, converting it according to
2275 format @var{format}. It also makes @var{format} the default if the
2276 buffer is saved later.
2278 The argument @var{format} is a list of format names. If @var{format} is
2279 @code{nil}, no conversion takes place. Interactively, typing just
2280 @key{RET} for @var{format} specifies @code{nil}.
2283 @deffn Command format-insert-file file format &optional beg end
2284 This command inserts the contents of file @var{file}, converting it
2285 according to format @var{format}. If @var{beg} and @var{end} are
2286 non-@code{nil}, they specify which part of the file to read, as in
2287 @code{insert-file-contents} (@pxref{Reading from Files}).
2289 The return value is like what @code{insert-file-contents} returns: a
2290 list of the absolute file name and the length of the data inserted
2293 The argument @var{format} is a list of format names. If @var{format} is
2294 @code{nil}, no conversion takes place. Interactively, typing just
2295 @key{RET} for @var{format} specifies @code{nil}.
2298 @defvar auto-save-file-format
2299 This variable specifies the format to use for auto-saving. Its value is
2300 a list of format names, just like the value of
2301 @code{buffer-file-format}; however, it is used instead of
2302 @code{buffer-file-format} for writing auto-save files. This variable is
2303 always buffer-local in all buffers.