comparison lispref/files.texi @ 6555:771fa0ddb356

Initial revision
author Richard M. Stallman <rms@gnu.org>
date Mon, 28 Mar 1994 18:36:14 +0000
parents
children 5a93e6fb43a4
comparison
equal deleted inserted replaced
6554:5f8effa94d20 6555:771fa0ddb356
1 @c -*-texinfo-*-
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
8 @chapter Files
9
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}.
15
16 @menu
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.
30 @end menu
31
32 @node Visiting Files
33 @section Visiting Files
34 @cindex finding files
35 @cindex visiting files
36
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.
40
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
50 back into the file.
51
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.
58
59 @menu
60 * Visiting Functions:: The usual interface functions for visiting.
61 * Subroutines of Visiting:: Lower-level subroutines that they use.
62 @end menu
63
64 @node Visiting Functions
65 @subsection Functions for Visiting Files
66
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.
72
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.
77
78 The body of the @code{find-file} function is very simple and looks
79 like this:
80
81 @example
82 (switch-to-buffer (find-file-noselect filename))
83 @end example
84
85 @noindent
86 (See @code{switch-to-buffer} in @ref{Displaying Buffers}.)
87
88 When @code{find-file} is called interactively, it prompts for
89 @var{filename} in the minibuffer.
90 @end deffn
91
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.
98
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.
104
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.
108
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}.
114
115 The @code{find-file-noselect} function returns the buffer that is
116 visiting the file @var{filename}.
117
118 @example
119 @group
120 (find-file-noselect "/etc/fstab")
121 @result{} #<buffer fstab>
122 @end group
123 @end example
124 @end defun
125
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.
132
133 When this command is called interactively, it prompts for @var{filename}.
134 @end deffn
135
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}.
140
141 When this command is called interactively, it prompts for
142 @var{filename}.
143 @end deffn
144
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.
149
150 When this command is called interactively, it prompts for
151 @var{filename}.
152 @end deffn
153
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}.
159
160 When @code{view-file} is called interactively, it prompts for
161 @var{filename}.
162 @end deffn
163
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.
169
170 This variable works just like a normal hook, but we think that renaming
171 it would not be advisable.
172 @end defvar
173
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
180 already set up.
181
182 This is not a normal hook because the values of the functions are
183 used and they may not all be called.
184 @end defvar
185
186 @node Subroutines of Visiting
187 @comment node-name, next, previous, up
188 @subsection Subroutines of Visiting
189
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.
193
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}.
199
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.
202
203 @example
204 @group
205 (create-file-buffer "foo")
206 @result{} #<buffer foo>
207 @end group
208 @group
209 (create-file-buffer "foo")
210 @result{} #<buffer foo<2>>
211 @end group
212 @group
213 (create-file-buffer "foo")
214 @result{} #<buffer foo<3>>
215 @end group
216 @end example
217
218 This function is used by @code{find-file-noselect}.
219 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
220 @end defun
221
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}).
226
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}.
234
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.
237
238 The last thing @code{after-find-file} does is call all the functions
239 in @code{find-file-hooks}.
240 @end defun
241
242 @node Saving Buffers
243 @section Saving Buffers
244
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.
250
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.
255
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:
261
262 @itemize @bullet
263 @item
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.
267
268 @item
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.
272 @end itemize
273 @end deffn
274
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
279 the user.
280
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
287 for this argument.
288 @end deffn
289
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}.
295 @end defvar
296
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}.
303 @end deffn
304
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
310 executed.
311
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:
315
316 @example
317 (or buffer-backed-up (backup-buffer))
318 @end example
319
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.
323
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}.
326 @end defvar
327
328 @c Emacs 19 feature
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.
333
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.
338 @end defvar
339
340 @c Emacs 19 feature
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.
346 @end defvar
347
348 @c Emacs 19 feature
349 @defvar after-save-hook
350 This normal hook runs after a buffer has been saved in its visited file.
351 @end defvar
352
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
359 invalid file.
360
361 (This feature worked differently in older Emacs versions.)
362
363 Some modes set this non-@code{nil} locally in particular buffers.
364 @end defvar
365
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
373 case arises.
374
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.
378 @end defopt
379
380 @node Reading from Files
381 @comment node-name, next, previous, up
382 @section Reading from Files
383
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.
387
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.
393
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}.
397
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.
403
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,
407
408 @example
409 (insert-file-contents filename nil 0 500)
410 @end example
411
412 @noindent
413 inserts the first 500 characters of a file.
414
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.
420 @end defun
421
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}.
425
426 @node Writing to Files
427 @comment node-name, next, previous, up
428 @section Writing to Files
429
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.
435
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}.
441
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.
444 @end deffn
445
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}.
449
450 @c Emacs 19 feature
451 If @var{start} is a string, then @code{write-region} writes or appends
452 that string, rather than text from the buffer.
453
454 If @var{append} is non-@code{nil}, then the specified text is appended
455 to the existing file contents (if any).
456
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
462 it yourself.
463
464 @c Emacs 19 feature
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.
472
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}.
476
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.
482 @end deffn
483
484 @node File Locks
485 @section File Locks
486 @cindex file locks
487
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.
493
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}.
501
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.
507
508 @example
509 @group
510 (file-locked-p "foo")
511 @result{} nil
512 @end group
513 @end example
514 @end defun
515
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.
521 @end defun
522
523 @defun unlock-buffer
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.
528 @end defun
529
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:
534
535 @itemize @bullet
536 @item
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.
539
540 @item
541 A value of @code{nil} says to ignore the lock and let this
542 user edit the file anyway.
543
544 @item
545 @kindex file-locked
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.
548
549 The error message for this error looks like this:
550
551 @example
552 @error{} File is locked: @var{file} @var{other-user}
553 @end example
554
555 @noindent
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.
558 @end itemize
559
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}.
564 @end defun
565
566 @node Information about Files
567 @section Information about Files
568
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
574 otherwise noted.
575
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}.
582
583 @menu
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.
588 @end menu
589
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
595
596 These functions test for permission to access a file in specific ways.
597
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.)
604
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
607 returns @code{nil}.
608 @end defun
609
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.
613
614 @example
615 @group
616 (file-readable-p "files.texi")
617 @result{} t
618 @end group
619 @group
620 (file-exists-p "/usr/spool/mqueue")
621 @result{} t
622 @end group
623 @group
624 (file-readable-p "/usr/spool/mqueue")
625 @result{} nil
626 @end group
627 @end example
628 @end defun
629
630 @c Emacs 19 feature
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
636 modes permit.
637 @end defun
638
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.
645
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
648 a directory.
649
650 @example
651 @group
652 (file-writable-p "~/foo")
653 @result{} t
654 @end group
655 @group
656 (file-writable-p "/foo")
657 @result{} nil
658 @end group
659 @group
660 (file-writable-p "~/no-such-dir/foo")
661 @result{} nil
662 @end group
663 @end example
664 @end defun
665
666 @c Emacs 19 feature
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.
672
673 Example: after the following,
674
675 @example
676 (file-accessible-directory-p "/foo")
677 @result{} nil
678 @end example
679
680 @noindent
681 we can deduce that any attempt to read a file in @file{/foo/} will
682 give an error.
683 @end defun
684
685 @defun file-newer-than-file-p filename1 filename2
686 @cindex file age
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,
691 it returns @code{t}.
692
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.
696
697 @example
698 @group
699 (file-newer-than-file-p "aug-19" "aug-20")
700 @result{} nil
701 @end group
702 @group
703 (file-newer-than-file-p "aug-20" "aug-19")
704 @result{} t
705 @end group
706 @group
707 (file-newer-than-file-p "aug-19" "no-file")
708 @result{} t
709 @end group
710 @group
711 (file-newer-than-file-p "no-file" "aug-19")
712 @result{} nil
713 @end group
714 @end example
715
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}.
718 @end defun
719
720 @node Kinds of Files
721 @comment node-name, next, previous, up
722 @subsection Distinguishing Kinds of Files
723
724 This section describes how to distinguish directories and symbolic
725 links from ordinary files.
726
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
732 no file at all.
733
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}.
736
737 @example
738 @group
739 (file-symlink-p "foo")
740 @result{} nil
741 @end group
742 @group
743 (file-symlink-p "sym-link")
744 @result{} "foo"
745 @end group
746 @group
747 (file-symlink-p "sym-link2")
748 @result{} "sym-link"
749 @end group
750 @group
751 (file-symlink-p "/bin")
752 @result{} "/pub/bin"
753 @end group
754 @end example
755
756 @c !!! file-symlink-p: should show output of ls -l for comparison
757 @end defun
758
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.
762
763 @example
764 @group
765 (file-directory-p "~rms")
766 @result{} t
767 @end group
768 @group
769 (file-directory-p "~rms/lewis/files.texi")
770 @result{} nil
771 @end group
772 @group
773 (file-directory-p "~rms/lewis/no-such-file")
774 @result{} nil
775 @end group
776 @group
777 (file-directory-p "$HOME")
778 @result{} nil
779 @end group
780 @group
781 (file-directory-p
782 (substitute-in-file-name "$HOME"))
783 @result{} t
784 @end group
785 @end example
786 @end defun
787
788 @node Truenames
789 @subsection Truenames
790 @cindex truename (of file)
791
792 @c Emacs 19 features
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.
799
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.
804 @end defun
805
806 @xref{Buffer File Name}, for related information.
807
808 @node File Attributes
809 @comment node-name, next, previous, up
810 @subsection Other Information about Files
811
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
816 and modification.
817
818 @defun file-modes filename
819 @cindex permission
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.
826
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.
830
831 @example
832 @group
833 (file-modes "~/junk/diffs")
834 @result{} 492 ; @r{Decimal integer.}
835 @end group
836 @group
837 (format "%o" 492)
838 @result{} "754" ; @r{Convert to octal.}
839 @end group
840
841 @group
842 (set-file-modes "~/junk/diffs" 438)
843 @result{} nil
844 @end group
845
846 @group
847 (format "%o" 438)
848 @result{} "666" ; @r{Convert to octal.}
849 @end group
850
851 @group
852 % ls -l diffs
853 -rw-rw-rw- 1 lewis 0 3063 Oct 30 16:00 diffs
854 @end group
855 @end example
856 @end defun
857
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
863 link to.
864
865 @example
866 @group
867 % ls -l foo*
868 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo
869 -rw-rw-rw- 2 rms 4 Aug 19 01:27 foo1
870 @end group
871
872 @group
873 (file-nlinks "foo")
874 @result{} 2
875 @end group
876 @group
877 (file-nlinks "doesnt-exist")
878 @result{} nil
879 @end group
880 @end example
881 @end defun
882
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}.
886
887 The elements of the list, in order, are:
888
889 @enumerate 0
890 @item
891 @code{t} for a directory, a string for a symbolic link (the name
892 linked to), or @code{nil} for a text file.
893
894 @c Wordy so as to prevent an overfull hbox. --rjc 15mar92
895 @item
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}).
899
900 @item
901 The file's @sc{uid}.
902
903 @item
904 The file's @sc{gid}.
905
906 @item
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}.)
911
912 @item
913 The time of last modification as a list of two integers (as above).
914
915 @item
916 The time of last status change as a list of two integers (as above).
917
918 @item
919 The size of the file in bytes.
920
921 @item
922 The file's modes, as a string of ten letters or dashes
923 as in @samp{ls -l}.
924
925 @item
926 @code{t} if the file's @sc{gid} would change if file were
927 deleted and recreated; @code{nil} otherwise.
928
929 @item
930 The file's inode number.
931
932 @item
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.
937 @end enumerate
938
939 For example, here are the file attributes for @file{files.texi}:
940
941 @example
942 @group
943 (file-attributes "files.texi")
944 @result{} (nil
945 1
946 2235
947 75
948 (8489 20284)
949 (8489 20284)
950 (8489 20285)
951 14906
952 "-rw-rw-rw-"
953 nil
954 129500
955 -32252)
956 @end group
957 @end example
958
959 @noindent
960 and here is how the result is interpreted:
961
962 @table @code
963 @item nil
964 is neither a directory nor a symbolic link.
965
966 @item 1
967 has only one name (the name @file{files.texi} in the current default
968 directory).
969
970 @item 2235
971 is owned by the user with @sc{uid} 2235.
972
973 @item 75
974 is in the group with @sc{gid} 75.
975
976 @item (8489 20284)
977 was last accessed on Aug 19 00:09. Unfortunately, you cannot convert
978 this number into a time string in Emacs.
979
980 @item (8489 20284)
981 was last modified on Aug 19 00:09.
982
983 @item (8489 20285)
984 last had its inode changed on Aug 19 00:09.
985
986 @item 14906
987 is 14906 characters long.
988
989 @item "-rw-rw-rw-"
990 has a mode of read and write access for the owner, group, and world.
991
992 @item nil
993 would retain the same @sc{gid} if it were recreated.
994
995 @item 129500
996 has an inode number of 129500.
997 @item -32252
998 is on file system number -32252.
999 @end table
1000 @end defun
1001
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
1009
1010 The functions in this section rename, copy, delete, link, and set the
1011 modes of files.
1012
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}:
1016
1017 @itemize @bullet
1018 @item
1019 Signal a @code{file-already-exists} error if
1020 @var{ok-if-already-exists} is @code{nil}.
1021
1022 @item
1023 Request confirmation if @var{ok-if-already-exists} is a number.
1024
1025 @item
1026 Replace the old file without confirmation if @var{ok-if-already-exists}
1027 is any other value.
1028 @end itemize
1029
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}.
1036
1037 In the first part of the following example, we list two files,
1038 @file{foo} and @file{foo3}.
1039
1040 @example
1041 @group
1042 % ls -l fo*
1043 -rw-rw-rw- 1 rms 29 Aug 18 20:32 foo
1044 -rw-rw-rw- 1 rms 24 Aug 18 20:31 foo3
1045 @end group
1046 @end example
1047
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}.
1051
1052 @example
1053 @group
1054 (add-name-to-file "~/lewis/foo1" "~/lewis/foo2")
1055 @result{} nil
1056 @end group
1057
1058 @group
1059 % ls -l fo*
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
1063 @end group
1064 @end example
1065
1066 @c !!! Check whether this set of examples is consistent. --rjc 15mar92
1067 Finally, we evaluate the following:
1068
1069 @example
1070 (add-name-to-file "~/lewis/foo" "~/lewis/foo3" t)
1071 @end example
1072
1073 @noindent
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.
1077
1078 @example
1079 @group
1080 (add-name-to-file "~/lewis/foo1" "~/lewis/foo3")
1081 @result{} nil
1082 @end group
1083
1084 @group
1085 % ls -l fo*
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
1089 @end group
1090 @end example
1091
1092 This function is meaningless on VMS, where multiple names for one file
1093 are not allowed.
1094
1095 See also @code{file-nlinks} in @ref{File Attributes}.
1096 @end defun
1097
1098 @deffn Command rename-file filename newname &optional ok-if-already-exists
1099 This command renames the file @var{filename} as @var{newname}.
1100
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.
1105
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.
1109 @end deffn
1110
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.
1114
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.)
1118
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.
1122 @end deffn
1123
1124 @deffn Command delete-file filename
1125 @pindex rm
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.
1129
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.)
1133
1134 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1135 @end deffn
1136
1137 @deffn Command make-symbolic-link filename newname &optional ok-if-exists
1138 @pindex ln
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}}.
1143
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
1146 exists.
1147 @end deffn
1148
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.
1152 @end defun
1153
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.
1157 @end defun
1158
1159 @c Emacs 19 feature
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.
1165
1166 The argument @var{mode} must be an integer. Only the 9 low bits of
1167 @var{mode} are used.
1168
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.
1172 @end defun
1173
1174 @defun default-file-modes
1175 This function returns the current default protection value.
1176 @end defun
1177
1178 @node File Names
1179 @section File Names
1180 @cindex file names
1181
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.
1185
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.
1190
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
1193 directory.
1194
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
1198 change.
1199
1200 @menu
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.
1208 @end menu
1209
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)
1215
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.
1222
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
1225 complicated.
1226
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
1232 directory lists.
1233
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{>}.
1240
1241 @example
1242 @group
1243 (file-name-directory "lewis/foo") ; @r{Unix example}
1244 @result{} "lewis/"
1245 @end group
1246 @group
1247 (file-name-directory "foo") ; @r{Unix example}
1248 @result{} nil
1249 @end group
1250 @group
1251 (file-name-directory "[X]FOO.TMP") ; @r{VMS example}
1252 @result{} "[X]"
1253 @end group
1254 @end example
1255 @end defun
1256
1257 @defun file-name-nondirectory filename
1258 This function returns the nondirectory part of @var{filename}.
1259
1260 @example
1261 @group
1262 (file-name-nondirectory "lewis/foo")
1263 @result{} "foo"
1264 @end group
1265 @group
1266 (file-name-nondirectory "foo")
1267 @result{} "foo"
1268 @end group
1269 @group
1270 ;; @r{The following example is accurate only on VMS.}
1271 (file-name-nondirectory "[X]FOO.TMP")
1272 @result{} "FOO.TMP"
1273 @end group
1274 @end example
1275 @end defun
1276
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.
1280
1281 @example
1282 @group
1283 (file-name-sans-versions "~rms/foo.~1~")
1284 @result{} "~rms/foo"
1285 @end group
1286 @group
1287 (file-name-sans-versions "~rms/foo~")
1288 @result{} "~rms/foo"
1289 @end group
1290 @group
1291 (file-name-sans-versions "~rms/foo")
1292 @result{} "~rms/foo"
1293 @end group
1294 @group
1295 ;; @r{The following example applies to VMS only.}
1296 (file-name-sans-versions "foo;23")
1297 @result{} "foo"
1298 @end group
1299 @end example
1300 @end defun
1301
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
1307
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.
1315
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
1319 acceptable.
1320
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{..}.
1324
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
1330 @file{[X.Y]}.
1331
1332 @example
1333 @group
1334 (file-name-as-directory "~rms/lewis")
1335 @result{} "~rms/lewis/"
1336 @end group
1337 @end example
1338 @end defun
1339
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
1345 @file{[X]Y.DIR.1}.
1346
1347 @example
1348 @group
1349 (directory-file-name "~lewis/")
1350 @result{} "~lewis"
1351 @end group
1352 @end example
1353 @end defun
1354
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.
1362
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.
1370
1371 You can set this variable in @file{site-init.el} to describe the
1372 abbreviations appropriate for your site.
1373
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}
1376 and so on.
1377
1378 @example
1379 (("^/home/fsf" . "/fsf")
1380 ("^/home/gp" . "/gp")
1381 ("^/home/gd" . "/gd"))
1382 @end example
1383 @end defvar
1384
1385 To convert a directory name to its abbreviation, use this
1386 function:
1387
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
1391 directory.
1392 @end defun
1393
1394 @node Relative File Names
1395 @subsection Absolute and Relative File Names
1396 @cindex absolute file name
1397 @cindex relative file name
1398
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
1406 complicated.
1407
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.
1412
1413 @example
1414 @group
1415 (file-name-absolute-p "~rms/foo")
1416 @result{} t
1417 @end group
1418 @group
1419 (file-name-absolute-p "rms/foo")
1420 @result{} nil
1421 @end group
1422 @group
1423 (file-name-absolute-p "/user/rms/foo")
1424 @result{} t
1425 @end group
1426 @end example
1427 @end defun
1428
1429 @node File Name Expansion
1430 @subsection Functions that Expand Filenames
1431 @cindex expansion of file names
1432
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}/../}.
1438
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
1445 used. For example:
1446
1447 @example
1448 @group
1449 (expand-file-name "foo")
1450 @result{} "/xcssun/users/rms/lewis/foo"
1451 @end group
1452 @group
1453 (expand-file-name "../foo")
1454 @result{} "/xcssun/users/rms/foo"
1455 @end group
1456 @group
1457 (expand-file-name "foo" "/usr/spool/")
1458 @result{} "/usr/spool/foo"
1459 @end group
1460 @group
1461 (expand-file-name "$HOME/foo")
1462 @result{} "/xcssun/users/rms/lewis/$HOME/foo"
1463 @end group
1464 @end example
1465
1466 Filenames containing @samp{.} or @samp{..} are simplified to their
1467 canonical form:
1468
1469 @example
1470 @group
1471 (expand-file-name "bar/../foo")
1472 @result{} "/xcssun/users/rms/lewis/foo"
1473 @end group
1474 @end example
1475
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:
1480
1481 @example
1482 @group
1483 (expand-file-name
1484 "/a1/gnu//usr/local/lib/emacs/etc/MACHINES")
1485 @result{} "/usr/local/lib/emacs/etc/MACHINES"
1486 @end group
1487 @group
1488 (expand-file-name "/a1/gnu/~/foo")
1489 @result{} "/xcssun/users/rms/foo"
1490 @end group
1491 @end example
1492
1493 @noindent
1494 In both cases, @file{/a1/gnu/} is discarded because an absolute file
1495 name follows it.
1496
1497 Note that @code{expand-file-name} does @emph{not} expand environment
1498 variables; only @code{substitute-in-file-name} does that.
1499 @end defun
1500
1501 @c Emacs 19 feature
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.)
1507
1508 @example
1509 (file-relative-name "/foo/bar" "/foo/")
1510 @result{} "bar")
1511 (file-relative-name "/foo/bar" "/hack/")
1512 @result{} "/foo/bar")
1513 @end example
1514 @end defun
1515
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.
1520
1521 @code{expand-file-name} uses the default directory when its second
1522 argument is @code{nil}.
1523
1524 On Unix systems, the value is always a string ending with a slash.
1525
1526 @example
1527 @group
1528 default-directory
1529 @result{} "/user/lewis/manual/"
1530 @end group
1531 @end example
1532 @end defvar
1533
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
1538 variable value.
1539
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
1543 matching @samp{@}}.
1544
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}.
1548
1549 @example
1550 @group
1551 (substitute-in-file-name "$HOME/foo")
1552 @result{} "/xcssun/users/rms/foo"
1553 @end group
1554 @end example
1555
1556 If a @samp{~} or a @samp{/} appears following a @samp{/}, after
1557 substitution, everything before the following @samp{/} is discarded:
1558
1559 @example
1560 @group
1561 (substitute-in-file-name "bar/~/foo")
1562 @result{} "~/foo"
1563 @end group
1564 @group
1565 (substitute-in-file-name "/usr/local/$HOME/foo")
1566 @result{} "/xcssun/users/rms/foo"
1567 @end group
1568 @end example
1569
1570 On VMS, @samp{$} substitution is not done, so this function does nothing
1571 on VMS except discard superfluous initial components as shown above.
1572 @end defun
1573
1574 @node Unique File Names
1575 @subsection Generating Unique File Names
1576
1577 Some programs need to write temporary files. Here is the usual way to
1578 construct a name for such a file:
1579
1580 @example
1581 (make-temp-name (concat "/tmp/" @var{name-of-application}))
1582 @end example
1583
1584 @noindent
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
1588 the same name.
1589
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.
1594
1595 @example
1596 @group
1597 (make-temp-name "/tmp/foo")
1598 @result{} "/tmp/foo021304"
1599 @end group
1600 @end example
1601
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.
1606 @end defun
1607
1608 @node File Name Completion
1609 @subsection File Name Completion
1610 @cindex file name completion subroutines
1611 @cindex completion, file name
1612
1613 This section describes low-level subroutines for completing a file
1614 name. For other completion functions, see @ref{Completion}.
1615
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
1621 information.
1622
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.
1626
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
1631
1632 @example
1633 @group
1634 (file-name-all-completions "f" "")
1635 @result{} ("foo" "file~" "file.c.~2~"
1636 "file.c.~1~" "file.c")
1637 @end group
1638
1639 @group
1640 (file-name-all-completions "fo" "")
1641 @result{} ("foo")
1642 @end group
1643 @end example
1644 @end defun
1645
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}.
1650
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}.
1654
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
1659
1660 @example
1661 @group
1662 (file-name-completion "fi" "")
1663 @result{} "file"
1664 @end group
1665
1666 @group
1667 (file-name-completion "file.c.~1" "")
1668 @result{} "file.c.~1~"
1669 @end group
1670
1671 @group
1672 (file-name-completion "file.c.~1~" "")
1673 @result{} t
1674 @end group
1675
1676 @group
1677 (file-name-completion "file.c.~3" "")
1678 @result{} nil
1679 @end group
1680 @end example
1681 @end defun
1682
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
1688
1689 A typical value might look like this:
1690
1691 @example
1692 @group
1693 completion-ignored-extensions
1694 @result{} (".o" ".elc" "~" ".dvi")
1695 @end group
1696 @end example
1697 @end defopt
1698
1699 @node Contents of Directories
1700 @section Contents of Directories
1701 @cindex directory-oriented functions
1702 @cindex file names in directory
1703
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.
1706
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.
1711
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.
1715
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.
1719
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.
1723
1724 @c Emacs 19 feature
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.
1730
1731 @example
1732 @group
1733 (directory-files "~lewis")
1734 @result{} ("#foo#" "#foo.el#" "." ".."
1735 "dired-mods.el" "files.texi"
1736 "files.texi.~1~")
1737 @end group
1738 @end example
1739
1740 An error is signaled if @var{directory} is not the name of a directory
1741 that can be read.
1742 @end defun
1743
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}.
1747 @end defun
1748
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.
1753
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
1757 wildcards.
1758
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
1761 is expected.
1762
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.
1767 @end defun
1768
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}.
1772 @end defvar
1773
1774 @node Create/Delete Dirs
1775 @section Creating and Deleting Directories
1776 @c Emacs 19 features
1777
1778 @defun make-directory dirname
1779 This function creates a directory named @var{dirname}.
1780 @end defun
1781
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.
1786 @end defun
1787
1788 @node Magic File Names
1789 @section Making Certain File Names ``Magic''
1790 @cindex magic file names
1791
1792 @c Emacs 19 feature
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.
1798
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:
1802
1803 @example
1804 (@var{regexp} . @var{handler})
1805 @end example
1806
1807 @noindent
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}.
1812
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:
1817
1818 @example
1819 (file-exists-p @var{filename})
1820 @end example
1821
1822 @noindent
1823 and @var{filename} has handler @var{handler}, then @var{handler} is
1824 called like this:
1825
1826 @example
1827 (funcall @var{handler} 'file-exists-p @var{filename})
1828 @end example
1829
1830 Here are the operations that you can handle for a magic file name:
1831
1832 @noindent
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}.
1852
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:
1857
1858 @example
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{})
1864 @dots{}
1865 ;; @r{Handle any operation we don't know about.}
1866 (t (let (file-name-handler-alist)
1867 (apply operation args)))))
1868 @end example
1869
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.
1873 @end defun
1874
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.
1880
1881 If @var{filename} is an ordinary file name, not magic, then this function
1882 does nothing and returns @code{nil}.
1883 @end defun
1884
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.
1889
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.
1893 @end defun