(sentence-end-double-space, sentence-end-without-period): Move to paragraphs.
[emacs.git] / lispref / files.texi
blob167ce9fa3174e3ffe6b1c39f54894773f2fee34f
1 @c -*-texinfo-*-
2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
4 @c   Free Software Foundation, Inc. 
5 @c See the file elisp.texi for copying conditions.
6 @setfilename ../info/files
7 @node Files, Backups and Auto-Saving, Documentation, Top
8 @comment  node-name,  next,  previous,  up
9 @chapter Files
11   In Emacs, you can find, create, view, save, and otherwise work with
12 files and file directories.  This chapter describes most of the
13 file-related functions of Emacs Lisp, but a few others are described in
14 @ref{Buffers}, and those related to backups and auto-saving are
15 described in @ref{Backups and Auto-Saving}.
17   Many of the file functions take one or more arguments that are file
18 names.  A file name is actually a string.  Most of these functions
19 expand file name arguments by calling @code{expand-file-name}, so that
20 @file{~} is handled correctly, as are relative file names (including
21 @samp{../}).  These functions don't recognize environment variable
22 substitutions such as @samp{$HOME}.  @xref{File Name Expansion}.
24   When file I/O functions signal Lisp errors, they usually use the
25 condition @code{file-error} (@pxref{Handling Errors}).  The error
26 message is in most cases obtained from the operating system, according
27 to locale @code{system-message-locale}, and decoded using coding system
28 @code{locale-coding-system} (@pxref{Locales}).
30 @menu
31 * Visiting Files::           Reading files into Emacs buffers for editing.
32 * Saving Buffers::           Writing changed buffers back into files.
33 * Reading from Files::       Reading files into buffers without visiting.
34 * Writing to Files::         Writing new files from parts of buffers.
35 * File Locks::               Locking and unlocking files, to prevent
36                                simultaneous editing by two people.
37 * Information about Files::  Testing existence, accessibility, size of files.
38 * Changing Files::           Renaming files, changing protection, etc.
39 * File Names::               Decomposing and expanding file names.
40 * Contents of Directories::  Getting a list of the files in a directory.
41 * Create/Delete Dirs::       Creating and Deleting Directories.
42 * Magic File Names::         Defining "magic" special handling
43                                for certain file names.
44 * Format Conversion::        Conversion to and from various file formats.
45 @end menu
47 @node Visiting Files
48 @section Visiting Files
49 @cindex finding files
50 @cindex visiting files
52   Visiting a file means reading a file into a buffer.  Once this is
53 done, we say that the buffer is @dfn{visiting} that file, and call the
54 file ``the visited file'' of the buffer.
56   A file and a buffer are two different things.  A file is information
57 recorded permanently in the computer (unless you delete it).  A buffer,
58 on the other hand, is information inside of Emacs that will vanish at
59 the end of the editing session (or when you kill the buffer).  Usually,
60 a buffer contains information that you have copied from a file; then we
61 say the buffer is visiting that file.  The copy in the buffer is what
62 you modify with editing commands.  Such changes to the buffer do not
63 change the file; therefore, to make the changes permanent, you must
64 @dfn{save} the buffer, which means copying the altered buffer contents
65 back into the file.
67   In spite of the distinction between files and buffers, people often
68 refer to a file when they mean a buffer and vice-versa.  Indeed, we say,
69 ``I am editing a file,'' rather than, ``I am editing a buffer that I
70 will soon save as a file of the same name.''  Humans do not usually need
71 to make the distinction explicit.  When dealing with a computer program,
72 however, it is good to keep the distinction in mind.
74 @menu
75 * Visiting Functions::         The usual interface functions for visiting.
76 * Subroutines of Visiting::    Lower-level subroutines that they use.
77 @end menu
79 @node Visiting Functions
80 @subsection Functions for Visiting Files
82   This section describes the functions normally used to visit files.
83 For historical reasons, these functions have names starting with
84 @samp{find-} rather than @samp{visit-}.  @xref{Buffer File Name}, for
85 functions and variables that access the visited file name of a buffer or
86 that find an existing buffer by its visited file name.
88   In a Lisp program, if you want to look at the contents of a file but
89 not alter it, the fastest way is to use @code{insert-file-contents} in a
90 temporary buffer.  Visiting the file is not necessary and takes longer.
91 @xref{Reading from Files}.
93 @deffn Command find-file filename &optional wildcards
94 This command selects a buffer visiting the file @var{filename},
95 using an existing buffer if there is one, and otherwise creating a 
96 new buffer and reading the file into it.  It also returns that buffer.
98 The body of the @code{find-file} function is very simple and looks
99 like this:
101 @example
102 (switch-to-buffer (find-file-noselect filename))
103 @end example
105 @noindent
106 (See @code{switch-to-buffer} in @ref{Displaying Buffers}.)
108 If @var{wildcards} is non-@code{nil}, which is always true in an
109 interactive call, then @code{find-file} expands wildcard characters in
110 @var{filename} and visits all the matching files.
112 When @code{find-file} is called interactively, it prompts for
113 @var{filename} in the minibuffer.
114 @end deffn
116 @defun find-file-noselect filename &optional nowarn rawfile wildcards
117 This function is the guts of all the file-visiting functions.  It finds
118 or creates a buffer visiting the file @var{filename}, and returns it.
119 It uses an existing buffer if there is one, and otherwise creates a new
120 buffer and reads the file into it.  You may make the buffer current or
121 display it in a window if you wish, but this function does not do so.
123 If @var{wildcards} is non-@code{nil},
124 then @code{find-file-noselect} expands wildcard
125 characters in @var{filename} and visits all the matching files.
127 When @code{find-file-noselect} uses an existing buffer, it first
128 verifies that the file has not changed since it was last visited or
129 saved in that buffer.  If the file has changed, then this function asks
130 the user whether to reread the changed file.  If the user says
131 @samp{yes}, any changes previously made in the buffer are lost.
133 This function displays warning or advisory messages in various peculiar
134 cases, unless the optional argument @var{nowarn} is non-@code{nil}.  For
135 example, if it needs to create a buffer, and there is no file named
136 @var{filename}, it displays the message @samp{(New file)} in the echo
137 area, and leaves the buffer empty.
139 The @code{find-file-noselect} function normally calls
140 @code{after-find-file} after reading the file (@pxref{Subroutines of
141 Visiting}).  That function sets the buffer major mode, parses local
142 variables, warns the user if there exists an auto-save file more recent
143 than the file just visited, and finishes by running the functions in
144 @code{find-file-hooks}.
146 If the optional argument @var{rawfile} is non-@code{nil}, then
147 @code{after-find-file} is not called, and the
148 @code{find-file-not-found-hooks} are not run in case of failure.  What's
149 more, a non-@code{nil} @var{rawfile} value suppresses coding system
150 conversion (@pxref{Coding Systems}) and format conversion (@pxref{Format
151 Conversion}).
153 The @code{find-file-noselect} function usually returns the buffer that
154 is visiting the file @var{filename}.  But, if wildcards are actually
155 used and expanded, it returns a list of buffers that are visiting the
156 various files.
158 @example
159 @group
160 (find-file-noselect "/etc/fstab")
161      @result{} #<buffer fstab>
162 @end group
163 @end example
164 @end defun
166 @deffn Command find-file-other-window filename &optional wildcards
167 This command selects a buffer visiting the file @var{filename}, but
168 does so in a window other than the selected window.  It may use another
169 existing window or split a window; see @ref{Displaying Buffers}.
171 When this command is called interactively, it prompts for
172 @var{filename}.
173 @end deffn
175 @deffn Command find-file-read-only filename &optional wildcards
176 This command selects a buffer visiting the file @var{filename}, like
177 @code{find-file}, but it marks the buffer as read-only.  @xref{Read Only
178 Buffers}, for related functions and variables.
180 When this command is called interactively, it prompts for
181 @var{filename}.
182 @end deffn
184 @deffn Command view-file filename
185 This command visits @var{filename} using View mode, returning to the
186 previous buffer when you exit View mode.  View mode is a minor mode that
187 provides commands to skim rapidly through the file, but does not let you
188 modify the text.  Entering View mode runs the normal hook
189 @code{view-mode-hook}.  @xref{Hooks}.
191 When @code{view-file} is called interactively, it prompts for
192 @var{filename}.
193 @end deffn
195 @tindex find-file-wildcards
196 @defvar find-file-wildcards
197 If this variable is non-@code{nil}, then the various @code{find-file}
198 commands check for wildcard characters and visit all the files that
199 match them.  If this is @code{nil}, then wildcard characters are
200 not treated specially.
201 @end defvar
203 @defvar find-file-hooks
204 The value of this variable is a list of functions to be called after a
205 file is visited.  The file's local-variables specification (if any) will
206 have been processed before the hooks are run.  The buffer visiting the
207 file is current when the hook functions are run.
209 This variable works just like a normal hook, but we think that renaming
210 it would not be advisable.  @xref{Hooks}.
211 @end defvar
213 @defvar find-file-not-found-hooks
214 The value of this variable is a list of functions to be called when
215 @code{find-file} or @code{find-file-noselect} is passed a nonexistent
216 file name.  @code{find-file-noselect} calls these functions as soon as
217 it detects a nonexistent file.  It calls them in the order of the list,
218 until one of them returns non-@code{nil}.  @code{buffer-file-name} is
219 already set up.
221 This is not a normal hook because the values of the functions are
222 used, and in many cases only some of the functions are called.
223 @end defvar
225 @node Subroutines of Visiting
226 @comment  node-name,  next,  previous,  up
227 @subsection Subroutines of Visiting
229   The @code{find-file-noselect} function uses two important subroutines
230 which are sometimes useful in user Lisp code: @code{create-file-buffer}
231 and @code{after-find-file}.  This section explains how to use them.
233 @defun create-file-buffer filename
234 This function creates a suitably named buffer for visiting
235 @var{filename}, and returns it.  It uses @var{filename} (sans directory)
236 as the name if that name is free; otherwise, it appends a string such as
237 @samp{<2>} to get an unused name.  See also @ref{Creating Buffers}.
239 @strong{Please note:} @code{create-file-buffer} does @emph{not}
240 associate the new buffer with a file and does not select the buffer.
241 It also does not use the default major mode.
243 @example
244 @group
245 (create-file-buffer "foo")
246      @result{} #<buffer foo>
247 @end group
248 @group
249 (create-file-buffer "foo")
250      @result{} #<buffer foo<2>>
251 @end group
252 @group
253 (create-file-buffer "foo")
254      @result{} #<buffer foo<3>>
255 @end group
256 @end example
258 This function is used by @code{find-file-noselect}.
259 It uses @code{generate-new-buffer} (@pxref{Creating Buffers}).
260 @end defun
262 @defun after-find-file &optional error warn noauto after-find-file-from-revert-buffer nomodes
263 This function sets the buffer major mode, and parses local variables
264 (@pxref{Auto Major Mode}).  It is called by @code{find-file-noselect}
265 and by the default revert function (@pxref{Reverting}).
267 @cindex new file message
268 @cindex file open error
269 If reading the file got an error because the file does not exist, but
270 its directory does exist, the caller should pass a non-@code{nil} value
271 for @var{error}.  In that case, @code{after-find-file} issues a warning:
272 @samp{(New file)}.  For more serious errors, the caller should usually not
273 call @code{after-find-file}.
275 If @var{warn} is non-@code{nil}, then this function issues a warning
276 if an auto-save file exists and is more recent than the visited file.
278 If @var{noauto} is non-@code{nil}, that says not to enable or disable
279 Auto-Save mode.  The mode remains enabled if it was enabled before.
281 If @var{after-find-file-from-revert-buffer} is non-@code{nil}, that
282 means this call was from @code{revert-buffer}.  This has no direct
283 effect, but some mode functions and hook functions check the value
284 of this variable.
286 If @var{nomodes} is non-@code{nil}, that means don't alter the buffer's
287 major mode, don't process local variables specifications in the file,
288 and don't run @code{find-file-hooks}.  This feature is used by
289 @code{revert-buffer} in some cases.
291 The last thing @code{after-find-file} does is call all the functions
292 in the list @code{find-file-hooks}.
293 @end defun
295 @node Saving Buffers
296 @section Saving Buffers
298   When you edit a file in Emacs, you are actually working on a buffer
299 that is visiting that file---that is, the contents of the file are
300 copied into the buffer and the copy is what you edit.  Changes to the
301 buffer do not change the file until you @dfn{save} the buffer, which
302 means copying the contents of the buffer into the file.
304 @deffn Command save-buffer &optional backup-option
305 This function saves the contents of the current buffer in its visited
306 file if the buffer has been modified since it was last visited or saved.
307 Otherwise it does nothing.
309 @code{save-buffer} is responsible for making backup files.  Normally,
310 @var{backup-option} is @code{nil}, and @code{save-buffer} makes a backup
311 file only if this is the first save since visiting the file.  Other
312 values for @var{backup-option} request the making of backup files in
313 other circumstances:
315 @itemize @bullet
316 @item
317 With an argument of 4 or 64, reflecting 1 or 3 @kbd{C-u}'s, the
318 @code{save-buffer} function marks this version of the file to be
319 backed up when the buffer is next saved.
321 @item
322 With an argument of 16 or 64, reflecting 2 or 3 @kbd{C-u}'s, the
323 @code{save-buffer} function unconditionally backs up the previous
324 version of the file before saving it.
325 @end itemize
326 @end deffn
328 @deffn Command save-some-buffers &optional save-silently-p pred
329 This command saves some modified file-visiting buffers.  Normally it
330 asks the user about each buffer.  But if @var{save-silently-p} is
331 non-@code{nil}, it saves all the file-visiting buffers without querying
332 the user.
334 The optional @var{pred} argument controls which buffers to ask about.
335 If it is @code{nil}, that means to ask only about file-visiting buffers.
336 If it is @code{t}, that means also offer to save certain other non-file
337 buffers---those that have a non-@code{nil} buffer-local value of
338 @code{buffer-offer-save}.  (A user who says @samp{yes} to saving a
339 non-file buffer is asked to specify the file name to use.)  The
340 @code{save-buffers-kill-emacs} function passes the value @code{t} for
341 @var{pred}.
343 If @var{pred} is neither @code{t} nor @code{nil}, then it should be
344 a function of no arguments.  It will be called in each buffer to decide
345 whether to offer to save that buffer.  If it returns a non-@code{nil}
346 value in a certain buffer, that means do offer to save that buffer.
347 @end deffn
349 @deffn Command write-file filename &optional confirm
350 This function writes the current buffer into file @var{filename}, makes
351 the buffer visit that file, and marks it not modified.  Then it renames
352 the buffer based on @var{filename}, appending a string like @samp{<2>}
353 if necessary to make a unique buffer name.  It does most of this work by
354 calling @code{set-visited-file-name} (@pxref{Buffer File Name}) and
355 @code{save-buffer}.
357 If @var{confirm} is non-@code{nil}, that means to ask for confirmation
358 before overwriting an existing file.
359 @end deffn
361   Saving a buffer runs several hooks.  It also performs format
362 conversion (@pxref{Format Conversion}), and may save text properties in
363 ``annotations'' (@pxref{Saving Properties}).
365 @defvar write-file-hooks
366 The value of this variable is a list of functions to be called before
367 writing out a buffer to its visited file.  If one of them returns
368 non-@code{nil}, the file is considered already written and the rest of
369 the functions are not called, nor is the usual code for writing the file
370 executed.
372 If a function in @code{write-file-hooks} returns non-@code{nil}, it
373 is responsible for making a backup file (if that is appropriate).
374 To do so, execute the following code:
376 @example
377 (or buffer-backed-up (backup-buffer))
378 @end example
380 You might wish to save the file modes value returned by
381 @code{backup-buffer} and use that to set the mode bits of the file that
382 you write.  This is what @code{save-buffer} normally does.
384 The hook functions in @code{write-file-hooks} are also responsible for
385 encoding the data (if desired): they must choose a suitable coding
386 system (@pxref{Lisp and Coding Systems}), perform the encoding
387 (@pxref{Explicit Encoding}), and set @code{last-coding-system-used} to
388 the coding system that was used (@pxref{Encoding and I/O}).
390 Do not make this variable buffer-local.  To set up buffer-specific hook
391 functions, use @code{write-contents-hooks} instead.
393 Even though this is not a normal hook, you can use @code{add-hook} and
394 @code{remove-hook} to manipulate the list.  @xref{Hooks}.
395 @end defvar
397 @c Emacs 19 feature
398 @defvar local-write-file-hooks
399 This works just like @code{write-file-hooks}, but it is intended to be
400 made buffer-local in particular buffers, and used for hooks that pertain
401 to the file name or the way the buffer contents were obtained.
403 The variable is marked as a permanent local, so that changing the major
404 mode does not alter a buffer-local value.  This is convenient for
405 packages that read ``file'' contents in special ways, and set up hooks
406 to save the data in a corresponding way.
407 @end defvar
409 @c Emacs 19 feature
410 @defvar write-contents-hooks
411 This works just like @code{write-file-hooks}, but it is intended for
412 hooks that pertain to the contents of the file, as opposed to hooks that
413 pertain to where the file came from.  Such hooks are usually set up by
414 major modes, as buffer-local bindings for this variable.
416 This variable automatically becomes buffer-local whenever it is set;
417 switching to a new major mode always resets this variable.  When you use
418 @code{add-hooks} to add an element to this hook, you should @emph{not}
419 specify a non-@code{nil} @var{local} argument, since this variable is
420 used @emph{only} buffer-locally.
421 @end defvar
423 @c Emacs 19 feature
424 @defvar after-save-hook
425 This normal hook runs after a buffer has been saved in its visited file.
426 One use of this hook is in Fast Lock mode; it uses this hook to save the
427 highlighting information in a cache file.
428 @end defvar
430 @defvar file-precious-flag
431 If this variable is non-@code{nil}, then @code{save-buffer} protects
432 against I/O errors while saving by writing the new file to a temporary
433 name instead of the name it is supposed to have, and then renaming it to
434 the intended name after it is clear there are no errors.  This procedure
435 prevents problems such as a lack of disk space from resulting in an
436 invalid file.
438 As a side effect, backups are necessarily made by copying.  @xref{Rename
439 or Copy}.  Yet, at the same time, saving a precious file always breaks
440 all hard links between the file you save and other file names.
442 Some modes give this variable a non-@code{nil} buffer-local value
443 in particular buffers.
444 @end defvar
446 @defopt require-final-newline
447 This variable determines whether files may be written out that do
448 @emph{not} end with a newline.  If the value of the variable is
449 @code{t}, then @code{save-buffer} silently adds a newline at the end of
450 the file whenever the buffer being saved does not already end in one.
451 If the value of the variable is non-@code{nil}, but not @code{t}, then
452 @code{save-buffer} asks the user whether to add a newline each time the
453 case arises.
455 If the value of the variable is @code{nil}, then @code{save-buffer}
456 doesn't add newlines at all.  @code{nil} is the default value, but a few
457 major modes set it to @code{t} in particular buffers.
458 @end defopt
460   See also the function @code{set-visited-file-name} (@pxref{Buffer File
461 Name}).
463 @node Reading from Files
464 @comment  node-name,  next,  previous,  up
465 @section Reading from Files
467   You can copy a file from the disk and insert it into a buffer
468 using the @code{insert-file-contents} function.  Don't use the user-level
469 command @code{insert-file} in a Lisp program, as that sets the mark.
471 @defun insert-file-contents filename &optional visit beg end replace
472 This function inserts the contents of file @var{filename} into the
473 current buffer after point.  It returns a list of the absolute file name
474 and the length of the data inserted.  An error is signaled if
475 @var{filename} is not the name of a file that can be read.
477 The function @code{insert-file-contents} checks the file contents
478 against the defined file formats, and converts the file contents if
479 appropriate.  @xref{Format Conversion}.  It also calls the functions in
480 the list @code{after-insert-file-functions}; see @ref{Saving
481 Properties}.  Normally, one of the functions in the
482 @code{after-insert-file-functions} list determines the coding system
483 (@pxref{Coding Systems}) used for decoding the file's contents.
485 If @var{visit} is non-@code{nil}, this function additionally marks the
486 buffer as unmodified and sets up various fields in the buffer so that it
487 is visiting the file @var{filename}: these include the buffer's visited
488 file name and its last save file modtime.  This feature is used by
489 @code{find-file-noselect} and you probably should not use it yourself.
491 If @var{beg} and @var{end} are non-@code{nil}, they should be integers
492 specifying the portion of the file to insert.  In this case, @var{visit}
493 must be @code{nil}.  For example,
495 @example
496 (insert-file-contents filename nil 0 500)
497 @end example
499 @noindent
500 inserts the first 500 characters of a file.
502 If the argument @var{replace} is non-@code{nil}, it means to replace the
503 contents of the buffer (actually, just the accessible portion) with the
504 contents of the file.  This is better than simply deleting the buffer
505 contents and inserting the whole file, because (1) it preserves some
506 marker positions and (2) it puts less data in the undo list.
508 It is possible to read a special file (such as a FIFO or an I/O device)
509 with @code{insert-file-contents}, as long as @var{replace} and
510 @var{visit} are @code{nil}.
511 @end defun
513 @defun insert-file-contents-literally filename &optional visit beg end replace
514 This function works like @code{insert-file-contents} except that it does
515 not do format decoding (@pxref{Format Conversion}), does not do
516 character code conversion (@pxref{Coding Systems}), does not run
517 @code{find-file-hooks}, does not perform automatic uncompression, and so
519 @end defun
521 If you want to pass a file name to another process so that another
522 program can read the file, use the function @code{file-local-copy}; see
523 @ref{Magic File Names}.
525 @node Writing to Files
526 @comment  node-name,  next,  previous,  up
527 @section Writing to Files
529   You can write the contents of a buffer, or part of a buffer, directly
530 to a file on disk using the @code{append-to-file} and
531 @code{write-region} functions.  Don't use these functions to write to
532 files that are being visited; that could cause confusion in the
533 mechanisms for visiting.
535 @deffn Command append-to-file start end filename
536 This function appends the contents of the region delimited by
537 @var{start} and @var{end} in the current buffer to the end of file
538 @var{filename}.  If that file does not exist, it is created.  This
539 function returns @code{nil}.
541 An error is signaled if @var{filename} specifies a nonwritable file,
542 or a nonexistent file in a directory where files cannot be created.
543 @end deffn
545 @deffn Command write-region start end filename &optional append visit lockname mustbenew
546 This function writes the region delimited by @var{start} and @var{end}
547 in the current buffer into the file specified by @var{filename}.
549 @c Emacs 19 feature
550 If @var{start} is a string, then @code{write-region} writes or appends
551 that string, rather than text from the buffer.  @var{end} is ignored in
552 this case.
554 If @var{append} is non-@code{nil}, then the specified text is appended
555 to the existing file contents (if any).  Starting in Emacs 21, if
556 @var{append} is an integer, then @code{write-region} seeks to that byte
557 offset from the start of the file and writes the data from there.
559 If @var{mustbenew} is non-@code{nil}, then @code{write-region} asks
560 for confirmation if @var{filename} names an existing file.
561 Starting in Emacs 21, if @var{mustbenew} is the symbol @code{excl}, 
562 then @code{write-region} does not ask for confirmation, but instead
563 it signals an error @code{file-already-exists} if the file already
564 exists.
566 The test for an existing file, when @var{mustbenew} is @code{excl}, uses
567 a special system feature.  At least for files on a local disk, there is
568 no chance that some other program could create a file of the same name
569 before Emacs does, without Emacs's noticing.
571 If @var{visit} is @code{t}, then Emacs establishes an association
572 between the buffer and the file: the buffer is then visiting that file.
573 It also sets the last file modification time for the current buffer to
574 @var{filename}'s modtime, and marks the buffer as not modified.  This
575 feature is used by @code{save-buffer}, but you probably should not use
576 it yourself.
578 @c Emacs 19 feature
579 If @var{visit} is a string, it specifies the file name to visit.  This
580 way, you can write the data to one file (@var{filename}) while recording
581 the buffer as visiting another file (@var{visit}).  The argument
582 @var{visit} is used in the echo area message and also for file locking;
583 @var{visit} is stored in @code{buffer-file-name}.  This feature is used
584 to implement @code{file-precious-flag}; don't use it yourself unless you
585 really know what you're doing.
587 The optional argument @var{lockname}, if non-@code{nil}, specifies the
588 file name to use for purposes of locking and unlocking, overriding
589 @var{filename} and @var{visit} for that purpose.
591 The function @code{write-region} converts the data which it writes to
592 the appropriate file formats specified by @code{buffer-file-format}.
593 @xref{Format Conversion}.  It also calls the functions in the list
594 @code{write-region-annotate-functions}; see @ref{Saving Properties}.
596 Normally, @code{write-region} displays the message @samp{Wrote
597 @var{filename}} in the echo area.  If @var{visit} is neither @code{t}
598 nor @code{nil} nor a string, then this message is inhibited.  This
599 feature is useful for programs that use files for internal purposes,
600 files that the user does not need to know about.
601 @end deffn
603 @defmac with-temp-file file body...
604 The @code{with-temp-file} macro evaluates the @var{body} forms with a
605 temporary buffer as the current buffer; then, at the end, it writes the
606 buffer contents into file @var{file}.  It kills the temporary buffer
607 when finished, restoring the buffer that was current before the
608 @code{with-temp-file} form.  Then it returns the value of the last form
609 in @var{body}.
611 The current buffer is restored even in case of an abnormal exit via
612 @code{throw} or error (@pxref{Nonlocal Exits}).
614 See also @code{with-temp-buffer} in @ref{Current Buffer}.
615 @end defmac
617 @node File Locks
618 @section File Locks
619 @cindex file locks
621   When two users edit the same file at the same time, they are likely to
622 interfere with each other.  Emacs tries to prevent this situation from
623 arising by recording a @dfn{file lock} when a file is being modified.
624 Emacs can then detect the first attempt to modify a buffer visiting a
625 file that is locked by another Emacs job, and ask the user what to do.
626 The file lock is really a file, a symbolic link with a special name,
627 stored in the same directory as the file you are editing.
629   When you access files using NFS, there may be a small probability that
630 you and another user will both lock the same file ``simultaneously''.
631 If this happens, it is possible for the two users to make changes
632 simultaneously, but Emacs will still warn the user who saves second.
633 Also, the detection of modification of a buffer visiting a file changed
634 on disk catches some cases of simultaneous editing; see
635 @ref{Modification Time}.
637 @defun file-locked-p filename
638 This function returns @code{nil} if the file @var{filename} is not
639 locked.  It returns @code{t} if it is locked by this Emacs process, and
640 it returns the name of the user who has locked it if it is locked by
641 some other job.
643 @example
644 @group
645 (file-locked-p "foo")
646      @result{} nil
647 @end group
648 @end example
649 @end defun
651 @defun lock-buffer &optional filename
652 This function locks the file @var{filename}, if the current buffer is
653 modified.  The argument @var{filename} defaults to the current buffer's
654 visited file.  Nothing is done if the current buffer is not visiting a
655 file, or is not modified.
656 @end defun
658 @defun unlock-buffer
659 This function unlocks the file being visited in the current buffer,
660 if the buffer is modified.  If the buffer is not modified, then
661 the file should not be locked, so this function does nothing.  It also
662 does nothing if the current buffer is not visiting a file.
663 @end defun
665   File locking is not supported on some systems.  On systems that do not
666 support it, the functions @code{lock-buffer}, @code{unlock-buffer} and
667 @code{file-locked-p} do nothing and return @code{nil}.
669 @defun ask-user-about-lock file other-user
670 This function is called when the user tries to modify @var{file}, but it
671 is locked by another user named @var{other-user}.  The default
672 definition of this function asks the user to say what to do.  The value
673 this function returns determines what Emacs does next:
675 @itemize @bullet
676 @item
677 A value of @code{t} says to grab the lock on the file.  Then
678 this user may edit the file and @var{other-user} loses the lock.
680 @item
681 A value of @code{nil} says to ignore the lock and let this
682 user edit the file anyway.
684 @item
685 @kindex file-locked
686 This function may instead signal a @code{file-locked} error, in which
687 case the change that the user was about to make does not take place.
689 The error message for this error looks like this:
691 @example
692 @error{} File is locked: @var{file} @var{other-user}
693 @end example
695 @noindent
696 where @code{file} is the name of the file and @var{other-user} is the
697 name of the user who has locked the file.
698 @end itemize
700 If you wish, you can replace the @code{ask-user-about-lock} function
701 with your own version that makes the decision in another way.  The code
702 for its usual definition is in @file{userlock.el}.
703 @end defun
705 @node Information about Files
706 @section Information about Files
708   The functions described in this section all operate on strings that
709 designate file names.  All the functions have names that begin with the
710 word @samp{file}.  These functions all return information about actual
711 files or directories, so their arguments must all exist as actual files
712 or directories unless otherwise noted.
714 @menu
715 * Testing Accessibility::   Is a given file readable?  Writable?
716 * Kinds of Files::          Is it a directory?  A symbolic link?
717 * Truenames::               Eliminating symbolic links from a file name.
718 * File Attributes::         How large is it?  Any other names?  Etc.
719 @end menu
721 @node Testing Accessibility
722 @comment  node-name,  next,  previous,  up
723 @subsection Testing Accessibility
724 @cindex accessibility of a file
725 @cindex file accessibility
727   These functions test for permission to access a file in specific ways.
729 @defun file-exists-p filename
730 This function returns @code{t} if a file named @var{filename} appears to
731 exist.  This does not mean you can necessarily read the file, only that
732 you can find out its attributes.  (On Unix and GNU/Linux, this is true
733 if the file exists and you have execute permission on the containing
734 directories, regardless of the protection of the file itself.)
736 If the file does not exist, or if fascist access control policies
737 prevent you from finding the attributes of the file, this function
738 returns @code{nil}.
739 @end defun
741 @defun file-readable-p filename
742 This function returns @code{t} if a file named @var{filename} exists
743 and you can read it.  It returns @code{nil} otherwise.
745 @example
746 @group
747 (file-readable-p "files.texi")
748      @result{} t
749 @end group
750 @group
751 (file-exists-p "/usr/spool/mqueue")
752      @result{} t
753 @end group
754 @group
755 (file-readable-p "/usr/spool/mqueue")
756      @result{} nil
757 @end group
758 @end example
759 @end defun
761 @c Emacs 19 feature
762 @defun file-executable-p filename
763 This function returns @code{t} if a file named @var{filename} exists and
764 you can execute it.  It returns @code{nil} otherwise.  On Unix and
765 GNU/Linux, if the file is a directory, execute permission means you can
766 check the existence and attributes of files inside the directory, and
767 open those files if their modes permit.
768 @end defun
770 @defun file-writable-p filename
771 This function returns @code{t} if the file @var{filename} can be written
772 or created by you, and @code{nil} otherwise.  A file is writable if the
773 file exists and you can write it.  It is creatable if it does not exist,
774 but the specified directory does exist and you can write in that
775 directory.
777 In the third example below, @file{foo} is not writable because the
778 parent directory does not exist, even though the user could create such
779 a directory.
781 @example
782 @group
783 (file-writable-p "~/foo")
784      @result{} t
785 @end group
786 @group
787 (file-writable-p "/foo")
788      @result{} nil
789 @end group
790 @group
791 (file-writable-p "~/no-such-dir/foo")
792      @result{} nil
793 @end group
794 @end example
795 @end defun
797 @c Emacs 19 feature
798 @defun file-accessible-directory-p dirname
799 This function returns @code{t} if you have permission to open existing
800 files in the directory whose name as a file is @var{dirname}; otherwise
801 (or if there is no such directory), it returns @code{nil}.  The value
802 of @var{dirname} may be either a directory name or the file name of a
803 file which is a directory.
805 Example: after the following,
807 @example
808 (file-accessible-directory-p "/foo")
809      @result{} nil
810 @end example
812 @noindent
813 we can deduce that any attempt to read a file in @file{/foo/} will
814 give an error.
815 @end defun
817 @defun access-file filename string
818 This function opens file @var{filename} for reading, then closes it and
819 returns @code{nil}.  However, if the open fails, it signals an error
820 using @var{string} as the error message text.
821 @end defun
823 @defun file-ownership-preserved-p filename
824 This function returns @code{t} if deleting the file @var{filename} and
825 then creating it anew would keep the file's owner unchanged.
826 @end defun
828 @defun file-newer-than-file-p filename1 filename2
829 @cindex file age
830 @cindex file modification time
831 This function returns @code{t} if the file @var{filename1} is
832 newer than file @var{filename2}.  If @var{filename1} does not
833 exist, it returns @code{nil}.  If @var{filename2} does not exist,
834 it returns @code{t}.
836 In the following example, assume that the file @file{aug-19} was written
837 on the 19th, @file{aug-20} was written on the 20th, and the file
838 @file{no-file} doesn't exist at all.
840 @example
841 @group
842 (file-newer-than-file-p "aug-19" "aug-20")
843      @result{} nil
844 @end group
845 @group
846 (file-newer-than-file-p "aug-20" "aug-19")
847      @result{} t
848 @end group
849 @group
850 (file-newer-than-file-p "aug-19" "no-file")
851      @result{} t
852 @end group
853 @group
854 (file-newer-than-file-p "no-file" "aug-19")
855      @result{} nil
856 @end group
857 @end example
859 You can use @code{file-attributes} to get a file's last modification
860 time as a list of two numbers.  @xref{File Attributes}.
861 @end defun
863 @node Kinds of Files
864 @comment  node-name,  next,  previous,  up
865 @subsection Distinguishing Kinds of Files
867   This section describes how to distinguish various kinds of files, such
868 as directories, symbolic links, and ordinary files.
870 @defun file-symlink-p filename
871 @cindex file symbolic links
872 If the file @var{filename} is a symbolic link, the @code{file-symlink-p}
873 function returns the file name to which it is linked.  This may be the
874 name of a text file, a directory, or even another symbolic link, or it
875 may be a nonexistent file name.
877 If the file @var{filename} is not a symbolic link (or there is no such file),
878 @code{file-symlink-p} returns @code{nil}.  
880 @example
881 @group
882 (file-symlink-p "foo")
883      @result{} nil
884 @end group
885 @group
886 (file-symlink-p "sym-link")
887      @result{} "foo"
888 @end group
889 @group
890 (file-symlink-p "sym-link2")
891      @result{} "sym-link"
892 @end group
893 @group
894 (file-symlink-p "/bin")
895      @result{} "/pub/bin"
896 @end group
897 @end example
899 @c !!! file-symlink-p: should show output of ls -l for comparison
900 @end defun
902 @defun file-directory-p filename
903 This function returns @code{t} if @var{filename} is the name of an
904 existing directory, @code{nil} otherwise.
906 @example
907 @group
908 (file-directory-p "~rms")
909      @result{} t
910 @end group
911 @group
912 (file-directory-p "~rms/lewis/files.texi")
913      @result{} nil
914 @end group
915 @group
916 (file-directory-p "~rms/lewis/no-such-file")
917      @result{} nil
918 @end group
919 @group
920 (file-directory-p "$HOME")
921      @result{} nil
922 @end group
923 @group
924 (file-directory-p
925  (substitute-in-file-name "$HOME"))
926      @result{} t
927 @end group
928 @end example
929 @end defun
931 @defun file-regular-p filename
932 This function returns @code{t} if the file @var{filename} exists and is
933 a regular file (not a directory, named pipe, terminal, or
934 other I/O device).
935 @end defun
937 @node Truenames
938 @subsection Truenames
939 @cindex truename (of file)
941 @c Emacs 19 features
942   The @dfn{truename} of a file is the name that you get by following
943 symbolic links at all levels until none remain, then simplifying away
944 @samp{.}@: and @samp{..}@: appearing as name components.  This results
945 in a sort of canonical name for the file.  A file does not always have a
946 unique truename; the number of distinct truenames a file has is equal to
947 the number of hard links to the file.  However, truenames are useful
948 because they eliminate symbolic links as a cause of name variation.
950 @defun file-truename filename
951 The function @code{file-truename} returns the truename of the file
952 @var{filename}.  The argument must be an absolute file name.
953 @end defun
955 @defun file-chase-links filename
956 This function follows symbolic links, starting with @var{filename},
957 until it finds a file name which is not the name of a symbolic link.
958 Then it returns that file name.
959 @end defun
961   To illustrate the difference between @code{file-chase-links} and
962 @code{file-truename}, suppose that @file{/usr/foo} is a symbolic link to
963 the directory @file{/home/foo}, and @file{/home/foo/hello} is an
964 ordinary file (or at least, not a symbolic link) or nonexistent.  Then
965 we would have:
967 @example
968 (file-chase-links "/usr/foo/hello")
969      ;; @r{This does not follow the links in the parent directories.}
970      @result{} "/usr/foo/hello"
971 (file-truename "/usr/foo/hello")
972      ;; @r{Assuming that @file{/home} is not a symbolic link.}
973      @result{} "/home/foo/hello"
974 @end example
976   @xref{Buffer File Name}, for related information.
978 @node File Attributes
979 @comment  node-name,  next,  previous,  up
980 @subsection Other Information about Files
982   This section describes the functions for getting detailed information
983 about a file, other than its contents.  This information includes the
984 mode bits that control access permission, the owner and group numbers,
985 the number of names, the inode number, the size, and the times of access
986 and modification.
988 @defun file-modes filename
989 @cindex permission
990 @cindex file attributes
991 This function returns the mode bits of @var{filename}, as an integer.
992 The mode bits are also called the file permissions, and they specify
993 access control in the usual Unix fashion.  If the low-order bit is 1,
994 then the file is executable by all users, if the second-lowest-order bit
995 is 1, then the file is writable by all users, etc.
997 The highest value returnable is 4095 (7777 octal), meaning that
998 everyone has read, write, and execute permission, that the @sc{suid} bit
999 is set for both others and group, and that the sticky bit is set.
1001 @example
1002 @group
1003 (file-modes "~/junk/diffs")
1004      @result{} 492               ; @r{Decimal integer.}
1005 @end group
1006 @group
1007 (format "%o" 492)
1008      @result{} "754"             ; @r{Convert to octal.}
1009 @end group
1011 @group
1012 (set-file-modes "~/junk/diffs" 438)
1013      @result{} nil
1014 @end group
1016 @group
1017 (format "%o" 438)
1018      @result{} "666"             ; @r{Convert to octal.}
1019 @end group
1021 @group
1022 % ls -l diffs
1023   -rw-rw-rw-  1 lewis 0 3063 Oct 30 16:00 diffs
1024 @end group
1025 @end example
1026 @end defun
1028 @defun file-nlinks filename
1029 This functions returns the number of names (i.e., hard links) that
1030 file @var{filename} has.  If the file does not exist, then this function
1031 returns @code{nil}.  Note that symbolic links have no effect on this
1032 function, because they are not considered to be names of the files they
1033 link to.
1035 @example
1036 @group
1037 % ls -l foo*
1038 -rw-rw-rw-  2 rms       4 Aug 19 01:27 foo
1039 -rw-rw-rw-  2 rms       4 Aug 19 01:27 foo1
1040 @end group
1042 @group
1043 (file-nlinks "foo")
1044      @result{} 2
1045 @end group
1046 @group
1047 (file-nlinks "doesnt-exist")
1048      @result{} nil
1049 @end group
1050 @end example
1051 @end defun
1053 @defun file-attributes filename
1054 This function returns a list of attributes of file @var{filename}.  If
1055 the specified file cannot be opened, it returns @code{nil}.
1057 The elements of the list, in order, are:
1059 @enumerate 0
1060 @item
1061 @code{t} for a directory, a string for a symbolic link (the name
1062 linked to), or @code{nil} for a text file.
1064 @c Wordy so as to prevent an overfull hbox.  --rjc 15mar92
1065 @item
1066 The number of names the file has.  Alternate names, also known as hard
1067 links, can be created by using the @code{add-name-to-file} function
1068 (@pxref{Changing Files}).
1070 @item
1071 The file's @sc{uid}.
1073 @item
1074 The file's @sc{gid}.
1076 @item
1077 The time of last access, as a list of two integers.
1078 The first integer has the high-order 16 bits of time,
1079 the second has the low 16 bits.  (This is similar to the
1080 value of @code{current-time}; see @ref{Time of Day}.)
1082 @item
1083 The time of last modification as a list of two integers (as above).
1085 @item
1086 The time of last status change as a list of two integers (as above).
1088 @item
1089 The size of the file in bytes.  If the size is too large to fit in a
1090 Lisp integer, this is a floating point number.
1092 @item
1093 The file's modes, as a string of ten letters or dashes,
1094 as in @samp{ls -l}.
1096 @item
1097 @code{t} if the file's @sc{gid} would change if file were
1098 deleted and recreated; @code{nil} otherwise.
1100 @item
1101 The file's inode number.  If possible, this is an integer.  If the inode
1102 number is too large to be represented as an integer in Emacs Lisp, then
1103 the value has the form @code{(@var{high} . @var{low})}, where @var{low}
1104 holds the low 16 bits.
1106 @item
1107 The file system number of the file system that the file is in.
1108 Depending on the magnitude of the value, this can be either an integer
1109 or a cons cell, in the same manner as the inode number.  This element
1110 and the file's inode number together give enough information to
1111 distinguish any two files on the system---no two files can have the same
1112 values for both of these numbers.
1113 @end enumerate
1115 For example, here are the file attributes for @file{files.texi}:
1117 @example
1118 @group
1119 (file-attributes "files.texi")
1120      @result{}  (nil 1 2235 75 
1121           (8489 20284) 
1122           (8489 20284) 
1123           (8489 20285)
1124           14906 "-rw-rw-rw-" 
1125           nil 129500 -32252)
1126 @end group
1127 @end example
1129 @noindent
1130 and here is how the result is interpreted:
1132 @table @code
1133 @item nil
1134 is neither a directory nor a symbolic link.
1136 @item 1
1137 has only one name (the name @file{files.texi} in the current default
1138 directory).
1140 @item 2235
1141 is owned by the user with @sc{uid} 2235.
1143 @item 75
1144 is in the group with @sc{gid} 75.
1146 @item (8489 20284)
1147 was last accessed on Aug 19 00:09.
1149 @item (8489 20284)
1150 was last modified on Aug 19 00:09.
1152 @item (8489 20285)
1153 last had its inode changed on Aug 19 00:09.
1155 @item 14906
1156 is 14906 bytes long.  (It may not contain 14906 characters, though,
1157 if some of the bytes belong to multibyte sequences.)
1159 @item "-rw-rw-rw-"
1160 has a mode of read and write access for the owner, group, and world.
1162 @item nil
1163 would retain the same @sc{gid} if it were recreated.
1165 @item 129500
1166 has an inode number of 129500.
1167 @item -32252
1168 is on file system number -32252.
1169 @end table
1170 @end defun
1172 @node Changing Files
1173 @section Changing File Names and Attributes
1174 @cindex renaming files
1175 @cindex copying files
1176 @cindex deleting files
1177 @cindex linking files
1178 @cindex setting modes of files
1180   The functions in this section rename, copy, delete, link, and set the
1181 modes of files.
1183   In the functions that have an argument @var{newname}, if a file by the
1184 name of @var{newname} already exists, the actions taken depend on the
1185 value of the argument @var{ok-if-already-exists}:
1187 @itemize @bullet
1188 @item
1189 Signal a @code{file-already-exists} error if
1190 @var{ok-if-already-exists} is @code{nil}.
1192 @item
1193 Request confirmation if @var{ok-if-already-exists} is a number.
1195 @item
1196 Replace the old file without confirmation if @var{ok-if-already-exists}
1197 is any other value.
1198 @end itemize
1200 @defun add-name-to-file oldname newname &optional ok-if-already-exists
1201 @cindex file with multiple names
1202 @cindex file hard link
1203 This function gives the file named @var{oldname} the additional name
1204 @var{newname}.  This means that @var{newname} becomes a new ``hard
1205 link'' to @var{oldname}.
1207 In the first part of the following example, we list two files,
1208 @file{foo} and @file{foo3}.
1210 @example
1211 @group
1212 % ls -li fo*
1213 81908 -rw-rw-rw-  1 rms       29 Aug 18 20:32 foo
1214 84302 -rw-rw-rw-  1 rms       24 Aug 18 20:31 foo3
1215 @end group
1216 @end example
1218 Now we create a hard link, by calling @code{add-name-to-file}, then list
1219 the files again.  This shows two names for one file, @file{foo} and
1220 @file{foo2}.
1222 @example
1223 @group
1224 (add-name-to-file "foo" "foo2")
1225      @result{} nil
1226 @end group
1228 @group
1229 % ls -li fo*
1230 81908 -rw-rw-rw-  2 rms       29 Aug 18 20:32 foo
1231 81908 -rw-rw-rw-  2 rms       29 Aug 18 20:32 foo2
1232 84302 -rw-rw-rw-  1 rms       24 Aug 18 20:31 foo3
1233 @end group
1234 @end example
1236 Finally, we evaluate the following:
1238 @example
1239 (add-name-to-file "foo" "foo3" t)
1240 @end example
1242 @noindent
1243 and list the files again.  Now there are three names
1244 for one file: @file{foo}, @file{foo2}, and @file{foo3}.  The old
1245 contents of @file{foo3} are lost.
1247 @example
1248 @group
1249 (add-name-to-file "foo1" "foo3")
1250      @result{} nil
1251 @end group
1253 @group
1254 % ls -li fo*
1255 81908 -rw-rw-rw-  3 rms       29 Aug 18 20:32 foo
1256 81908 -rw-rw-rw-  3 rms       29 Aug 18 20:32 foo2
1257 81908 -rw-rw-rw-  3 rms       29 Aug 18 20:32 foo3
1258 @end group
1259 @end example
1261 This function is meaningless on operating systems where multiple names
1262 for one file are not allowed.  Some systems implement multiple names
1263 by copying the file instead.
1265 See also @code{file-nlinks} in @ref{File Attributes}.
1266 @end defun
1268 @deffn Command rename-file filename newname &optional ok-if-already-exists
1269 This command renames the file @var{filename} as @var{newname}.
1271 If @var{filename} has additional names aside from @var{filename}, it
1272 continues to have those names.  In fact, adding the name @var{newname}
1273 with @code{add-name-to-file} and then deleting @var{filename} has the
1274 same effect as renaming, aside from momentary intermediate states.
1276 In an interactive call, this function prompts for @var{filename} and
1277 @var{newname} in the minibuffer; also, it requests confirmation if
1278 @var{newname} already exists.
1279 @end deffn
1281 @deffn Command copy-file oldname newname &optional ok-if-exists time
1282 This command copies the file @var{oldname} to @var{newname}.  An
1283 error is signaled if @var{oldname} does not exist.
1285 If @var{time} is non-@code{nil}, then this function gives the new file
1286 the same last-modified time that the old one has.  (This works on only
1287 some operating systems.)  If setting the time gets an error,
1288 @code{copy-file} signals a @code{file-date-error} error.
1290 In an interactive call, this function prompts for @var{filename} and
1291 @var{newname} in the minibuffer; also, it requests confirmation if
1292 @var{newname} already exists.
1293 @end deffn
1295 @deffn Command delete-file filename
1296 @pindex rm
1297 This command deletes the file @var{filename}, like the shell command
1298 @samp{rm @var{filename}}.  If the file has multiple names, it continues
1299 to exist under the other names.
1301 A suitable kind of @code{file-error} error is signaled if the file does
1302 not exist, or is not deletable.  (On Unix and GNU/Linux, a file is
1303 deletable if its directory is writable.)
1305 See also @code{delete-directory} in @ref{Create/Delete Dirs}.
1306 @end deffn
1308 @deffn Command make-symbolic-link filename newname  &optional ok-if-exists
1309 @pindex ln
1310 @kindex file-already-exists
1311 This command makes a symbolic link to @var{filename}, named
1312 @var{newname}.  This is like the shell command @samp{ln -s
1313 @var{filename} @var{newname}}.
1315 In an interactive call, this function prompts for @var{filename} and
1316 @var{newname} in the minibuffer; also, it requests confirmation if
1317 @var{newname} already exists.
1319 This function is not available on systems that don't support symbolic
1320 links.
1321 @end deffn
1323 @defun define-logical-name varname string
1324 This function defines the logical name @var{name} to have the value
1325 @var{string}.  It is available only on VMS.
1326 @end defun
1328 @defun set-file-modes filename mode
1329 This function sets mode bits of @var{filename} to @var{mode} (which must
1330 be an integer).  Only the low 12 bits of @var{mode} are used.
1331 @end defun
1333 @c Emacs 19 feature
1334 @defun set-default-file-modes mode
1335 This function sets the default file protection for new files created by
1336 Emacs and its subprocesses.  Every file created with Emacs initially has
1337 this protection, or a subset of it (@code{write-region} will not give a
1338 file execute permission even if the default file protection allows
1339 execute permission).  On Unix and GNU/Linux, the default protection is
1340 the bitwise complement of the ``umask'' value.
1342 The argument @var{mode} must be an integer.  On most systems, only the
1343 low 9 bits of @var{mode} are meaningful.  You can use the Lisp construct
1344 for octal character codes to enter @var{mode}; for example,
1346 @example
1347 (set-default-file-modes ?\644)
1348 @end example
1350 Saving a modified version of an existing file does not count as creating
1351 the file; it preserves the existing file's mode, whatever that is.  So
1352 the default file protection has no effect.
1353 @end defun
1355 @defun default-file-modes
1356 This function returns the current default protection value.
1357 @end defun
1359 @cindex MS-DOS and file modes
1360 @cindex file modes and MS-DOS
1361   On MS-DOS, there is no such thing as an ``executable'' file mode bit.
1362 So Emacs considers a file executable if its name ends in one of the
1363 standard executable extensions, such as @file{.com}, @file{.bat},
1364 @file{.exe}, and some others.  Files that begin with the Unix-standard
1365 @samp{#!} signature, such as shell and Perl scripts, are also considered
1366 as executable files.  This is reflected in the values returned by
1367 @code{file-modes} and @code{file-attributes}.  Directories are also
1368 reported with executable bit set, for compatibility with Unix.
1370 @node File Names
1371 @section File Names
1372 @cindex file names
1374   Files are generally referred to by their names, in Emacs as elsewhere.
1375 File names in Emacs are represented as strings.  The functions that
1376 operate on a file all expect a file name argument.
1378   In addition to operating on files themselves, Emacs Lisp programs
1379 often need to operate on file names; i.e., to take them apart and to use
1380 part of a name to construct related file names.  This section describes
1381 how to manipulate file names.
1383   The functions in this section do not actually access files, so they
1384 can operate on file names that do not refer to an existing file or
1385 directory.
1387   On MS-DOS and MS-Windows, these functions (like the function that
1388 actually operate on files) accept MS-DOS or MS-Windows file-name syntax,
1389 where backslashes separate the components, as well as Unix syntax; but
1390 they always return Unix syntax.  On VMS, these functions (and the ones
1391 that operate on files) understand both VMS file-name syntax and Unix
1392 syntax.  This enables Lisp programs to specify file names in Unix syntax
1393 and work properly on all systems without change.
1395 @menu
1396 * File Name Components::  The directory part of a file name, and the rest.
1397 * Directory Names::       A directory's name as a directory
1398                             is different from its name as a file.
1399 * Relative File Names::   Some file names are relative to a current directory.
1400 * File Name Expansion::   Converting relative file names to absolute ones.
1401 * Unique File Names::     Generating names for temporary files.
1402 * File Name Completion::  Finding the completions for a given file name.
1403 * Standard File Names::   If your package uses a fixed file name,
1404                             how to handle various operating systems simply.
1405 @end menu
1407 @node File Name Components
1408 @subsection File Name Components
1409 @cindex directory part (of file name)
1410 @cindex nondirectory part (of file name)
1411 @cindex version number (in file name)
1413   The operating system groups files into directories.  To specify a
1414 file, you must specify the directory and the file's name within that
1415 directory.  Therefore, Emacs considers a file name as having two main
1416 parts: the @dfn{directory name} part, and the @dfn{nondirectory} part
1417 (or @dfn{file name within the directory}).  Either part may be empty.
1418 Concatenating these two parts reproduces the original file name.
1420   On most systems, the directory part is everything up to and including
1421 the last slash (backslash is also allowed in input on MS-DOS or
1422 MS-Windows); the nondirectory part is the rest.  The rules in VMS syntax
1423 are complicated.
1425   For some purposes, the nondirectory part is further subdivided into
1426 the name proper and the @dfn{version number}.  On most systems, only
1427 backup files have version numbers in their names.  On VMS, every file
1428 has a version number, but most of the time the file name actually used
1429 in Emacs omits the version number, so that version numbers in Emacs are
1430 found mostly in directory lists.
1432 @defun file-name-directory filename
1433 This function returns the directory part of @var{filename} (or
1434 @code{nil} if @var{filename} does not include a directory part).  On
1435 most systems, the function returns a string ending in a slash.  On VMS,
1436 it returns a string ending in one of the three characters @samp{:},
1437 @samp{]}, or @samp{>}.
1439 @example
1440 @group
1441 (file-name-directory "lewis/foo")  ; @r{Unix example}
1442      @result{} "lewis/"
1443 @end group
1444 @group
1445 (file-name-directory "foo")        ; @r{Unix example}
1446      @result{} nil
1447 @end group
1448 @group
1449 (file-name-directory "[X]FOO.TMP") ; @r{VMS example}
1450      @result{} "[X]"
1451 @end group
1452 @end example
1453 @end defun
1455 @defun file-name-nondirectory filename
1456 This function returns the nondirectory part of @var{filename}.
1458 @example
1459 @group
1460 (file-name-nondirectory "lewis/foo")
1461      @result{} "foo"
1462 @end group
1463 @group
1464 (file-name-nondirectory "foo")
1465      @result{} "foo"
1466 @end group
1467 @group
1468 ;; @r{The following example is accurate only on VMS.}
1469 (file-name-nondirectory "[X]FOO.TMP")
1470      @result{} "FOO.TMP"
1471 @end group
1472 @end example
1473 @end defun
1475 @defun file-name-sans-versions filename &optional keep-backup-version
1476 This function returns @var{filename} with any file version numbers,
1477 backup version numbers, or trailing tildes discarded.
1479 If @var{keep-backup-version} is non-@code{nil}, then true file version
1480 numbers understood as such by the file system are discarded from the
1481 return value, but backup version numbers are kept.
1483 @example
1484 @group
1485 (file-name-sans-versions "~rms/foo.~1~")
1486      @result{} "~rms/foo"
1487 @end group
1488 @group
1489 (file-name-sans-versions "~rms/foo~")
1490      @result{} "~rms/foo"
1491 @end group
1492 @group
1493 (file-name-sans-versions "~rms/foo")
1494      @result{} "~rms/foo"
1495 @end group
1496 @group
1497 ;; @r{The following example applies to VMS only.}
1498 (file-name-sans-versions "foo;23")
1499      @result{} "foo"
1500 @end group
1501 @end example
1502 @end defun
1504 @defun file-name-sans-extension filename
1505 This function returns @var{filename} minus its ``extension,'' if any.
1506 The extension, in a file name, is the part that starts with the last
1507 @samp{.} in the last name component, except if that @samp{.} is the
1508 first character of the file name's last component.  For example,
1510 @example
1511 (file-name-sans-extension "foo.lose.c")
1512      @result{} "foo.lose"
1513 (file-name-sans-extension "big.hack/foo")
1514      @result{} "big.hack/foo"
1515 (file-name-sans-extension "/my/home/.emacs")
1516      @result{} "/my/home.emacs"
1517 (file-name-sans-extension "/my/home/.emacs.el")
1518      @result{} "/my/home/.emacs"
1519 @end example
1520 @end defun
1522 @ignore
1523 Andrew Innes says that this 
1525 @c @defvar directory-sep-char
1526 @c @tindex directory-sep-char
1527 This variable holds the character that Emacs normally uses to separate
1528 file name components.  The default value is @code{?/}, but on MS-Windows
1529 you can set it to @code{?\\}; then the functions that transform file names
1530 use backslashes in their output.
1532 File names using backslashes work as input to Lisp primitives even on
1533 MS-DOS and MS-Windows, even if @code{directory-sep-char} has its default
1534 value of @code{?/}.
1535 @end defvar
1536 @end ignore
1538 @defun file-name-extension filename &optional period
1539 This function returns @var{filename}'s final ``extension,'' if any,
1540 after applying @code{file-name-sans-versions} to remove any
1541 version/backup part.  It returns @code{nil} for extensionless file
1542 names such as @file{foo}.  If @var{period} is non-nil, then the
1543 returned value includes the period that delimits the extension, and if
1544 @var{filename} has no extension, the value is @code{""}.  If the last
1545 component of a file name begins with a @samp{.}, that @samp{.} doesn't
1546 count as the beginning of an extension, so, for example,
1547 @file{.emacs}'s ``extension'' is @code{nil}, not @samp{.emacs}.
1548 @end defun
1550 @node Directory Names
1551 @comment  node-name,  next,  previous,  up
1552 @subsection Directory Names
1553 @cindex directory name
1554 @cindex file name of directory
1556   A @dfn{directory name} is the name of a directory.  A directory is a
1557 kind of file, and it has a file name, which is related to the directory
1558 name but not identical to it.  (This is not quite the same as the usual
1559 Unix terminology.)  These two different names for the same entity are
1560 related by a syntactic transformation.  On most systems, this is simple:
1561 a directory name ends in a slash (or backslash), whereas the directory's
1562 name as a file lacks that slash.  On VMS, the relationship is more
1563 complicated.
1565   The difference between a directory name and its name as a file is
1566 subtle but crucial.  When an Emacs variable or function argument is
1567 described as being a directory name, a file name of a directory is not
1568 acceptable.
1570   The following two functions convert between directory names and file
1571 names.  They do nothing special with environment variable substitutions
1572 such as @samp{$HOME}, and the constructs @samp{~}, and @samp{..}.
1574 @defun file-name-as-directory filename
1575 This function returns a string representing @var{filename} in a form
1576 that the operating system will interpret as the name of a directory.  On
1577 most systems, this means appending a slash to the string (if it does not
1578 already end in one).  On VMS, the function converts a string of the form
1579 @file{[X]Y.DIR.1} to the form @file{[X.Y]}.
1581 @example
1582 @group
1583 (file-name-as-directory "~rms/lewis")
1584      @result{} "~rms/lewis/"
1585 @end group
1586 @end example
1587 @end defun
1589 @defun directory-file-name dirname
1590 This function returns a string representing @var{dirname} in a form that
1591 the operating system will interpret as the name of a file.  On most
1592 systems, this means removing the final slash (or backslash) from the
1593 string.  On VMS, the function converts a string of the form @file{[X.Y]}
1594 to @file{[X]Y.DIR.1}.
1596 @example
1597 @group
1598 (directory-file-name "~lewis/")
1599      @result{} "~lewis"
1600 @end group
1601 @end example
1602 @end defun
1604 @cindex directory name abbreviation
1605   Directory name abbreviations are useful for directories that are
1606 normally accessed through symbolic links.  Sometimes the users recognize
1607 primarily the link's name as ``the name'' of the directory, and find it
1608 annoying to see the directory's ``real'' name.  If you define the link
1609 name as an abbreviation for the ``real'' name, Emacs shows users the
1610 abbreviation instead.
1612 @defvar directory-abbrev-alist
1613 The variable @code{directory-abbrev-alist} contains an alist of
1614 abbreviations to use for file directories.  Each element has the form
1615 @code{(@var{from} . @var{to})}, and says to replace @var{from} with
1616 @var{to} when it appears in a directory name.  The @var{from} string is
1617 actually a regular expression; it should always start with @samp{^}.
1618 The function @code{abbreviate-file-name} performs these substitutions.
1620 You can set this variable in @file{site-init.el} to describe the
1621 abbreviations appropriate for your site.
1623 Here's an example, from a system on which file system @file{/home/fsf}
1624 and so on are normally accessed through symbolic links named @file{/fsf}
1625 and so on.
1627 @example
1628 (("^/home/fsf" . "/fsf")
1629  ("^/home/gp" . "/gp")
1630  ("^/home/gd" . "/gd"))
1631 @end example
1632 @end defvar
1634   To convert a directory name to its abbreviation, use this
1635 function:
1637 @defun abbreviate-file-name dirname
1638 This function applies abbreviations from @code{directory-abbrev-alist}
1639 to its argument, and substitutes @samp{~} for the user's home
1640 directory.
1641 @end defun
1643 @node Relative File Names
1644 @subsection Absolute and Relative File Names
1645 @cindex absolute file name
1646 @cindex relative file name
1648   All the directories in the file system form a tree starting at the
1649 root directory.  A file name can specify all the directory names
1650 starting from the root of the tree; then it is called an @dfn{absolute}
1651 file name.  Or it can specify the position of the file in the tree
1652 relative to a default directory; then it is called a @dfn{relative} file
1653 name.  On Unix and GNU/Linux, an absolute file name starts with a slash
1654 or a tilde (@samp{~}), and a relative one does not.  On MS-DOS and
1655 MS-Windows, an absolute file name starts with a slash or a backslash, or
1656 with a drive specification @samp{@var{x}:/}, where @var{x} is the
1657 @dfn{drive letter}.  The rules on VMS are complicated.
1659 @defun file-name-absolute-p filename
1660 This function returns @code{t} if file @var{filename} is an absolute
1661 file name, @code{nil} otherwise.  On VMS, this function understands both
1662 Unix syntax and VMS syntax.
1664 @example
1665 @group
1666 (file-name-absolute-p "~rms/foo")
1667      @result{} t
1668 @end group
1669 @group
1670 (file-name-absolute-p "rms/foo")
1671      @result{} nil
1672 @end group
1673 @group
1674 (file-name-absolute-p "/user/rms/foo")
1675      @result{} t
1676 @end group
1677 @end example
1678 @end defun
1680 @node File Name Expansion
1681 @subsection Functions that Expand Filenames
1682 @cindex expansion of file names
1684   @dfn{Expansion} of a file name means converting a relative file name
1685 to an absolute one.  Since this is done relative to a default directory,
1686 you must specify the default directory name as well as the file name to
1687 be expanded.  Expansion also simplifies file names by eliminating
1688 redundancies such as @file{./} and @file{@var{name}/../}.
1690 @defun expand-file-name filename &optional directory
1691 This function converts @var{filename} to an absolute file name.  If
1692 @var{directory} is supplied, it is the default directory to start with
1693 if @var{filename} is relative.  (The value of @var{directory} should
1694 itself be an absolute directory name; it may start with @samp{~}.)
1695 Otherwise, the current buffer's value of @code{default-directory} is
1696 used.  For example:
1698 @example
1699 @group
1700 (expand-file-name "foo")
1701      @result{} "/xcssun/users/rms/lewis/foo"
1702 @end group
1703 @group
1704 (expand-file-name "../foo")
1705      @result{} "/xcssun/users/rms/foo"
1706 @end group
1707 @group
1708 (expand-file-name "foo" "/usr/spool/")
1709      @result{} "/usr/spool/foo"
1710 @end group
1711 @group
1712 (expand-file-name "$HOME/foo")
1713      @result{} "/xcssun/users/rms/lewis/$HOME/foo"
1714 @end group
1715 @end example
1717 Filenames containing @samp{.} or @samp{..} are simplified to their
1718 canonical form:
1720 @example
1721 @group
1722 (expand-file-name "bar/../foo")
1723      @result{} "/xcssun/users/rms/lewis/foo"
1724 @end group
1725 @end example
1727 Note that @code{expand-file-name} does @emph{not} expand environment
1728 variables; only @code{substitute-in-file-name} does that.
1729 @end defun
1731 @c Emacs 19 feature
1732 @defun file-relative-name filename &optional directory
1733 This function does the inverse of expansion---it tries to return a
1734 relative name that is equivalent to @var{filename} when interpreted
1735 relative to @var{directory}.  If @var{directory} is omitted or
1736 @code{nil}, it defaults to the current buffer's default directory.
1738 On some operating systems, an absolute file name begins with a device
1739 name.  On such systems, @var{filename} has no relative equivalent based
1740 on @var{directory} if they start with two different device names.  In
1741 this case, @code{file-relative-name} returns @var{filename} in absolute
1742 form.
1744 @example
1745 (file-relative-name "/foo/bar" "/foo/")
1746      @result{} "bar"
1747 (file-relative-name "/foo/bar" "/hack/")
1748      @result{} "../foo/bar"
1749 @end example
1750 @end defun
1752 @defvar default-directory
1753 The value of this buffer-local variable is the default directory for the
1754 current buffer.  It should be an absolute directory name; it may start
1755 with @samp{~}.  This variable is buffer-local in every buffer.
1757 @code{expand-file-name} uses the default directory when its second
1758 argument is @code{nil}.
1760 Aside from VMS, the value is always a string ending with a slash.
1762 @example
1763 @group
1764 default-directory
1765      @result{} "/user/lewis/manual/"
1766 @end group
1767 @end example
1768 @end defvar
1770 @defun substitute-in-file-name filename
1771 This function replaces environment variables references in
1772 @var{filename} with the environment variable values.  Following standard
1773 Unix shell syntax, @samp{$} is the prefix to substitute an environment
1774 variable value.
1776 The environment variable name is the series of alphanumeric characters
1777 (including underscores) that follow the @samp{$}.  If the character following
1778 the @samp{$} is a @samp{@{}, then the variable name is everything up to the
1779 matching @samp{@}}.
1781 @c Wordy to avoid overfull hbox.  --rjc 15mar92
1782 Here we assume that the environment variable @code{HOME}, which holds
1783 the user's home directory name, has value @samp{/xcssun/users/rms}.
1785 @example
1786 @group
1787 (substitute-in-file-name "$HOME/foo")
1788      @result{} "/xcssun/users/rms/foo"
1789 @end group
1790 @end example
1792 After substitution, if a @samp{~} or a @samp{/} appears following a
1793 @samp{/}, everything before the following @samp{/} is discarded:
1795 @example
1796 @group
1797 (substitute-in-file-name "bar/~/foo")
1798      @result{} "~/foo"
1799 @end group
1800 @group
1801 (substitute-in-file-name "/usr/local/$HOME/foo")
1802      @result{} "/xcssun/users/rms/foo"
1803      ;; @r{@file{/usr/local/} has been discarded.}
1804 @end group
1805 @end example
1807 On VMS, @samp{$} substitution is not done, so this function does nothing
1808 on VMS except discard superfluous initial components as shown above.
1809 @end defun
1811 @node Unique File Names
1812 @subsection Generating Unique File Names
1814   Some programs need to write temporary files.  Here is the usual way to
1815 construct a name for such a file, starting in Emacs 21:
1817 @example
1818 (make-temp-file @var{name-of-application})
1819 @end example
1821 @noindent
1822 The job of @code{make-temp-file} is to prevent two different users or
1823 two different jobs from trying to use the exact same file name.
1825 @defun make-temp-file prefix &optional dir-flag
1826 @tindex make-temp-file
1827 This function creates a temporary file and returns its name.
1828 The name starts with @var{prefix}; it also contains a number that is
1829 different in each Emacs job.  If @var{prefix} is a relative file name,
1830 it is expanded against @code{temporary-file-directory}.
1832 @example
1833 @group
1834 (make-temp-file "foo")
1835      @result{} "/tmp/foo232J6v"
1836 @end group
1837 @end example
1839 When @code{make-temp-file} returns, the file has been created and is
1840 empty.  At that point, you should write the intended contents into the
1841 file.
1843 If @var{dir-flag} is non-@code{nil}, @code{make-temp-file} creates
1844 an empty directory instead of an empty file.
1846 To prevent conflicts among different libraries running in the same
1847 Emacs, each Lisp program that uses @code{make-temp-file} should have its
1848 own @var{prefix}.  The number added to the end of @var{prefix}
1849 distinguishes between the same application running in different Emacs
1850 jobs.  Additional added characters permit a large number of distinct
1851 names even in one Emacs job.
1852 @end defun
1854   The default directory for temporary files is controlled by the
1855 variable @code{temporary-file-directory}.  This variable gives the user
1856 a uniform way to specify the directory for all temporary files.  Some
1857 programs use @code{small-temporary-file-directory} instead, if that is
1858 non-@code{nil}.  To use it, you should expand the prefix against
1859 the proper directory before calling @code{make-temp-file}.
1861   In older Emacs versions where @code{make-temp-file} does not exist,
1862 you should use @code{make-temp-name} instead:
1864 @example
1865 (make-temp-name
1866  (expand-file-name @var{name-of-application}
1867                    temporary-file-directory))
1868 @end example
1870 @defun make-temp-name string
1871 This function generates a string that can be used as a unique file name.
1872 The name starts with @var{string}, and contains a number that is
1873 different in each Emacs job.  It is like @code{make-temp-file} except
1874 that it just constructs a name, and does not create a file.  On MS-DOS,
1875 the @var{string} prefix can be truncated to fit into the 8+3 file-name
1876 limits.
1877 @end defun
1879 @defvar temporary-file-directory
1880 @cindex @code{TMPDIR} environment variable
1881 @cindex @code{TMP} environment variable
1882 @cindex @code{TEMP} environment variable
1883 This variable specifies the directory name for creating temporary files.
1884 Its value should be a directory name (@pxref{Directory Names}), but it
1885 is good for Lisp programs to cope if the value is a directory's file
1886 name instead.  Using the value as the second argument to
1887 @code{expand-file-name} is a good way to achieve that.
1889 The default value is determined in a reasonable way for your operating
1890 system; it is based on the @code{TMPDIR}, @code{TMP} and @code{TEMP}
1891 environment variables, with a fall-back to a system-dependent name if
1892 none of these variables is defined.
1894 Even if you do not use @code{make-temp-name} to choose the temporary
1895 file's name, you should still use this variable to decide which
1896 directory to put the file in.  However, if you expect the file to be
1897 small, you should use @code{small-temporary-file-directory} first if
1898 that is non-@code{nil}.
1899 @end defvar
1901 @tindex small-temporary-file-directory
1902 @defvar small-temporary-file-directory
1903 This variable (new in Emacs 21) specifies the directory name for
1904 creating certain temporary files, which are likely to be small.
1906 If you want to write a temporary file which is likely to be small, you
1907 should compute the directory like this:
1909 @example
1910 (make-temp-file
1911   (expand-file-name @var{prefix}
1912                     (or small-temporary-file-directory
1913                         temporary-file-directory)))
1914 @end example
1915 @end defvar
1917 @node File Name Completion
1918 @subsection File Name Completion
1919 @cindex file name completion subroutines
1920 @cindex completion, file name
1922   This section describes low-level subroutines for completing a file
1923 name.  For other completion functions, see @ref{Completion}.
1925 @defun file-name-all-completions partial-filename directory
1926 This function returns a list of all possible completions for a file
1927 whose name starts with @var{partial-filename} in directory
1928 @var{directory}.  The order of the completions is the order of the files
1929 in the directory, which is unpredictable and conveys no useful
1930 information.
1932 The argument @var{partial-filename} must be a file name containing no
1933 directory part and no slash (or backslash on some systems).  The current
1934 buffer's default directory is prepended to @var{directory}, if
1935 @var{directory} is not absolute.
1937 In the following example, suppose that @file{~rms/lewis} is the current
1938 default directory, and has five files whose names begin with @samp{f}:
1939 @file{foo}, @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1940 @file{file.c.~2~}.@refill
1942 @example
1943 @group
1944 (file-name-all-completions "f" "")
1945      @result{} ("foo" "file~" "file.c.~2~" 
1946                 "file.c.~1~" "file.c")
1947 @end group
1949 @group
1950 (file-name-all-completions "fo" "")  
1951      @result{} ("foo")
1952 @end group
1953 @end example
1954 @end defun
1956 @defun file-name-completion filename directory
1957 This function completes the file name @var{filename} in directory
1958 @var{directory}.  It returns the longest prefix common to all file names
1959 in directory @var{directory} that start with @var{filename}.
1961 If only one match exists and @var{filename} matches it exactly, the
1962 function returns @code{t}.  The function returns @code{nil} if directory
1963 @var{directory} contains no name starting with @var{filename}.
1965 In the following example, suppose that the current default directory
1966 has five files whose names begin with @samp{f}: @file{foo},
1967 @file{file~}, @file{file.c}, @file{file.c.~1~}, and
1968 @file{file.c.~2~}.@refill
1970 @example
1971 @group
1972 (file-name-completion "fi" "")
1973      @result{} "file"
1974 @end group
1976 @group
1977 (file-name-completion "file.c.~1" "")
1978      @result{} "file.c.~1~"
1979 @end group
1981 @group
1982 (file-name-completion "file.c.~1~" "")
1983      @result{} t
1984 @end group
1986 @group
1987 (file-name-completion "file.c.~3" "")
1988      @result{} nil
1989 @end group
1990 @end example
1991 @end defun
1993 @defopt completion-ignored-extensions
1994 @code{file-name-completion} usually ignores file names that end in any
1995 string in this list.  It does not ignore them when all the possible
1996 completions end in one of these suffixes or when a buffer showing all
1997 possible completions is displayed.@refill
1999 A typical value might look like this:
2001 @example
2002 @group
2003 completion-ignored-extensions
2004      @result{} (".o" ".elc" "~" ".dvi")
2005 @end group
2006 @end example
2008 If an element of @code{completion-ignored-extensions} ends in a slash
2009 @samp{/}, it signals a directory.  The elements which do @emph{not} end
2010 in a slash will never match a directory; thus, the above value will not
2011 filter out a directory named @file{foo.elc}.
2012 @end defopt
2014 @node Standard File Names
2015 @subsection Standard File Names
2017   Most of the file names used in Lisp programs are entered by the user.
2018 But occasionally a Lisp program needs to specify a standard file name
2019 for a particular use---typically, to hold customization information
2020 about each user.  For example, abbrev definitions are stored (by
2021 default) in the file @file{~/.abbrev_defs}; the @code{completion}
2022 package stores completions in the file @file{~/.completions}.  These are
2023 two of the many standard file names used by parts of Emacs for certain
2024 purposes.
2026   Various operating systems have their own conventions for valid file
2027 names and for which file names to use for user profile data.  A Lisp
2028 program which reads a file using a standard file name ought to use, on
2029 each type of system, a file name suitable for that system.  The function
2030 @code{convert-standard-filename} makes this easy to do.
2032 @defun convert-standard-filename filename
2033 This function alters the file name @var{filename} to fit the conventions
2034 of the operating system in use, and returns the result as a new string.
2035 @end defun
2037   The recommended way to specify a standard file name in a Lisp program
2038 is to choose a name which fits the conventions of GNU and Unix systems,
2039 usually with a nondirectory part that starts with a period, and pass it
2040 to @code{convert-standard-filename} instead of using it directly.  Here
2041 is an example from the @code{completion} package:
2043 @example
2044 (defvar save-completions-file-name
2045         (convert-standard-filename "~/.completions")
2046   "*The file name to save completions to.")
2047 @end example
2049   On GNU and Unix systems, and on some other systems as well,
2050 @code{convert-standard-filename} returns its argument unchanged.  On
2051 some other systems, it alters the name to fit the system's conventions.
2053   For example, on MS-DOS the alterations made by this function include
2054 converting a leading @samp{.}  to @samp{_}, converting a @samp{_} in the
2055 middle of the name to @samp{.} if there is no other @samp{.}, inserting
2056 a @samp{.} after eight characters if there is none, and truncating to
2057 three characters after the @samp{.}.  (It makes other changes as well.)
2058 Thus, @file{.abbrev_defs} becomes @file{_abbrev.def}, and
2059 @file{.completions} becomes @file{_complet.ion}.
2061 @node Contents of Directories
2062 @section Contents of Directories
2063 @cindex directory-oriented functions
2064 @cindex file names in directory
2066   A directory is a kind of file that contains other files entered under
2067 various names.  Directories are a feature of the file system.
2069   Emacs can list the names of the files in a directory as a Lisp list,
2070 or display the names in a buffer using the @code{ls} shell command.  In
2071 the latter case, it can optionally display information about each file,
2072 depending on the options passed to the @code{ls} command.
2074 @defun directory-files directory &optional full-name match-regexp nosort
2075 This function returns a list of the names of the files in the directory
2076 @var{directory}.  By default, the list is in alphabetical order.
2078 If @var{full-name} is non-@code{nil}, the function returns the files'
2079 absolute file names.  Otherwise, it returns the names relative to
2080 the specified directory.
2082 If @var{match-regexp} is non-@code{nil}, this function returns only
2083 those file names that contain a match for that regular expression---the
2084 other file names are excluded from the list.
2086 @c Emacs 19 feature
2087 If @var{nosort} is non-@code{nil}, @code{directory-files} does not sort
2088 the list, so you get the file names in no particular order.  Use this if
2089 you want the utmost possible speed and don't care what order the files
2090 are processed in.  If the order of processing is visible to the user,
2091 then the user will probably be happier if you do sort the names.
2093 @example
2094 @group
2095 (directory-files "~lewis")
2096      @result{} ("#foo#" "#foo.el#" "." ".."
2097          "dired-mods.el" "files.texi" 
2098          "files.texi.~1~")
2099 @end group
2100 @end example
2102 An error is signaled if @var{directory} is not the name of a directory
2103 that can be read.
2104 @end defun
2106 @defun file-name-all-versions file dirname
2107 This function returns a list of all versions of the file named
2108 @var{file} in directory @var{dirname}.
2109 @end defun
2111 @tindex file-expand-wildcards
2112 @defun file-expand-wildcards pattern &optional full
2113 This function expands the wildcard pattern @var{pattern}, returning
2114 a list of file names that match it.
2116 If @var{pattern} is written as an absolute file name,
2117 the values are absolute also.
2119 If @var{pattern} is written as a relative file name, it is interpreted
2120 relative to the current default directory.  The file names returned are
2121 normally also relative to the current default directory.  However, if
2122 @var{full} is non-@code{nil}, they are absolute.
2123 @end defun
2125 @defun insert-directory file switches &optional wildcard full-directory-p
2126 This function inserts (in the current buffer) a directory listing for
2127 directory @var{file}, formatted with @code{ls} according to
2128 @var{switches}.  It leaves point after the inserted text.
2130 The argument @var{file} may be either a directory name or a file
2131 specification including wildcard characters.  If @var{wildcard} is
2132 non-@code{nil}, that means treat @var{file} as a file specification with
2133 wildcards.
2135 If @var{full-directory-p} is non-@code{nil}, that means the directory
2136 listing is expected to show the full contents of a directory.  You
2137 should specify @code{t} when @var{file} is a directory and switches do
2138 not contain @samp{-d}.  (The @samp{-d} option to @code{ls} says to
2139 describe a directory itself as a file, rather than showing its
2140 contents.)
2142 On most systems, this function works by running a directory listing
2143 program whose name is in the variable @code{insert-directory-program}.
2144 If @var{wildcard} is non-@code{nil}, it also runs the shell specified by
2145 @code{shell-file-name}, to expand the wildcards.
2147 MS-DOS and MS-Windows systems usually lack the standard Unix program
2148 @code{ls}, so this function emulates the standard Unix program @code{ls}
2149 with Lisp code.
2150 @end defun
2152 @defvar insert-directory-program
2153 This variable's value is the program to run to generate a directory listing
2154 for the function @code{insert-directory}.  It is ignored on systems
2155 which generate the listing with Lisp code.
2156 @end defvar
2158 @node Create/Delete Dirs
2159 @section Creating and Deleting Directories
2160 @c Emacs 19 features
2162   Most Emacs Lisp file-manipulation functions get errors when used on
2163 files that are directories.  For example, you cannot delete a directory
2164 with @code{delete-file}.  These special functions exist to create and
2165 delete directories.
2167 @defun make-directory dirname &optional parents
2168 This function creates a directory named @var{dirname}.
2169 If @var{parents} is non-@code{nil}, that means to create
2170 the parent directories first, if they don't already exist.
2171 @end defun
2173 @defun delete-directory dirname
2174 This function deletes the directory named @var{dirname}.  The function
2175 @code{delete-file} does not work for files that are directories; you
2176 must use @code{delete-directory} for them.  If the directory contains
2177 any files, @code{delete-directory} signals an error.
2178 @end defun
2180 @node Magic File Names
2181 @section Making Certain File Names ``Magic''
2182 @cindex magic file names
2184 @c Emacs 19 feature
2185   You can implement special handling for certain file names.  This is
2186 called making those names @dfn{magic}.  The principal use for this
2187 feature is in implementing remote file names (@pxref{Remote Files,,
2188 Remote Files, emacs, The GNU Emacs Manual}).
2190   To define a kind of magic file name, you must supply a regular
2191 expression to define the class of names (all those that match the
2192 regular expression), plus a handler that implements all the primitive
2193 Emacs file operations for file names that do match.
2195   The variable @code{file-name-handler-alist} holds a list of handlers,
2196 together with regular expressions that determine when to apply each
2197 handler.  Each element has this form:
2199 @example
2200 (@var{regexp} . @var{handler})
2201 @end example
2203 @noindent
2204 All the Emacs primitives for file access and file name transformation
2205 check the given file name against @code{file-name-handler-alist}.  If
2206 the file name matches @var{regexp}, the primitives handle that file by
2207 calling @var{handler}.
2209 The first argument given to @var{handler} is the name of the primitive;
2210 the remaining arguments are the arguments that were passed to that
2211 primitive.  (The first of these arguments is most often the file name
2212 itself.)  For example, if you do this:
2214 @example
2215 (file-exists-p @var{filename})
2216 @end example
2218 @noindent
2219 and @var{filename} has handler @var{handler}, then @var{handler} is
2220 called like this:
2222 @example
2223 (funcall @var{handler} 'file-exists-p @var{filename})
2224 @end example
2226 When a function takes two or more arguments that must be file names,
2227 it checks each of those names for a handler.  For example, if you do
2228 this:
2230 @example
2231 (expand-file-name @var{filename} @var{dirname})
2232 @end example
2234 @noindent
2235 then it checks for a handler for @var{filename} and then for a handler
2236 for @var{dirname}.  In either case, the @var{handler} is called like
2237 this:
2239 @example
2240 (funcall @var{handler} 'expand-file-name @var{filename} @var{dirname})
2241 @end example
2243 @noindent
2244 The @var{handler} then needs to figure out whether to handle
2245 @var{filename} or @var{dirname}.
2247 Here are the operations that a magic file name handler gets to handle:
2249 @ifnottex
2250 @noindent
2251 @code{add-name-to-file}, @code{copy-file}, @code{delete-directory},
2252 @code{delete-file},
2253 @code{diff-latest-backup-file},
2254 @code{directory-file-name},
2255 @code{directory-files},
2256 @code{dired-call-process},
2257 @code{dired-compress-file}, @code{dired-uncache},
2258 @code{expand-file-name},
2259 @code{file-accessible-directory-p},@*
2260 @code{file-attributes},
2261 @code{file-directory-p},
2262 @code{file-executable-p}, @code{file-exists-p},@*
2263 @code{file-local-copy},
2264 @code{file-modes}, @code{file-name-all-completions},@*
2265 @code{file-name-as-directory},
2266 @code{file-name-completion},
2267 @code{file-name-directory},
2268 @code{file-name-nondirectory},
2269 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2270 @code{file-ownership-preserved-p},
2271 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2272 @code{file-truename}, @code{file-writable-p},
2273 @code{find-backup-file-name},
2274 @code{get-file-buffer},@*
2275 @code{insert-directory},
2276 @code{insert-file-contents},
2277 @code{load}, @code{make-directory},
2278 @code{make-symbolic-link}, @code{rename-file}, @code{set-file-modes},
2279 @code{set-visited-file-modtime}, @code{shell-command},@*
2280 @code{unhandled-file-name-directory},
2281 @code{vc-registered},
2282 @code{verify-visited-file-modtime},@*
2283 @code{write-region}.
2284 @end ifnottex
2285 @iftex
2286 @noindent
2287 @flushleft
2288 @code{add-name-to-file}, @code{copy-file}, @code{delete-directory},
2289 @code{delete-file},
2290 @code{diff-latest-backup-file},
2291 @code{directory-file-name},
2292 @code{directory-files},
2293 @code{dired-call-process},
2294 @code{dired-compress-file}, @code{dired-uncache},
2295 @code{expand-file-name},
2296 @code{file-accessible-direc@discretionary{}{}{}tory-p},
2297 @code{file-attributes},
2298 @code{file-direct@discretionary{}{}{}ory-p},
2299 @code{file-executable-p}, @code{file-exists-p},
2300 @code{file-local-copy},
2301 @code{file-modes}, @code{file-name-all-completions},
2302 @code{file-name-as-directory},
2303 @code{file-name-completion},
2304 @code{file-name-directory},
2305 @code{file-name-nondirec@discretionary{}{}{}tory},
2306 @code{file-name-sans-versions}, @code{file-newer-than-file-p},
2307 @code{file-ownership-pre@discretionary{}{}{}served-p},
2308 @code{file-readable-p}, @code{file-regular-p}, @code{file-symlink-p},
2309 @code{file-truename}, @code{file-writable-p},
2310 @code{find-backup-file-name},
2311 @code{get-file-buffer},
2312 @code{insert-directory},
2313 @code{insert-file-contents},
2314 @code{load}, @code{make-direc@discretionary{}{}{}tory},
2315 @code{make-symbolic-link}, @code{rename-file}, @code{set-file-modes},
2316 @code{set-visited-file-modtime}, @code{shell-command},
2317 @code{unhandled-file-name-directory},
2318 @code{vc-regis@discretionary{}{}{}tered},
2319 @code{verify-visited-file-modtime},
2320 @code{write-region}.
2321 @end flushleft
2322 @end iftex
2324 Handlers for @code{insert-file-contents} typically need to clear the
2325 buffer's modified flag, with @code{(set-buffer-modified-p nil)}, if the
2326 @var{visit} argument is non-@code{nil}.  This also has the effect of
2327 unlocking the buffer if it is locked.
2329 The handler function must handle all of the above operations, and
2330 possibly others to be added in the future.  It need not implement all
2331 these operations itself---when it has nothing special to do for a
2332 certain operation, it can reinvoke the primitive, to handle the
2333 operation ``in the usual way''.  It should always reinvoke the primitive
2334 for an operation it does not recognize.  Here's one way to do this:
2336 @smallexample
2337 (defun my-file-handler (operation &rest args)
2338   ;; @r{First check for the specific operations}
2339   ;; @r{that we have special handling for.}
2340   (cond ((eq operation 'insert-file-contents) @dots{})
2341         ((eq operation 'write-region) @dots{})
2342         @dots{}
2343         ;; @r{Handle any operation we don't know about.}
2344         (t (let ((inhibit-file-name-handlers
2345                   (cons 'my-file-handler 
2346                         (and (eq inhibit-file-name-operation operation)
2347                              inhibit-file-name-handlers)))
2348                  (inhibit-file-name-operation operation))
2349              (apply operation args)))))
2350 @end smallexample
2352 When a handler function decides to call the ordinary Emacs primitive for
2353 the operation at hand, it needs to prevent the primitive from calling
2354 the same handler once again, thus leading to an infinite recursion.  The
2355 example above shows how to do this, with the variables
2356 @code{inhibit-file-name-handlers} and
2357 @code{inhibit-file-name-operation}.  Be careful to use them exactly as
2358 shown above; the details are crucial for proper behavior in the case of
2359 multiple handlers, and for operations that have two file names that may
2360 each have handlers.
2362 @defvar inhibit-file-name-handlers
2363 This variable holds a list of handlers whose use is presently inhibited
2364 for a certain operation.
2365 @end defvar
2367 @defvar inhibit-file-name-operation
2368 The operation for which certain handlers are presently inhibited.
2369 @end defvar
2371 @defun find-file-name-handler file operation
2372 This function returns the handler function for file name @var{file}, or
2373 @code{nil} if there is none.  The argument @var{operation} should be the
2374 operation to be performed on the file---the value you will pass to the
2375 handler as its first argument when you call it.  The operation is needed
2376 for comparison with @code{inhibit-file-name-operation}.
2377 @end defun
2379 @defun file-local-copy filename
2380 This function copies file @var{filename} to an ordinary non-magic file,
2381 if it isn't one already.
2383 If @var{filename} specifies a magic file name, which programs
2384 outside Emacs cannot directly read or write, this copies the contents to
2385 an ordinary file and returns that file's name.
2387 If @var{filename} is an ordinary file name, not magic, then this function
2388 does nothing and returns @code{nil}.
2389 @end defun
2391 @defun unhandled-file-name-directory filename
2392 This function returns the name of a directory that is not magic.  It
2393 uses the directory part of @var{filename} if that is not magic.  For a
2394 magic file name, it invokes the file name handler, which therefore
2395 decides what value to return.
2397 This is useful for running a subprocess; every subprocess must have a
2398 non-magic directory to serve as its current directory, and this function
2399 is a good way to come up with one.
2400 @end defun
2402 @node Format Conversion
2403 @section File Format Conversion
2405 @cindex file format conversion
2406 @cindex encoding file formats
2407 @cindex decoding file formats
2408   The variable @code{format-alist} defines a list of @dfn{file formats},
2409 which describe textual representations used in files for the data (text,
2410 text-properties, and possibly other information) in an Emacs buffer.
2411 Emacs performs format conversion if appropriate when reading and writing
2412 files.
2414 @defvar format-alist
2415 This list contains one format definition for each defined file format.
2416 @end defvar
2418 @cindex format definition
2419 Each format definition is a list of this form:
2421 @example
2422 (@var{name} @var{doc-string} @var{regexp} @var{from-fn} @var{to-fn} @var{modify} @var{mode-fn})
2423 @end example
2425 Here is what the elements in a format definition mean:
2427 @table @var
2428 @item name
2429 The name of this format.
2431 @item doc-string
2432 A documentation string for the format.
2434 @item regexp
2435 A regular expression which is used to recognize files represented in
2436 this format.
2438 @item from-fn
2439 A shell command or function to decode data in this format (to convert
2440 file data into the usual Emacs data representation).
2442 A shell command is represented as a string; Emacs runs the command as a
2443 filter to perform the conversion.
2445 If @var{from-fn} is a function, it is called with two arguments, @var{begin}
2446 and @var{end}, which specify the part of the buffer it should convert.
2447 It should convert the text by editing it in place.  Since this can
2448 change the length of the text, @var{from-fn} should return the modified
2449 end position.
2451 One responsibility of @var{from-fn} is to make sure that the beginning
2452 of the file no longer matches @var{regexp}.  Otherwise it is likely to
2453 get called again.
2455 @item to-fn
2456 A shell command or function to encode data in this format---that is, to
2457 convert the usual Emacs data representation into this format.
2459 If @var{to-fn} is a string, it is a shell command; Emacs runs the
2460 command as a filter to perform the conversion.
2462 If @var{to-fn} is a function, it is called with two arguments, @var{begin}
2463 and @var{end}, which specify the part of the buffer it should convert.
2464 There are two ways it can do the conversion:
2466 @itemize @bullet
2467 @item
2468 By editing the buffer in place.  In this case, @var{to-fn} should
2469 return the end-position of the range of text, as modified.
2471 @item
2472 By returning a list of annotations.  This is a list of elements of the
2473 form @code{(@var{position} . @var{string})}, where @var{position} is an
2474 integer specifying the relative position in the text to be written, and
2475 @var{string} is the annotation to add there.  The list must be sorted in
2476 order of position when @var{to-fn} returns it.
2478 When @code{write-region} actually writes the text from the buffer to the
2479 file, it intermixes the specified annotations at the corresponding
2480 positions.  All this takes place without modifying the buffer.
2481 @end itemize
2483 @item modify
2484 A flag, @code{t} if the encoding function modifies the buffer, and
2485 @code{nil} if it works by returning a list of annotations.
2487 @item mode-fn
2488 A minor-mode function to call after visiting a file converted from this
2489 format.  The function is called with one argument, the integer 1;
2490 that tells a minor-mode function to enable the mode.
2491 @end table
2493 The function @code{insert-file-contents} automatically recognizes file
2494 formats when it reads the specified file.  It checks the text of the
2495 beginning of the file against the regular expressions of the format
2496 definitions, and if it finds a match, it calls the decoding function for
2497 that format.  Then it checks all the known formats over again.
2498 It keeps checking them until none of them is applicable.
2500 Visiting a file, with @code{find-file-noselect} or the commands that use
2501 it, performs conversion likewise (because it calls
2502 @code{insert-file-contents}); it also calls the mode function for each
2503 format that it decodes.  It stores a list of the format names in the
2504 buffer-local variable @code{buffer-file-format}.
2506 @defvar buffer-file-format
2507 This variable states the format of the visited file.  More precisely,
2508 this is a list of the file format names that were decoded in the course
2509 of visiting the current buffer's file.  It is always buffer-local in all
2510 buffers.
2511 @end defvar
2513 When @code{write-region} writes data into a file, it first calls the
2514 encoding functions for the formats listed in @code{buffer-file-format},
2515 in the order of appearance in the list.
2517 @deffn Command format-write-file file format
2518 This command writes the current buffer contents into the file @var{file}
2519 in format @var{format}, and makes that format the default for future
2520 saves of the buffer.  The argument @var{format} is a list of format
2521 names.
2522 @end deffn
2524 @deffn Command format-find-file file format
2525 This command finds the file @var{file}, converting it according to
2526 format @var{format}.  It also makes @var{format} the default if the
2527 buffer is saved later.
2529 The argument @var{format} is a list of format names.  If @var{format} is
2530 @code{nil}, no conversion takes place.  Interactively, typing just
2531 @key{RET} for @var{format} specifies @code{nil}.
2532 @end deffn
2534 @deffn Command format-insert-file file format &optional beg end
2535 This command inserts the contents of file @var{file}, converting it
2536 according to format @var{format}.  If @var{beg} and @var{end} are
2537 non-@code{nil}, they specify which part of the file to read, as in
2538 @code{insert-file-contents} (@pxref{Reading from Files}).
2540 The return value is like what @code{insert-file-contents} returns: a
2541 list of the absolute file name and the length of the data inserted
2542 (after conversion).
2544 The argument @var{format} is a list of format names.  If @var{format} is
2545 @code{nil}, no conversion takes place.  Interactively, typing just
2546 @key{RET} for @var{format} specifies @code{nil}.
2547 @end deffn
2549 @defvar auto-save-file-format
2550 This variable specifies the format to use for auto-saving.  Its value is
2551 a list of format names, just like the value of
2552 @code{buffer-file-format}; however, it is used instead of
2553 @code{buffer-file-format} for writing auto-save files.  This variable is
2554 always buffer-local in all buffers.
2555 @end defvar