2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 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}.
17 * Visiting Files:: Reading files into Emacs buffers for editing.
18 * Saving Buffers:: Writing changed buffers back into files.
19 * Reading from Files:: Reading files into buffers without visiting.
20 * Writing to Files:: Writing new files from parts of buffers.
21 * File Locks:: Locking and unlocking files, to prevent
22 simultaneous editing by two people.
23 * Information about Files:: Testing existence, accessibility, size of files.
24 * Changing File Attributes:: Renaming files, changing protection, etc.
25 * File Names:: Decomposing and expanding file names.
26 * Contents of Directories:: Getting a list of the files in a directory.
27 * Create/Delete Dirs:: Creating and Deleting Directories.
28 * Magic File Names:: Defining "magic" special handling
29 for certain file names.
33 @section Visiting Files
35 @cindex visiting files
37 Visiting a file means reading a file into a buffer. Once this is
38 done, we say that the buffer is @dfn{visiting} that file, and call the
39 file ``the visited file'' of the buffer.
41 A file and a buffer are two different things. A file is information
42 recorded permanently in the computer (unless you delete it). A buffer,
43 on the other hand, is information inside of Emacs that will vanish at
44 the end of the editing session (or when you kill the buffer). Usually,
45 a buffer contains information that you have copied from a file; then we
46 say the buffer is visiting that file. The copy in the buffer is what
47 you modify with editing commands. Such changes to the buffer do not
48 change the file; therefore, to make the changes permanent, you must
49 @dfn{save} the buffer, which means copying the altered buffer contents
52 In spite of the distinction between files and buffers, people often
53 refer to a file when they mean a buffer and vice-versa. Indeed, we say,
54 ``I am editing a file,'' rather than, ``I am editing a buffer which I
55 will soon save as a file of the same name.'' Humans do not usually need
56 to make the distinction explicit. When dealing with a computer program,
57 however, it is good to keep the distinction in mind.
60 * Visiting Functions:: The usual interface functions for visiting.
61 * Subroutines of Visiting:: Lower-level subroutines that they use.
64 @node Visiting Functions
65 @subsection Functions for Visiting Files
67 This section describes the functions normally used to visit files.
68 For historical reasons, these functions have names starting with
69 @samp{find-} rather than @samp{visit-}. @xref{Buffer File Name}, for
70 functions and variables that access the visited file name of a buffer or
71 that find an existing buffer by its visited file name.
73 @deffn Command find-file filename
74 This command selects a buffer visiting the file @var{filename},
75 using an existing buffer if there is one, and otherwise creating a
76 new buffer and reading the file into it. It also returns that buffer.
78 The body of the @code{find-file} function is very simple and looks
82 (switch-to-buffer (find-file-noselect filename))
86 (See @code{switch-to-buffer} in @ref{Displaying Buffers}.)
88 When @code{find-file} is called interactively, it prompts for
89 @var{filename} in the minibuffer.
92 @defun find-file-noselect filename
93 This function is the guts of all the file-visiting functions. It finds
94 or creates a buffer visiting the file @var{filename}, and returns it.
95 It uses an existing buffer if there is one, and otherwise creates a new
96 buffer and reads the file into it. You may make the buffer current or
97 display it in a window if you wish, but this function does not do so.
99 When @code{find-file-noselect} uses an existing buffer, it first
100 verifies that the file has not changed since it was last visited or
101 saved in that buffer. If the file has changed, then this function asks
102 the user whether to reread the changed file. If the user says
103 @samp{yes}, any changes previously made in the buffer are lost.
105 If @code{find-file-noselect} needs to create a buffer, and there is no
106 file named @var{filename}, it displays the message @samp{New file} in
107 the echo area, and leaves the buffer empty.
109 The @code{find-file-noselect} function calls @code{after-find-file}
110 after reading the file (@pxref{Subroutines of Visiting}). That function
111 sets the buffer major mode, parses local variables, warns the user if
112 there exists an auto-save file more recent than the file just visited,
113 and finishes by running the functions in @code{find-file-hooks}.
115 The @code{find-file-noselect} function returns the buffer that is
116 visiting the file @var{filename}.
120 (find-file-noselect "/etc/fstab")
121 @result{} #<buffer fstab>
126 @deffn Command find-alternate-file filename
127 This command selects a buffer visiting the file @var{filename}, then
128 kills the buffer that was previously displayed in the selected window.
129 It is useful if you have visited the wrong file by mistake, so that you
130 can get rid of the buffer that you did not want to create, at the same
131 time as you visit the file you intended.
133 When this command is called interactively, it prompts for @var{filename}.
136 @deffn Command find-file-other-window filename
137 This command selects a buffer visiting the file @var{filename}, but
138 does so in a window other than the selected window. It may use another
139 existing window or split a window; see @ref{Displaying Buffers}.
141 When this command is called interactively, it prompts for
145 @deffn Command find-file-read-only filename
146 This command selects a buffer visiting the file @var{filename}, like
147 @code{find-file}, but it marks the buffer as read-only. @xref{Read Only
148 Buffers}, for related functions and variables.
150 When this command is called interactively, it prompts for
154 @deffn Command view-file filename
155 This command views @var{filename} in View mode, returning to the
156 previous buffer when done. View mode is a mode that allows you to skim
157 rapidly through the file but does not let you modify it. Entering View
158 mode runs the normal hook @code{view-mode-hook}. @xref{Hooks}.
160 When @code{view-file} is called interactively, it prompts for
164 @defvar find-file-hooks
165 The value of this variable is a list of functions to be called after a
166 file is visited. The file's local-variables specification (if any) will
167 have been processed before the hooks are run. The buffer visiting the
168 file is current when the hook functions are run.
170 This variable works just like a normal hook, but we think that renaming
171 it would not be advisable.
174 @defvar find-file-not-found-hooks
175 The value of this variable is a list of functions to be called when
176 @code{find-file} or @code{find-file-noselect} is passed a nonexistent
177 file name. @code{find-file-noselect} calls these functions as soon as
178 it detects a nonexistent file. It calls them in the order of the list,
179 until one of them returns non-@code{nil}. @code{buffer-file-name} is
182 This is not a normal hook because the values of the functions are
183 used and they may not all be called.
186 @node Subroutines of Visiting
187 @comment node-name, next, previous, up
188 @subsection Subroutines of Visiting
190 The @code{find-file-noselect} function uses the
191 @code{create-file-buffer} and @code{after-find-file} functions as
192 subroutines. Sometimes it is useful to call them directly.
194 @defun create-file-buffer filename
195 This function creates a suitably named buffer for visiting
196 @var{filename}, and returns it. It uses @var{filename} (sans directory)
197 as the name if that name is free; otherwise, it appends a string such as
198 @samp{<2>} to get an unused name. See also @ref{Creating Buffers}.
200 @strong{Please note:} @code{create-file-buffer} does @emph{not}
201 associate the new buffer with a file and does not select the buffer.
205 (create-file-buffer "foo")
206 @result{} #<buffer foo>
209 (create-file-buffer "foo")
210 @result{} #<buffer foo<2>>
213 (create-file-buffer "foo")
214 @result{} #<buffer foo<3>>
218 This function is used by @code{find-file-noselect}.
219 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
222 @defun after-find-file &optional error warn
223 This function sets the buffer major mode, and parses local variables
224 (@pxref{Auto Major Mode}). It is called by @code{find-file-noselect}
225 and by the default revert function (@pxref{Reverting}).
227 @cindex new file message
228 @cindex file open error
229 If reading the file got an error because the file does not exist, but
230 its directory does exist, the caller should pass a non-@code{nil} value
231 for @var{error}. In that case, @code{after-find-file} issues a warning:
232 @samp{(New File)}. For more serious errors, the caller should usually not
233 call @code{after-find-file}.
235 If @var{warn} is non-@code{nil}, then this function issues a warning
236 if an auto-save file exists and is more recent than the visited file.
238 The last thing @code{after-find-file} does is call all the functions
239 in @code{find-file-hooks}.
243 @section Saving Buffers
245 When you edit a file in Emacs, you are actually working on a buffer
246 that is visiting that file---that is, the contents of the file are
247 copied into the buffer and the copy is what you edit. Changes to the
248 buffer do not change the file until you @dfn{save} the buffer, which
249 means copying the contents of the buffer into the file.
251 @deffn Command save-buffer &optional backup-option
252 This function saves the contents of the current buffer in its visited
253 file if the buffer has been modified since it was last visited or saved.
254 Otherwise it does nothing.
256 @code{save-buffer} is responsible for making backup files. Normally,
257 @var{backup-option} is @code{nil}, and @code{save-buffer} makes a backup
258 file only if this is the first save or if the buffer was previously
259 modified. Other values for @var{backup-option} request the making of
260 backup files in other circumstances:
264 With an argument of 4 or 64, reflecting 1 or 3 @kbd{C-u}'s, the
265 @code{save-buffer} function marks this version of the file to be
266 backed up when the buffer is next saved.
269 With an argument of 16 or 64, reflecting 2 or 3 @kbd{C-u}'s, the
270 @code{save-buffer} function unconditionally backs up the previous
271 version of the file before saving it.
275 @deffn Command save-some-buffers &optional save-silently-p exiting
276 This command saves some modified file-visiting buffers. Normally it
277 asks the user about each buffer. But if @var{save-silently-p} is
278 non-@code{nil}, it saves all the file-visiting buffers without querying
281 The optional @var{exiting} argument, if non-@code{nil}, requests this
282 function to offer also to save certain other buffers that are not
283 visiting files. These are buffers that have a non-@code{nil} local
284 value of @code{buffer-offer-save}. (A user who says yes to saving one
285 of these is asked to specify a file name to use.) The
286 @code{save-buffers-kill-emacs} function passes a non-@code{nil} value
290 @defvar buffer-offer-save
291 When this variable is non-@code{nil} in a buffer, Emacs offers to save
292 the buffer on exit even if the buffer is not visiting a file. The
293 variable is automatically local in all buffers. Normally, Mail mode
294 (used for editing outgoing mail) sets this to @code{t}.
297 @deffn Command write-file filename
298 This function writes the current buffer into file @var{filename}, makes
299 the buffer visit that file, and marks it not modified. Then it renames
300 the buffer based on @var{filename}, appending a string like @samp{<2>}
301 if necessary to make a unique buffer name. It does most of this work by
302 calling @code{set-visited-file-name} and @code{save-buffer}.
305 @defvar write-file-hooks
306 The value of this variable is a list of functions to be called before
307 writing out a buffer to its visited file. If one of them returns
308 non-@code{nil}, the file is considered already written and the rest of
309 the functions are not called, nor is the usual code for writing the file
312 If a function in @code{write-file-hooks} returns non-@code{nil}, it
313 is responsible for making a backup file (if that is appropriate).
314 To do so, execute the following code:
317 (or buffer-backed-up (backup-buffer))
320 You might wish to save the file modes value returned by
321 @code{backup-buffer} and use that to set the mode bits of the file that
322 you write. This is what @code{save-buffer} normally does.
324 Even though this is not a normal hook, you can use @code{add-hook} and
325 @code{remove-hook} to manipulate the list. @xref{Hooks}.
329 @defvar local-write-file-hooks
330 This works just like @code{write-file-hooks}, but it is intended
331 to be made local to particular buffers. It's not a good idea to make
332 @code{write-file-hooks} local to a buffer---use this variable instead.
334 The variable is marked as a permanent local, so that changing the major
335 mode does not alter a buffer-local value. This is convenient for
336 packages that read ``file'' contents in special ways, and set up hooks
337 to save the data in a corresponding way.
341 @defvar write-contents-hooks
342 This works just like @code{write-file-hooks}, but it is intended for
343 hooks that pertain to the contents of the file, as opposed to hooks that
344 pertain to where the file came from. Typically major mode commands make
345 buffer-local bindings for this variable.
349 @defvar after-save-hook
350 This normal hook runs after a buffer has been saved in its visited file.
353 @defvar file-precious-flag
354 If this variable is non-@code{nil}, then @code{save-buffer} protects
355 against I/O errors while saving by writing the new file to a temporary
356 name instead of the name it is supposed to have, and then renaming it to
357 the intended name after it is clear there are no errors. This procedure
358 prevents problems such as a lack of disk space from resulting in an
361 (This feature worked differently in older Emacs versions.)
363 Some modes set this non-@code{nil} locally in particular buffers.
366 @defopt require-final-newline
367 This variable determines whether files may be written out that do
368 @emph{not} end with a newline. If the value of the variable is
369 @code{t}, then @code{save-buffer} silently adds a newline at the end of
370 the file whenever the buffer being saved does not already end in one.
371 If the value of the variable is non-@code{nil}, but not @code{t}, then
372 @code{save-buffer} asks the user whether to add a newline each time the
375 If the value of the variable is @code{nil}, then @code{save-buffer}
376 doesn't add newlines at all. @code{nil} is the default value, but a few
377 major modes set it to @code{t} in particular buffers.
380 @node Reading from Files
381 @comment node-name, next, previous, up
382 @section Reading from Files
384 You can copy a file from the disk and insert it into a buffer
385 using the @code{insert-file-contents} function. Don't use the user-level
386 command @code{insert-file} in a Lisp program, as that sets the mark.
388 @defun insert-file-contents filename &optional visit beg end replace
389 This function inserts the contents of file @var{filename} into the
390 current buffer after point. It returns a list of the absolute file name
391 and the length of the data inserted. An error is signaled if
392 @var{filename} is not the name of a file that can be read.
394 To set up saved text properties, @code{insert-file-contents} calls the
395 functions in the list @code{after-insert-file-functions}. For more
396 information, see @ref{Saving Properties}.
398 If @var{visit} is non-@code{nil}, this function additionally marks the
399 buffer as unmodified and sets up various fields in the buffer so that it
400 is visiting the file @var{filename}: these include the buffer's visited
401 file name and its last save file modtime. This feature is used by
402 @code{find-file-noselect} and you probably should not use it yourself.
404 If @var{beg} and @var{end} are non-@code{nil}, they should be integers
405 specifying the portion of the file to insert. In this case, @var{visit}
406 must be @code{nil}. For example,
409 (insert-file-contents filename nil 0 500)
413 inserts the first 500 characters of a file.
415 If the argument @var{replace} is non-@code{nil}, it means to replace the
416 contents of the buffer (actually, just the accessible portion) with the
417 contents of the file. This is better than simply deleting the buffer
418 contents and inserting the whole file, because (1) it preserves some
419 marker positions and (2) it puts less data in the undo list.
422 If you want to pass a file name to another process so that another
423 program can read the file, use the function @code{file-local-copy}; see
424 @ref{Magic File Names}.
426 @node Writing to Files
427 @comment node-name, next, previous, up
428 @section Writing to Files
430 You can write the contents of a buffer, or part of a buffer, directly
431 to a file on disk using the @code{append-to-file} and
432 @code{write-region} functions. Don't use these functions to write to
433 files that are being visited; that could cause confusion in the
434 mechanisms for visiting.
436 @deffn Command append-to-file start end filename
437 This function appends the contents of the region delimited by
438 @var{start} and @var{end} in the current buffer to the end of file
439 @var{filename}. If that file does not exist, it is created. This
440 function returns @code{nil}.
442 An error is signaled if @var{filename} specifies a nonwritable file,
443 or a nonexistent file in a directory where files cannot be created.
446 @deffn Command write-region start end filename &optional append visit
447 This function writes the region delimited by @var{start} and @var{end}
448 in the current buffer into the file specified by @var{filename}.
451 If @var{start} is a string, then @code{write-region} writes or appends
452 that string, rather than text from the buffer.
454 If @var{append} is non-@code{nil}, then the specified text is appended
455 to the existing file contents (if any).
457 If @var{visit} is @code{t}, then Emacs establishes an association
458 between the buffer and the file: the buffer is then visiting that file.
459 It also sets the last file modification time for the current buffer to
460 @var{filename}'s modtime, and marks the buffer as not modified. This
461 feature is used by @code{save-buffer}, but you probably should not use
465 If @var{visit} is a string, it specifies the file name to visit. This
466 way, you can write the data to one file (@var{filename}) while recording
467 the buffer as visiting another file (@var{visit}). The argument
468 @var{visit} is used in the echo area message and also for file locking;
469 @var{visit} is stored in @code{buffer-file-name}. This feature is used
470 to implement @code{file-precious-flag}; don't use it yourself unless you
471 really know what you're doing.
473 To output information about text properties, @code{write-region} calls
474 the functions in the list @code{write-region-annotation-functions}. For
475 more information, see @ref{Saving Properties}.
477 Normally, @code{write-region} displays a message @samp{Wrote file
478 @var{filename}} in the echo area. If @var{visit} is neither @code{t}
479 nor @code{nil} nor a string, then this message is inhibited. This
480 feature is useful for programs that use files for internal purposes,
481 files which the user does not need to know about.
488 When two users edit the same file at the same time, they are likely to
489 interfere with each other. Emacs tries to prevent this situation from
490 arising by recording a @dfn{file lock} when a file is being modified.
491 Emacs can then detect the first attempt to modify a buffer visiting a
492 file that is locked by another Emacs job, and ask the user what to do.
494 File locks do not work properly when multiple machines can share
495 file systems, such as with NFS. Perhaps a better file locking system
496 will be implemented in the future. When file locks do not work, it is
497 possible for two users to make changes simultaneously, but Emacs can
498 still warn the user who saves second. Also, the detection of
499 modification of a buffer visiting a file changed on disk catches some
500 cases of simultaneous editing; see @ref{Modification Time}.
502 @defun file-locked-p filename
503 This function returns @code{nil} if the file @var{filename} is not
504 locked by this Emacs process. It returns @code{t} if it is locked by
505 this Emacs, and it returns the name of the user who has locked it if it
506 is locked by someone else.
510 (file-locked-p "foo")
516 @defun lock-buffer &optional filename
517 This function locks the file @var{filename}, if the current buffer is
518 modified. The argument @var{filename} defaults to the current buffer's
519 visited file. Nothing is done if the current buffer is not visiting a
520 file, or is not modified.
524 This function unlocks the file being visited in the current buffer,
525 if the buffer is modified. If the buffer is not modified, then
526 the file should not be locked, so this function does nothing. It also
527 does nothing if the current buffer is not visiting a file.
530 @defun ask-user-about-lock file other-user
531 This function is called when the user tries to modify @var{file}, but it
532 is locked by another user name @var{other-user}. The value it returns
533 determines what happens next:
537 A value of @code{t} says to grab the lock on the file. Then
538 this user may edit the file and @var{other-user} loses the lock.
541 A value of @code{nil} says to ignore the lock and let this
542 user edit the file anyway.
546 This function may instead signal a @code{file-locked} error, in which
547 case the change that the user was about to make does not take place.
549 The error message for this error looks like this:
552 @error{} File is locked: @var{file} @var{other-user}
556 where @code{file} is the name of the file and @var{other-user} is the
557 name of the user who has locked the file.
560 The default definition of this function asks the user to choose what
561 to do. If you wish, you can replace the @code{ask-user-about-lock}
562 function with your own version that decides in another way. The code
563 for its usual definition is in @file{userlock.el}.
566 @node Information about Files
567 @section Information about Files
569 The functions described in this section are similar in as much as
570 they all operate on strings which are interpreted as file names. All
571 have names that begin with the word @samp{file}. These functions all
572 return information about actual files or directories, so their
573 arguments must all exist as actual files or directories unless
576 Most of the file-oriented functions take a single argument,
577 @var{filename}, which must be a string. The file name is expanded using
578 @code{expand-file-name}, so @file{~} is handled correctly, as are
579 relative file names (including @samp{../}). These functions don't
580 recognize environment variable substitutions such as @samp{$HOME}.
581 @xref{File Name Expansion}.
584 * Testing Accessibility:: Is a given file readable? Writable?
585 * Kinds of Files:: Is it a directory? A symbolic link?
586 * Truenames:: Eliminating symbolic links from a file name.
587 * File Attributes:: How large is it? Any other names? Etc.
590 @node Testing Accessibility
591 @comment node-name, next, previous, up
592 @subsection Testing Accessibility
593 @cindex accessibility of a file
594 @cindex file accessibility
596 These functions test for permission to access a file in specific ways.
598 @defun file-exists-p filename
599 This function returns @code{t} if a file named @var{filename} appears
600 to exist. This does not mean you can necessarily read the file, only
601 that you can find out its attributes. (On Unix, this is true if the
602 file exists and you have execute permission on the containing
603 directories, regardless of the protection of the file itself.)
605 If the file does not exist, or if fascist access control policies
606 prevent you from finding the attributes of the file, this function
610 @defun file-readable-p filename
611 This function returns @code{t} if a file named @var{filename} exists
612 and you can read it. It returns @code{nil} otherwise.
616 (file-readable-p "files.texi")
620 (file-exists-p "/usr/spool/mqueue")
624 (file-readable-p "/usr/spool/mqueue")
631 @defun file-executable-p filename
632 This function returns @code{t} if a file named @var{filename} exists and
633 you can execute it. It returns @code{nil} otherwise. If the file is a
634 directory, execute permission means you can check the existence and
635 attributes of files inside the directory, and open those files if their
639 @defun file-writable-p filename
640 This function returns @code{t} if the file @var{filename} can be written or
641 created by you. It is writable if the file exists and you can write it.
642 It is creatable if the file does not exist, but the specified directory
643 does exist and you can write in that directory. @code{file-writable-p}
644 returns @code{nil} otherwise.
646 In the third example below, @file{foo} is not writable because the
647 parent directory does not exist, even though the user could create such
652 (file-writable-p "~/foo")
656 (file-writable-p "/foo")
660 (file-writable-p "~/no-such-dir/foo")
667 @defun file-accessible-directory-p dirname
668 This function returns @code{t} if you have permission to open existing
669 files in directory @var{dirname}; otherwise (and if there is no such
670 directory), it returns @code{nil}. The value of @var{dirname} may be
671 either a directory name or the file name of a directory.
673 Example: after the following,
676 (file-accessible-directory-p "/foo")
681 we can deduce that any attempt to read a file in @file{/foo/} will
685 @defun file-newer-than-file-p filename1 filename2
687 @cindex file modification time
688 This functions returns @code{t} if the file @var{filename1} is
689 newer than file @var{filename2}. If @var{filename1} does not
690 exist, it returns @code{nil}. If @var{filename2} does not exist,
693 In the following example, assume that the file @file{aug-19} was
694 written on the 19th, and @file{aug-20} was written on the 20th. The
695 file @file{no-file} doesn't exist at all.
699 (file-newer-than-file-p "aug-19" "aug-20")
703 (file-newer-than-file-p "aug-20" "aug-19")
707 (file-newer-than-file-p "aug-19" "no-file")
711 (file-newer-than-file-p "no-file" "aug-19")
716 You can use @code{file-attributes} to get a file's last modification
717 time as a list of two numbers. @xref{File Attributes}.
721 @comment node-name, next, previous, up
722 @subsection Distinguishing Kinds of Files
724 This section describes how to distinguish directories and symbolic
725 links from ordinary files.
727 @defun file-symlink-p filename
728 @cindex file symbolic links
729 If the file @var{filename} is a symbolic link, the @code{file-symlink-p}
730 function returns the file name to which it is linked. This may be the
731 name of a text file, a directory, or even another symbolic link, or of
734 If the file @var{filename} is not a symbolic link (or there is no such file),
735 @code{file-symlink-p} returns @code{nil}.
739 (file-symlink-p "foo")
743 (file-symlink-p "sym-link")
747 (file-symlink-p "sym-link2")
751 (file-symlink-p "/bin")
756 @c !!! file-symlink-p: should show output of ls -l for comparison
759 @defun file-directory-p filename
760 This function returns @code{t} if @var{filename} is the name of an
761 existing directory, @code{nil} otherwise.
765 (file-directory-p "~rms")
769 (file-directory-p "~rms/lewis/files.texi")
773 (file-directory-p "~rms/lewis/no-such-file")
777 (file-directory-p "$HOME")
782 (substitute-in-file-name "$HOME"))
789 @subsection Truenames
790 @cindex truename (of file)
793 The @dfn{truename} of a file is the name that you get by following
794 symbolic links until none remain, then expanding to get rid of @samp{.}
795 and @samp{..} as components. Strictly speaking, a file need not have a
796 unique truename; the number of distinct truenames a file has is equal to
797 the number of hard links to the file. However, truenames are useful
798 because they eliminate symbolic links as a cause of name variation.
800 @defun file-truename filename
801 The function @code{file-truename} returns the true name of the file
802 @var{filename}. This is the name that you get by following symbolic
803 links until none remain. The argument must be an absolute file name.
806 @xref{Buffer File Name}, for related information.
808 @node File Attributes
809 @comment node-name, next, previous, up
810 @subsection Other Information about Files
812 This section describes the functions for getting detailed information
813 about a file, other than its contents. This information includes the
814 mode bits that control access permission, the owner and group numbers,
815 the number of names, the inode number, the size, and the times of access
818 @defun file-modes filename
820 @cindex file attributes
821 This function returns the mode bits of @var{filename}, as an integer.
822 The mode bits are also called the file permissions, and they specify
823 access control in the usual Unix fashion. If the low-order bit is 1,
824 then the file is executable by all users, if the second lowest-order bit
825 is 1, then the file is writable by all users, etc.
827 The highest value returnable is 4095 (7777 octal), meaning that
828 everyone has read, write, and execute permission, that the @sc{suid} bit
829 is set for both others and group, and that the sticky bit is set.
833 (file-modes "~/junk/diffs")
834 @result{} 492 ; @r{Decimal integer.}
838 @result{} "754" ; @r{Convert to octal.}
842 (set-file-modes "~/junk/diffs" 438)
848 @result{} "666" ; @r{Convert to octal.}
853 -rw-rw-rw- 1 lewis 0 3063 Oct 30 16:00 diffs
858 @defun file-nlinks filename
859 This functions returns the number of names (i.e., hard links) that
860 file @var{filename} has. If the file does not exist, then this function
861 returns @code{nil}. Note that symbolic links have no effect on this
862 function, because they are not considered to be names of the files they
868 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo
869 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo1
877 (file-nlinks "doesnt-exist")
883 @defun file-attributes filename
884 This function returns a list of attributes of file @var{filename}. If
885 the specified file cannot be opened, it returns @code{nil}.
887 The elements of the list, in order, are:
891 @code{t} for a directory, a string for a symbolic link (the name
892 linked to), or @code{nil} for a text file.
894 @c Wordy so as to prevent an overfull hbox. --rjc 15mar92
896 The number of names the file has. Alternate names, also known as hard
897 links, can be created by using the @code{add-name-to-file} function
898 (@pxref{Changing File Attributes}).
907 The time of last access, as a list of two integers.
908 The first integer has the high-order 16 bits of time,
909 the second has the low 16 bits. (This is similar to the
910 value of @code{current-time}; see @ref{Time of Day}.)
913 The time of last modification as a list of two integers (as above).
916 The time of last status change as a list of two integers (as above).
919 The size of the file in bytes.
922 The file's modes, as a string of ten letters or dashes
926 @code{t} if the file's @sc{gid} would change if file were
927 deleted and recreated; @code{nil} otherwise.
930 The file's inode number.
933 The file system number of the file system that the file is in. This
934 element together with the file's inode number, give enough information
935 to distinguish any two files on the system---no two files can have the
936 same values for both of these numbers.
939 For example, here are the file attributes for @file{files.texi}:
943 (file-attributes "files.texi")
960 and here is how the result is interpreted:
964 is neither a directory nor a symbolic link.
967 has only one name (the name @file{files.texi} in the current default
971 is owned by the user with @sc{uid} 2235.
974 is in the group with @sc{gid} 75.
977 was last accessed on Aug 19 00:09. Unfortunately, you cannot convert
978 this number into a time string in Emacs.
981 was last modified on Aug 19 00:09.
984 last had its inode changed on Aug 19 00:09.
987 is 14906 characters long.
990 has a mode of read and write access for the owner, group, and world.
993 would retain the same @sc{gid} if it were recreated.
996 has an inode number of 129500.
998 is on file system number -32252.
1002 @node Changing File Attributes
1003 @section Changing File Names and Attributes
1004 @cindex renaming files
1005 @cindex copying files
1006 @cindex deleting files
1007 @cindex linking files
1008 @cindex setting modes of files
1010 The functions in this section rename, copy, delete, link, and set the
1013 In the functions that have an argument @var{newname}, if a file by the
1014 name of @var{newname} already exists, the actions taken depend on the
1015 value of the argument @var{ok-if-already-exists}:
1019 Signal a @code{file-already-exists} error if
1020 @var{ok-if-already-exists} is @code{nil}.
1023 Request confirmation if @var{ok-if-already-exists} is a number.
1026 Replace the old file without confirmation if @var{ok-if-already-exists}
1030 @defun add-name-to-file oldname newname &optional ok-if-already-exists
1031 @cindex file with multiple names
1032 @cindex file hard link
1033 This function gives the file named @var{oldname} the additional name
1034 @var{newname}. This means that @var{newname} becomes a new ``hard
1035 link'' to @var{oldname}.
1037 In the first part of the following example, we list two files,
1038 @file{foo} and @file{foo3}.
1043 -rw-rw-rw- 1 rms 29 Aug 18 20:32 foo
1044 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1048 Then we evaluate the form @code{(add-name-to-file "~/lewis/foo"
1049 "~/lewis/foo2")}. Again we list the files. This shows two names,
1050 @file{foo} and @file{foo2}.
1054 (add-name-to-file "~/lewis/foo1" "~/lewis/foo2")
1060 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo
1061 -rw-rw-rw- 2 rms 29 Aug 18 20:32 foo2
1062 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1066 @c !!! Check whether this set of examples is consistent. --rjc 15mar92
1067 Finally, we evaluate the following:
1070 (add-name-to-file "~/lewis/foo" "~/lewis/foo3" t)
1074 and list the files again. Now there are three names
1075 for one file: @file{foo}, @file{foo2}, and @file{foo3}. The old
1076 contents of @file{foo3} are lost.
1080 (add-name-to-file "~/lewis/foo1" "~/lewis/foo3")
1086 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo
1087 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo2
1088 -rw-rw-rw- 3 rms 29 Aug 18 20:32 foo3
1092 This function is meaningless on VMS, where multiple names for one file
1095 See also @code{file-nlinks} in @ref{File Attributes}.
1098 @deffn Command rename-file filename newname &optional ok-if-already-exists
1099 This command renames the file @var{filename} as @var{newname}.
1101 If @var{filename} has additional names aside from @var{filename}, it
1102 continues to have those names. In fact, adding the name @var{newname}
1103 with @code{add-name-to-file} and then deleting @var{filename} has the
1104 same effect as renaming, aside from momentary intermediate states.
1106 In an interactive call, this function prompts for @var{filename} and
1107 @var{newname} in the minibuffer; also, it requests confirmation if
1108 @var{newname} already exists.
1111 @deffn Command copy-file oldname newname &optional ok-if-exists time
1112 This command copies the file @var{oldname} to @var{newname}. An
1113 error is signaled if @var{oldname} does not exist.
1115 If @var{time} is non-@code{nil}, then this functions gives the new
1116 file the same last-modified time that the old one has. (This works on
1117 only some operating systems.)
1119 In an interactive call, this function prompts for @var{filename} and
1120 @var{newname} in the minibuffer; also, it requests confirmation if
1121 @var{newname} already exists.
1124 @deffn Command delete-file filename
1126 This command deletes the file @var{filename}, like the shell command
1127 @samp{rm @var{filename}}. If the file has multiple names, it continues
1128 to exist under the other names.
1130 A suitable kind of @code{file-error} error is signaled if the file
1131 does not exist, or is not deletable. (On Unix, a file is deletable if
1132 its directory is writable.)
1134 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1137 @deffn Command make-symbolic-link filename newname &optional ok-if-exists
1139 @kindex file-already-exists
1140 This command makes a symbolic link to @var{filename}, named
1141 @var{newname}. This is like the shell command @samp{ln -s
1142 @var{filename} @var{newname}}.
1144 In an interactive call, @var{filename} and @var{newname} are read in the
1145 minibuffer; it requests confirmation if the file @var{newname} already
1149 @defun define-logical-name varname string
1150 This function defines the logical name @var{name} to have the value
1151 @var{string}. It is available only on VMS.
1154 @defun set-file-modes filename mode
1155 This function sets mode bits of @var{filename} to @var{mode} (which must
1156 be an integer). Only the 12 low bits of @var{mode} are used.
1160 @defun set-default-file-modes mode
1161 This function sets the default file protection for new files created by
1162 Emacs and its subprocesses. Every file created with Emacs initially has
1163 this protection. On Unix, the default protection is the bitwise
1164 complement of the ``umask'' value.
1166 The argument @var{mode} must be an integer. Only the 9 low bits of
1167 @var{mode} are used.
1169 Saving a modified version of an existing file does not count as creating
1170 the file; it does not change the file's mode, and does not use the
1171 default file protection.
1174 @defun default-file-modes
1175 This function returns the current default protection value.
1182 Files are generally referred to by their names, in Emacs as elsewhere.
1183 File names in Emacs are represented as strings. The functions that
1184 operate on a file all expect a file name argument.
1186 In addition to operating on files themselves, Emacs Lisp programs
1187 often need to operate on the names; i.e., to take them apart and to use
1188 part of a name to construct related file names. This section describes
1189 how to manipulate file names.
1191 The functions in this section do not actually access files, so they
1192 can operate on file names that do not refer to an existing file or
1195 On VMS, all these functions understand both VMS file name syntax and
1196 Unix syntax. This is so that all the standard Lisp libraries can
1197 specify file names in Unix syntax and work properly on VMS without
1201 * File Name Components:: The directory part of a file name, and the rest.
1202 * Directory Names:: A directory's name as a directory
1203 is different from its name as a file.
1204 * Relative File Names:: Some file names are relative to a current directory.
1205 * File Name Expansion:: Converting relative file names to absolute ones.
1206 * Unique File Names:: Generating names for temporary files.
1207 * File Name Completion:: Finding the completions for a given file name.
1210 @node File Name Components
1211 @subsection File Name Components
1212 @cindex directory part (of file name)
1213 @cindex nondirectory part (of file name)
1214 @cindex version number (in file name)
1216 The operating system groups files into directories. To specify a
1217 file, you must specify the directory, and the file's name in that
1218 directory. Therefore, a file name in Emacs is considered to have two
1219 main parts: the @dfn{directory name} part, and the @dfn{nondirectory}
1220 part (or @dfn{file name within the directory}). Either part may be
1221 empty. Concatenating these two parts reproduces the original file name.
1223 On Unix, the directory part is everything up to and including the last
1224 slash; the nondirectory part is the rest. The rules in VMS syntax are
1227 For some purposes, the nondirectory part is further subdivided into
1228 the name proper and the @dfn{version number}. On Unix, only backup
1229 files have version numbers in their names; on VMS, every file has a
1230 version number, but most of the time the file name actually used in
1231 Emacs omits the version number. Version numbers are found mostly in
1234 @defun file-name-directory filename
1235 This function returns the directory part of @var{filename} (or
1236 @code{nil} if @var{filename} does not include a directory part). On
1237 Unix, the function returns a string ending in a slash. On VMS, it
1238 returns a string ending in one of the three characters @samp{:},
1239 @samp{]}, or @samp{>}.
1243 (file-name-directory "lewis/foo") ; @r{Unix example}
1247 (file-name-directory "foo") ; @r{Unix example}
1251 (file-name-directory "[X]FOO.TMP") ; @r{VMS example}
1257 @defun file-name-nondirectory filename
1258 This function returns the nondirectory part of @var{filename}.
1262 (file-name-nondirectory "lewis/foo")
1266 (file-name-nondirectory "foo")
1270 ;; @r{The following example is accurate only on VMS.}
1271 (file-name-nondirectory "[X]FOO.TMP")
1277 @defun file-name-sans-versions filename
1278 This function returns @var{filename} without any file version numbers,
1279 backup version numbers, or trailing tildes.
1283 (file-name-sans-versions "~rms/foo.~1~")
1284 @result{} "~rms/foo"
1287 (file-name-sans-versions "~rms/foo~")
1288 @result{} "~rms/foo"
1291 (file-name-sans-versions "~rms/foo")
1292 @result{} "~rms/foo"
1295 ;; @r{The following example applies to VMS only.}
1296 (file-name-sans-versions "foo;23")
1302 @node Directory Names
1303 @comment node-name, next, previous, up
1304 @subsection Directory Names
1305 @cindex directory name
1306 @cindex file name of directory
1308 A @dfn{directory name} is the name of a directory. A directory is a
1309 kind of file, and it has a file name, which is related to the directory
1310 name but not identical to it. (This is not quite the same as the usual
1311 Unix terminology.) These two different names for the same entity are
1312 related by a syntactic transformation. On Unix, this is simple: a
1313 directory name ends in a slash, whereas the directory's name as a file
1314 lacks that slash. On VMS, the relationship is more complicated.
1316 The difference between a directory name and its name as a file is
1317 subtle but crucial. When an Emacs variable or function argument is
1318 described as being a directory name, a file name of a directory is not
1321 These two functions convert between directory names and file names.
1322 They do nothing special with environment variable substitutions such as
1323 @samp{$HOME}, and the constructs @samp{~}, and @samp{..}.
1325 @defun file-name-as-directory filename
1326 This function returns a string representing @var{filename} in a form
1327 that the operating system will interpret as the name of a directory. In
1328 Unix, this means appending a slash to the string. On VMS, the function
1329 converts a string of the form @file{[X]Y.DIR.1} to the form
1334 (file-name-as-directory "~rms/lewis")
1335 @result{} "~rms/lewis/"
1340 @defun directory-file-name dirname
1341 This function returns a string representing @var{dirname} in a form
1342 that the operating system will interpret as the name of a file. On
1343 Unix, this means removing a final slash from the string. On VMS, the
1344 function converts a string of the form @file{[X.Y]} to
1349 (directory-file-name "~lewis/")
1355 @cindex directory name abbreviation
1356 Directory name abbreviations are useful for directories that are
1357 normally accessed through symbolic links. Sometimes the users recognize
1358 primarily the link's name as ``the name'' of the directory, and find it
1359 annoying to see the directory's ``real'' name. If you define the link
1360 name as an abbreviation for the ``real'' name, Emacs shows users the
1361 abbreviation instead.
1363 @defvar directory-abbrev-alist
1364 The variable @code{directory-abbrev-alist} contains an alist of
1365 abbreviations to use for file directories. Each element has the form
1366 @code{(@var{from} . @var{to})}, and says to replace @var{from} with
1367 @var{to} when it appears in a directory name. The @var{from} string is
1368 actually a regular expression; it should always start with @samp{^}.
1369 The function @code{abbreviate-file-name} performs these substitutions.
1371 You can set this variable in @file{site-init.el} to describe the
1372 abbreviations appropriate for your site.
1374 Here's an example, from a system on which file system @file{/home/fsf}
1375 and so on are normally accessed through symbolic links named @file{/fsf}
1379 (("^/home/fsf" . "/fsf")
1380 ("^/home/gp" . "/gp")
1381 ("^/home/gd" . "/gd"))
1385 To convert a directory name to its abbreviation, use this
1388 @defun abbreviate-file-name dirname
1389 This function applies abbreviations from @code{directory-abbrev-alist}
1390 to its argument, and substitutes @samp{~} for the user's home
1394 @node Relative File Names
1395 @subsection Absolute and Relative File Names
1396 @cindex absolute file name
1397 @cindex relative file name
1399 All the directories in the file system form a tree starting at the
1400 root directory. A file name can specify all the directory names
1401 starting from the root of the tree; then it is called an @dfn{absolute}
1402 file name. Or it can specify the position of the file in the tree
1403 relative to a default directory; then it is called a @dfn{relative}
1404 file name. On Unix, an absolute file name starts with a slash or a
1405 tilde (@samp{~}), and a relative one does not. The rules on VMS are
1408 @defun file-name-absolute-p filename
1409 This function returns @code{t} if file @var{filename} is an absolute
1410 file name, @code{nil} otherwise. On VMS, this function understands both
1411 Unix syntax and VMS syntax.
1415 (file-name-absolute-p "~rms/foo")
1419 (file-name-absolute-p "rms/foo")
1423 (file-name-absolute-p "/user/rms/foo")
1429 @node File Name Expansion
1430 @subsection Functions that Expand Filenames
1431 @cindex expansion of file names
1433 @dfn{Expansion} of a file name means converting a relative file name
1434 to an absolute one. Since this is done relative to a default directory,
1435 you must specify the default directory name as well as the file name to
1436 be expanded. Expansion also simplifies file names by eliminating
1437 redundancies such as @file{./} and @file{@var{name}/../}.
1439 @defun expand-file-name filename &optional directory
1440 This function converts @var{filename} to an absolute file name. If
1441 @var{directory} is supplied, it is the directory to start with if
1442 @var{filename} is relative. (The value of @var{directory} should itself
1443 be an absolute directory name; it may start with @samp{~}.)
1444 Otherwise, the current buffer's value of @code{default-directory} is
1449 (expand-file-name "foo")
1450 @result{} "/xcssun/users/rms/lewis/foo"
1453 (expand-file-name "../foo")
1454 @result{} "/xcssun/users/rms/foo"
1457 (expand-file-name "foo" "/usr/spool/")
1458 @result{} "/usr/spool/foo"
1461 (expand-file-name "$HOME/foo")
1462 @result{} "/xcssun/users/rms/lewis/$HOME/foo"
1466 Filenames containing @samp{.} or @samp{..} are simplified to their
1471 (expand-file-name "bar/../foo")
1472 @result{} "/xcssun/users/rms/lewis/foo"
1476 @samp{~/} is expanded into the user's home directory. A @samp{/} or
1477 @samp{~} following a @samp{/} is taken to be the start of an absolute
1478 file name that overrides what precedes it, so everything before that
1479 @samp{/} or @samp{~} is deleted. For example:
1484 "/a1/gnu//usr/local/lib/emacs/etc/MACHINES")
1485 @result{} "/usr/local/lib/emacs/etc/MACHINES"
1488 (expand-file-name "/a1/gnu/~/foo")
1489 @result{} "/xcssun/users/rms/foo"
1494 In both cases, @file{/a1/gnu/} is discarded because an absolute file
1497 Note that @code{expand-file-name} does @emph{not} expand environment
1498 variables; only @code{substitute-in-file-name} does that.
1502 @defun file-relative-name filename directory
1503 This function does the inverse of expansion---it tries to return a
1504 relative name which is equivalent to @var{filename} when interpreted
1505 relative to @var{directory}. (If such a relative name would be longer
1506 than the absolute name, it returns the absolute name instead.)
1509 (file-relative-name "/foo/bar" "/foo/")
1511 (file-relative-name "/foo/bar" "/hack/")
1512 @result{} "/foo/bar")
1516 @defvar default-directory
1517 The value of this buffer-local variable is the default directory for the
1518 current buffer. It should be an absolute directory name; it may start
1519 with @samp{~}. This variable is local in every buffer.
1521 @code{expand-file-name} uses the default directory when its second
1522 argument is @code{nil}.
1524 On Unix systems, the value is always a string ending with a slash.
1529 @result{} "/user/lewis/manual/"
1534 @defun substitute-in-file-name filename
1535 This function replaces environment variables references in
1536 @var{filename} with the environment variable values. Following standard
1537 Unix shell syntax, @samp{$} is the prefix to substitute an environment
1540 The environment variable name is the series of alphanumeric characters
1541 (including underscores) that follow the @samp{$}. If the character following
1542 the @samp{$} is a @samp{@{}, then the variable name is everything up to the
1545 @c Wordy to avoid overfull hbox. --rjc 15mar92
1546 Here we assume that the environment variable @code{HOME}, which holds
1547 the user's home directory name, has value @samp{/xcssun/users/rms}.
1551 (substitute-in-file-name "$HOME/foo")
1552 @result{} "/xcssun/users/rms/foo"
1556 If a @samp{~} or a @samp{/} appears following a @samp{/}, after
1557 substitution, everything before the following @samp{/} is discarded:
1561 (substitute-in-file-name "bar/~/foo")
1565 (substitute-in-file-name "/usr/local/$HOME/foo")
1566 @result{} "/xcssun/users/rms/foo"
1570 On VMS, @samp{$} substitution is not done, so this function does nothing
1571 on VMS except discard superfluous initial components as shown above.
1574 @node Unique File Names
1575 @subsection Generating Unique File Names
1577 Some programs need to write temporary files. Here is the usual way to
1578 construct a name for such a file:
1581 (make-temp-name (concat "/tmp/" @var{name-of-application}))
1585 Here we use the directory @file{/tmp/} because that is the standard
1586 place on Unix for temporary files. The job of @code{make-temp-name} is
1587 to prevent two different users or two different jobs from trying to use
1590 @defun make-temp-name string
1591 This function generates string that can be used as a unique name. The
1592 name starts with the prefix @var{string}, and ends with a number that
1593 is different in each Emacs job.
1597 (make-temp-name "/tmp/foo")
1598 @result{} "/tmp/foo021304"
1602 To prevent conflicts among different libraries running in the same
1603 Emacs, each Lisp program that uses @code{make-temp-name} should have its
1604 own @var{string}. The number added to the end of the name distinguishes
1605 between the same application running in different Emacs jobs.
1608 @node File Name Completion
1609 @subsection File Name Completion
1610 @cindex file name completion subroutines
1611 @cindex completion, file name
1613 This section describes low-level subroutines for completing a file
1614 name. For other completion functions, see @ref{Completion}.
1616 @defun file-name-all-completions partial-filename directory
1617 This function returns a list of all possible completions for a file
1618 whose name starts with @var{partial-filename} in directory
1619 @var{directory}. The order of the completions is the order of the files
1620 in the directory, which is unpredictable and conveys no useful
1623 The argument @var{partial-filename} must be a file name containing no
1624 directory part and no slash. The current buffer's default directory is
1625 prepended to @var{directory}, if @var{directory} is not absolute.
1627 In the following example, suppose that the current default directory,
1628 @file{~rms/lewis}, has five files whose names begin with @samp{f}:
1629 @file{foo}, @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1630 @file{file.c.~2~}.@refill
1634 (file-name-all-completions "f" "")
1635 @result{} ("foo" "file~" "file.c.~2~"
1636 "file.c.~1~" "file.c")
1640 (file-name-all-completions "fo" "")
1646 @defun file-name-completion filename directory
1647 This function completes the file name @var{filename} in directory
1648 @var{directory}. It returns the longest prefix common to all file names
1649 in directory @var{directory} that start with @var{filename}.
1651 If only one match exists and @var{filename} matches it exactly, the
1652 function returns @code{t}. The function returns @code{nil} if directory
1653 @var{directory} contains no name starting with @var{filename}.
1655 In the following example, suppose that the current default directory
1656 has five files whose names begin with @samp{f}: @file{foo},
1657 @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1658 @file{file.c.~2~}.@refill
1662 (file-name-completion "fi" "")
1667 (file-name-completion "file.c.~1" "")
1668 @result{} "file.c.~1~"
1672 (file-name-completion "file.c.~1~" "")
1677 (file-name-completion "file.c.~3" "")
1683 @defopt completion-ignored-extensions
1684 @code{file-name-completion} usually ignores file names that end in any
1685 string in this list. It does not ignore them when all the possible
1686 completions end in one of these suffixes or when a buffer showing all
1687 possible completions is displayed.@refill
1689 A typical value might look like this:
1693 completion-ignored-extensions
1694 @result{} (".o" ".elc" "~" ".dvi")
1699 @node Contents of Directories
1700 @section Contents of Directories
1701 @cindex directory-oriented functions
1702 @cindex file names in directory
1704 A directory is a kind of file that contains other files entered under
1705 various names. Directories are a feature of the file system.
1707 Emacs can list the names of the files in a directory as a Lisp list,
1708 or display the names in a buffer using the @code{ls} shell command. In
1709 the latter case, it can optionally display information about each file,
1710 depending on the options passed to the @code{ls} command.
1712 @defun directory-files directory &optional full-name match-regexp nosort
1713 This function returns a list of the names of the files in the directory
1714 @var{directory}. By default, the list is in alphabetical order.
1716 If @var{full-name} is non-@code{nil}, the function returns the files'
1717 absolute file names. Otherwise, it returns the names relative to
1718 the specified directory.
1720 If @var{match-regexp} is non-@code{nil}, this function returns only
1721 those file names that contain a match for that regular expression---the
1722 other file names are excluded from the list.
1725 If @var{nosort} is non-@code{nil}, @code{directory-files} does not sort
1726 the list, so you get the file names in no particular order. Use this if
1727 you want the utmost possible speed and don't care what order the files
1728 are processed in. If the order of processing is visible to the user,
1729 then the user will probably be happier if you do sort the names.
1733 (directory-files "~lewis")
1734 @result{} ("#foo#" "#foo.el#" "." ".."
1735 "dired-mods.el" "files.texi"
1740 An error is signaled if @var{directory} is not the name of a directory
1744 @defun file-name-all-versions file dirname
1745 This function returns a list of all versions of the file named
1746 @var{file} in directory @var{dirname}.
1749 @defun insert-directory file switches &optional wildcard full-directory-p
1750 This function inserts a directory listing for directory @var{dir},
1751 formatted with @code{ls} according to @var{switches}. It leaves point
1752 after the inserted text.
1754 The argument @var{dir} may be either a directory name or a file
1755 specification including wildcard characters. If @var{wildcard} is
1756 non-@code{nil}, that means treat @var{file} as a file specification with
1759 If @var{full-directory-p} is non-@code{nil}, that means @var{file} is a
1760 directory and switches do not contain @samp{d}, so that a full listing
1763 This function works by running a directory listing program whose name is
1764 in the variable @code{insert-directory-program}. If @var{wildcard} is
1765 non-@code{nil}, it also runs the shell specified by
1766 @code{shell-file-name}, to expand the wildcards.
1769 @defvar insert-directory-program
1770 This variable's value is the program to run to generate a directory listing
1771 for the function @code{insert-directory}.
1774 @node Create/Delete Dirs
1775 @section Creating and Deleting Directories
1776 @c Emacs 19 features
1778 @defun make-directory dirname
1779 This function creates a directory named @var{dirname}.
1782 @defun delete-directory dirname
1783 This function deletes the directory named @var{dirname}. The function
1784 @code{delete-file} does not work for files that are directories; you
1785 must use @code{delete-directory} in that case.
1788 @node Magic File Names
1789 @section Making Certain File Names ``Magic''
1790 @cindex magic file names
1793 You can implement special handling for certain file names. This is
1794 called making those names @dfn{magic}. You must supply a regular
1795 expression to define the class of names (all those which match the
1796 regular expression), plus a handler that implements all the primitive
1797 Emacs file operations for file names that do match.
1799 The value of @code{file-name-handler-alist} is a list of handlers,
1800 together with regular expressions that determine when to apply each
1801 handler. Each element has this form:
1804 (@var{regexp} . @var{handler})
1808 All the Emacs primitives for file access and file name transformation
1809 check the given file name against @code{file-name-handler-alist}. If
1810 the file name matches @var{regexp}, the primitives handle that file by
1811 calling @var{handler}.
1813 The first argument given to @var{handler} is the name of the primitive;
1814 the remaining arguments are the arguments that were passed to that
1815 operation. (The first of these arguments is typically the file name
1816 itself.) For example, if you do this:
1819 (file-exists-p @var{filename})
1823 and @var{filename} has handler @var{handler}, then @var{handler} is
1827 (funcall @var{handler} 'file-exists-p @var{filename})
1830 Here are the operations that you can handle for a magic file name:
1833 @code{add-name-to-file}, @code{copy-file}, @code{delete-directory},
1834 @code{delete-file},@*
1835 @code{directory-file-name},
1836 @code{diff-latest-backup-file}, @code{directory-files},
1837 @code{dired-compress-file}, @code{dired-uncache},
1838 @code{expand-file-name},@*
1839 @code{file-accessible-directory-p},
1840 @code{file-attributes}, @code{file-directory-p},
1841 @code{file-executable-p}, @code{file-exists-p}, @code{file-local-copy},
1842 @code{file-modes}, @code{file-name-all-completions},
1843 @code{file-name-as-directory}, @code{file-name-completion},
1844 @code{file-name-directory}, @code{file-name-nondirectory},
1845 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
1846 @code{file-readable-p}, @code{file-symlink-p}, @code{file-truename},
1847 @code{file-writable-p}, @code{insert-directory},
1848 @code{insert-file-contents}, @code{load}, @code{make-directory},
1849 @code{make-symbolic-link}, @code{rename-file}, @code{set-file-modes},
1850 @code{set-visited-file-modtime}, @code{unhandled-file-name-directory},
1851 @code{verify-visited-file-modtime}, @code{write-region}.
1853 The handler function must handle all of the above operations, and
1854 possibly others to be added in the future. Therefore, it should always
1855 reinvoke the ordinary Lisp primitive when it receives an operation it
1856 does not recognize. Here's one way to do this:
1859 (defun my-file-handler (operation &rest args)
1860 ;; @r{First check for the specific operations}
1861 ;; @r{that we have special handling for.}
1862 (cond ((eq operation 'insert-file-contents) @dots{})
1863 ((eq operation 'write-region) @dots{})
1865 ;; @r{Handle any operation we don't know about.}
1866 (t (let (file-name-handler-alist)
1867 (apply operation args)))))
1870 @defun find-file-name-handler file
1871 This function returns the handler function for file name @var{file}, or
1872 @code{nil} if there is none.
1875 @defun file-local-copy filename
1876 This function copies file @var{filename} to the local site, if it isn't
1877 there already. If @var{filename} specifies a ``magic'' file name which
1878 programs outside Emacs cannot directly read or write, this copies the
1879 contents to an ordinary file and returns that file's name.
1881 If @var{filename} is an ordinary file name, not magic, then this function
1882 does nothing and returns @code{nil}.
1885 @defun unhandled-file-name-directory filename
1886 This function returns the name of a directory that is not magic.
1887 It uses the directory part of @var{filename} if that is not magic.
1888 Otherwise, it asks the handler what to do.
1890 This is useful for running a subprocess; every subprocess must have a
1891 non-magic directory to serve as its current directory, and this function
1892 is a good way to come up with one.